android框架MVP封装Base类学习总结

1、首先，就是封装IBaseView，这里面没什么需要做的，所以就只要一个方法，就是显示错误信息

        

public interface IBaseView {
    /**
     * 显示错误信息
     * @param msg
     */
    void showErrorMessage(String msg);
}

2、然后，我们就需要根据自己的实际情况，写出显示自己需要展示View的方法，我这里呢就是根据某站上的一个大佬的视频学习的显示一个ListView

public interface IFruitView extends IBaseView {
    /**
     * 显示listView
     * @param fruits
     */
    void showFruitView(List<Fruit> fruits);
}

3、上面就是VIew层也就是视图层，下面呢我们就看一下Model层，也就是业务逻辑层吧，在IBaseModel这里面去加载数据源，如数据库操作等，进行数据逻辑处理，这里，我们创建了一个内部接口，用于监听数据源加载成功还是失败。然后就是加载数据源的方法

public interface IBaseModel {
    /**
     * 加载数据源的监听事件
     */
    interface onLoadListener{

        /**
         * 数据加载成功
         * @param fruits
         */
        void onComplete(List<Fruit> fruits);

        /**
         * 数据加载失败
         */
        void onError();
    }
    void loadData(onLoadListener onLoadListener);
}

4、根据自己的需要去实现IBaseModel，加载数据源，这里我们就是创建了FruitModel去实现IBaseModel

public class FruitModel implements IBaseModel {
    private List<Fruit> fruits = new ArrayList<>();
    @Override
    public void loadData(onLoadListener onLoadListener) {
        onLoadListener.onComplete(getData());
    }

    private List<Fruit> getData() {
        for (int i = 0; i < 10; i++) {
            fruits.add(new Fruit("apple", R.drawable.apple_pic));
        }
        return fruits;
    }
}

5、接下来就到了P层，也就是Presenter层，这里的话，我们定义的Base类的话主要就是为了完全解决内存泄露，所以我们使用了若引用和手动绑定和解绑View,并且监听表示层的生命周期

public class BasePresenter<T extends IBaseView> implements LifecycleObserver {
    /**
     * 弱引用加手动绑定和解绑，加快回收速度
     */
    public WeakReference<T> fruitView;

    /**
     * 绑定
     * @param view
     */
    public void attachView(T view){
        fruitView = new WeakReference<>(view);
    }

    /**
     * 解除绑定
     * @param view
     */
    public void detachView(T view){
        if (fruitView != null){
            fruitView.clear();
            fruitView = null;
        }
    }

    /**
     * 监听表示层的生命周期
     * @param owner
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(LifecycleOwner owner){}
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy(LifecycleOwner owner){}

}

6、然后我们自己的一个Presenter就去继承这个BasePresenter,执行自己的业务逻辑，监听生命周期

public class FruitPresenter<T extends IFruitView> extends BasePresenter{
    private FruitModel fruitModel = new FruitModel();

    /**
     * 执行业务逻辑
     */
    public void fetch(){
        fruitModel.loadData(new IBaseModel.onLoadListener() {
            @Override
            public void onComplete(List<Fruit> fruits) {
                ((T)fruitView.get()).showFruitView(fruits);
            }

            @Override
            public void onError() {

            }
        });
    }

    /**
     * 监听表示层的生命周期
     * @param owner
     */
    @Override
    void onCreate(LifecycleOwner owner) {
        super.onCreate(owner);
        Log.i("jett","onCreate");
    }

    @Override
    void onDestroy(LifecycleOwner owner) {
        super.onDestroy(owner);
        Log.i("jett","onDestroy");
    }
}

好了，到了Activity里面了，我们看一下BaseActivity,在这里面，我们做的事情主要就是定义一个泛型的presenter,然后使用抽象方法的方式，使得自己的Activity可以根据自己的需要去创建自己的Presenter,然后绑定View，所以我们自己的Activity就不用去绑定View和解除绑定了

abstract class BaseActivity<T extends BasePresenter,V extends IBaseView> extends AppCompatActivity {

    //创建Presenter
    protected T presenter;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        presenter = createPresenter();
        //绑定View
        presenter.attachView((V)this);
        registSDK();
        unRegistSDK();
        //初始化
        init();
    }

    /**
     * 创建presenter
     * @return
     */
    protected abstract T createPresenter();

    /**
     * 模板方法
     */
    public void registSDK(){};
    public void unRegistSDK(){};
    public void init(){};

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //解绑View
        presenter.detachView((V)this);
    }
}

好了，看一下我们自己的Activity，这里面我们的工作就特别轻松，重写父类的方法，然后，只需要完成简单的几步就可以了，在重写的createPresenter里面，我们创建了自己的FruitPresenter,返回的结果就是presenter,在onCreate（）方法-----Activity创建的时候,首先加载了自己的布局控件listView，然后就直接通过重写的ShowFruitView，在这里面去给控件设置自己的适配器然后就直接用Presenter去调用fetch()方法执行业务逻辑，就ok了

public class MainActivity extends BaseActivity<FruitPresenter, IFruitView> implements IFruitView {

    private ListView listView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        listView = findViewById(R.id.lv_list_view);
        presenter.fetch();
    }

    @Override
    protected FruitPresenter createPresenter(){
        return new FruitPresenter();
    }

    @Override
    public void showFruitView(List<Fruit> fruits) {
        listView.setAdapter(new FruitAdapter(this,R.layout.fruit_item,fruits));
    }

    @Override
    public void showErrorMessage(String msg) {

    }

    /**
     * 初始化绑定LifeCycle和表示层
     */
    @Override
    public void init() {
        super.init();
        getLifecycle().addObserver(presenter);
    }
}

执行结果：（内网传不了图片。。。。），个人理解也就到这个地步了，若有不对的地方还请多多指正，玻璃心，不喜勿喷，谢谢=。=