Android MVP模式中，一个Activity对应多个Presenter时该怎样抽象？

Question

这是网上常见的MvpActivity基类

public abstract class BaseMvpActivity<t extends BaseAdapter> extends AppCompatActivity {   
 
    public T presenter;    
 
     @Override  
     protected void onCreate(Bundle savedInstanceState) {        
         super.onCreate(savedInstanceState);        
         presenter = initPresenter();   
     }    
 
     @Override   
     protected void onResume() {        
          super.onResume();        
          presenter.attach((V)this);    
     }    
 
     @Override   
     protected void onDestroy() {       
        presenter.dettach();        
        super.onDestroy();    
     }   
 
     public abstract T initPresenter();
 
}

这个基类完成了presenter的实例化、presenter持有的Activity对象的释放.
那么当一个Activity有多个功能时，应该怎样实现呢。

我想，一种方法是让一个presenter实现多个功能，这时可以继续用上面的基类，但是程序的功能不容易复用。比如Activity1有功能A和B，Activity2有功能C和D，当Activity3有功能A和D时，无法复用Activity1和2的presenter； 一种方法是一个Activity持有多个presenter，这时就要重写BaseActivity，我写了一个，如下：

public abstract class MvpActivity extends BaseActivity {
    protected Map<String, BasePresenter> presenters;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        presenters = createPresenter();
        super.onCreate(savedInstanceState);
    }

    protected abstract Map<String, BasePresenter> createPresenter();

    @Override
    protected void onDestroy() {
        super.onDestroy();
        for (Map.Entry<String, BasePresenter> entry : presenters.entrySet()) {
            if (entry.getValue() != null) {
                entry.getValue().detachView();
            }
        }
    }

    protected BasePresenter getPresenter(){
        return presenters.entrySet().iterator().next().getValue();
    }

    protected BasePresenter getPresenter(String key){
        return presenters.get(key);
    }
}

但是这个基类使用起来很别扭，说他别扭是因为：
在第一版中有public T presenter这个变量，可以直接调用presenter的功能，第二版中首先要调用getPresenter，还要类型转换才能使用。还有在createPresenter抽象方法实现起来不想第一版那么直观。

我JAVA功力不够，还请各位指点一下。

Answer 1

Une activité correspond à un présentateur A, puis le présentateur correspondant A peut être développé. Il n'est utilisé que comme classe proxy, et d'autres implémentations spécifiques sont implémentées par d'autres présentateurs B, C et D. De cette façon, là il n'est pas nécessaire de changer l'activité. La méthode appelante peut également réutiliser le présentateur, mais cela semble bizarre. . .

Answer 2

Il existe des contraintes de protocole entre View et Presenter.
En supposant qu'il existe des V1, P1, V2, P2, et qu'une ActivityA correspond aux fonctions de P1/P2, elle doit également indiquer qu'elle implémente la V1/. Interface V2. Il devrait y avoir PresenterA qui implémente P1 et P2. Il s'agit du protocole VP complet.
Étant donné que plusieurs pages peuvent utiliser la même fonction, Le moyen le plus simple est d'utiliser l'héritage multiple sur mon nœud (un présentateur implémente les quatre interfaces ABCD), de sorte que quelle que soit l'activité, le même présentateur soit réellement utilisé. Si vous êtes sûr qu'il a été implémenté, implémentez simplement un agent en conséquence. à la méthode ci-dessus.

Si vous souhaitez vraiment implémenter plusieurs présentateurs, vous pouvez définir plusieurs classes différentes pour prendre en charge l'extension de différents présentateurs multiples :

class BaseMvpActivity1<P> extent BaseActivity {
    P presenter;
}
class BaseMvpActivity2<P1, P2> extent BaseActivity {
    P1 presenter1;
    P2 presenter2;
}

Mais cela n'est pas recommandé (perte de l'abstraction et violation du principe d'inversion des dépendances) ; il est également déconseillé d'utiliser des tableaux ou des listes (la classe de base utilise des génériques pour faciliter la vérification du compilateur, et les tableaux ou les listes doivent être saisis lorsque utilisé spécifiquement)

Answer 3

http://blog.csdn.net/github_3... Il y a une introduction dedans