Interfaccia / classe del contratto con classi interne / interfacce

4

Breve descrizione della struttura del mio progetto.

Ho alcune classi base come BaseView , BasePresenter .... Anche il mio progetto è costituito da moduli, il modulo rappresenta una parte completa dell'applicazione.
Ogni modulo ha il proprio Presenter , View ...
Ma anche ogni modulo ha il proprio Base<ModuleName>Presenter ..., in cui sono definiti i requisiti specifici del modulo.
All'inizio ho usato un file separato per tutte queste classi, ma poi ho trovato un altro approccio, che mi sembra interessante.

L'idea è creare Contract class \ interface dove sono localizzate tutte le classi di base specifiche del modulo.

Ecco un esempio.

public interface StatisticsContract {

    interface View extends BaseView<Presenter> {

        void setProgressIndicator(boolean active);

        void showStatistics(int numberOfIncompleteTasks, int numberOfCompletedTasks);

        void showLoadingStatisticsError();

        boolean isActive();
    }

    interface Presenter extends BasePresenter {

    }
}

O

public interface ModesListContract {
    static abstract class Presenter extends BasePresenter {

    }

    interface View extends BaseView {

    }
}

Personalmente trovo questo utile raggruppare tutte le classi base in un posto e questo diventa una specie di modello - Contract . So dove si trovano tutte le interfacce di base per il modulo specifico. Ho anche visto un simile approccio nel codice sorgente di Google Android.

D'altra parte, sembra una violazione di Single Responsibility Principle e alcune altre pratiche conosciute.

Quindi non sono sicuro che sia corretto usare questo approccio o questa è una cattiva pratica che dovrebbe essere evitata.

Sarei grato per qualsiasi risposta.

Grazie

    
posta CROSP 18.12.2016 - 15:26
fonte

1 risposta

1

The idea is create Contract class\interface where all module specific base classes\interfaces are located.

Questo in effetti sembra una violazione di ISP .

Capisco che l'applicazione abbia una serie di moduli standardizzati, per i quali si desidera avere un accoppiamento basso e la possibilità di scambiare l'implementazione del modulo. In tal caso, suggerirei di creare un namespace Application / Contract / Modules (pacchetto in caso di Java), creare uno spazio secondario per ciascuno dei moduli e inserire tutte le interfacce specifiche del modulo.

Tutte le interfacce, condivise da tutti (o dalla maggior parte dei moduli), dovrebbero andare nello spazio dei nomi / pacchetto di Applicazione / Contratto.

Se si posiziona la definizione dell'interfaccia del modulo su un modulo stesso, si verificherà un problema con lo swapping dell'implementazione. Il tuo nuovo modulo dipenderà da uno vecchio, perché quello vecchio contiene la definizione dell'interfaccia.

    
risposta data 19.12.2016 - 12:16
fonte