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

一个activity对应一个presenter A，然后对应的这个presenter A中可以拓展下，它只做为一个代理类，其它具体实现交给其它的presenter B、C、D去实现，这样是不用改变activity的调用方式，也可以复用presenter，不过感觉怪怪的。。。

Answer 2

View 和 Presenter 之间是有协议约束的.
假设现有V1, P1, V2, P2, 一个ActivityA对应了P1/P2的功能, 也应该说明它实现了V1/V2接口, 此时应该有PresenterA 实现了P1, P2. 这就是完整的VP的协议就对上了.
这里既然多个页面可能用到同样的功能, 最简单的方式我节点使用多继承(一个Persenter实现ABCD四个接口), 这样不管Activity实际上用的都是同一个Persenter.如果确定现在已经有实现了, 按楼上的方法实现一个代理就可以了.

实在要实现多个Presenter的话, 可以定义几个不同的类, 来支持不同多个Presenter的扩展:

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

但不推荐这样做(失去抽象, 违反依赖倒置原则); 更不推荐使用数组或List(基类使用泛型方便编译器检查, 数组或List在具体使用时需要做类型的强转)

Answer 3

http://blog.csdn.net/github_3... 里面有介绍

Answer 4

可以把你的Activity的代表的View层抽象成很多view(自定义组合空间),通过定义你生命周期的接口和你实际的View层(Activity)绑定起来，这样你的view和presenter就是1对1的关系

Answer 5

android小白，虽然开发中尽量避免一对多，但还是遇到了这个问题。
最终思路也是将多个VP化为一个VP。
但是PresenterAImpl中的实现存在破坏封装的问题，还请大神赐教。

/* 定义View和Presenter接口，及代理View和Presenter接口 */
public interface TestContract {
    /* 业务A view */
    interface IViewA extends BaseView {
        void viewFuncA();
    }

    /* 业务B view */
    interface IViewB extends BaseView{
        void viewFuncB();
    }
    
    /* 因为两个业务在一个Activity/Fragment中实现，所以提供一个代理接口IViewAll，并用作Presenter模板参数（不然多重继承参数不一致的模板会出错） */
    interface IViewAll extends IViewA, IViewB {
    }

    /* 业务A presenter */
    interface IPresenterA extends IPresenter<IViewAll> {
        void presenterA();
    }

    /* 业务B presenter */
    interface IPresenterB extends IPresenter<IViewAll>{
        void presenterB();
    }

    /* 代理Presenter接口 */
    interface IPresenterAll extends IPresenterA, IPresenterB{
        
    }
}

public class PresenterAImpl extends BasePresenter<TestContract.IViewAll> implements TestContract.IPresenterA{
    public void viewFuncA(){
        /* 具体的实现 */
        /* 但是这里有个问题，就是模板参数是IViewAll，也就是说在PresenterA中可以访问ViewB的接口，破坏了封装。尚未找到好的解决办法。。。 */
    }
}

public class PresenterBImpl extends BasePresenter<TestContract.IViewAll> implements TestContract.IPresenterB{
    public void viewFuncB(){
        /* 具体的实现 */
    }
}

public class PresenterAllImpl extends BasePresenter<TestContract.IViewAll> implements TestContract.IPresenterAll{
    TestContract.IPresenterA mPresenterA = new PresenterAImpl();
    TestContract.IPresenterB mPresenterB = new PresenterBImpl();

    /* 分别调用mPresenterA和mPresenterA的接口 */
    @Override
    public void viewFuncA(){
        mPresenterA.viewFuncA();
    }
    @Override
    public void viewFuncB(){
        mPresenterB.viewFuncB();
    }
    
    /* 重写生命周期绑定接口，不然被代理的对象还没有绑定view */
    @Override
    public void attachView(TestContract.IViewAll view) {
        super.attachView(view);
        mPresenterA.attachView(view);
        mPresenterB.attachView(view);
    }
    
    @Override
    public void detachView() {
        super.detachView();
        mPresenterA.detachView();
        mPresenterB.detachView();
    }
}