一、内容概要

今天来实战一个简单实用的基于MVP模式的简单的基础架构，主要基于前一个章节中的BaseActivity，在其基础上实现一个BaseMvpActivity。其定义了MVP的通用规范，所有的要实现MVP的Activity都需要集成该类。

类构成介绍：

1.BaseModel所有model的基类

2.BasePresenter所有Presenter的基类

3.IBaseView所有的Veiw都要实现的接口

4.BaseActivity所有Activity的基类

5.BaseMvpActivity所有要实现MVP模式的Activity的基类

优点：让Model和View解耦，使presenter充当他们之间的桥梁。扩展和维护性比较好

缺点：接口和类会暴增

选择：多人协作的项目（或者稍大点的项目），可以使用该模式明确每个人的分工，同时也使项目更加容易维护

废话不多说，下面直接来看看具体的代码怎样写。ps：相关的比较重要的内容都在注释中加了解释

二、实战部分

/**
 * Mvp模式的model基类
 * create by yangwei
 * on 2020/7/23 16:44
 */
open class BaseModel {
  //所有model的基类，先做定义然后备用
  //此处必须加上open关键字子类才有可能继承，否则该类不能被集成，因为如果不加
  //其编译后是public static final的
}

/**
 * MVP模式的presenter基类，
 * create by yangwei
 * on 2020/7/23 16:45
 */
abstract class BasePresenter<M : BaseModel, V : IBaseView> {
    //这里的泛型重点提下：Kotlin的泛型和java的泛型差不多，但是语法上差异比较大，
    //例如：java中泛型的上限、下限、类型通配符分别是extends、supper、？
    //kotlin中的泛型的上限、下限、通配符分别是out、in、* 。且Kotlin中对上限的通配符可以省略
    //但是java中不能省略，等下到BaseMvpActivity的时候大家大概就明白了什么意思了。这里我做一个
    //粗略的概要，同学如果不明白可以专门看一下泛型                       
    private var mProxyView: V? = null
    private var model: M? = null
    //弱引用防止内存泄露
    private var weakReference: WeakReference<IBaseView>? = null

    /**
     * 绑定View
     */
    fun attachView(view: IBaseView) {
        weakReference = WeakReference(view)
      //这里用动态代理来生成一个IBaseView的子类
        mProxyView = Proxy.newProxyInstance(
            view.javaClass.classLoader,
            view.javaClass.interfaces,
            this.MvpViewHandler(weakReference?.get() as IBaseView)
        ) as V//此处的as相当于java中的instanceof+强制类型转换
				//在子persenter中延时初始化model
        if (model == null) {
            model = createModel()
        }

    }

    /**
     * 解绑View
     */
    fun detachView() {
      	//此处操作是为了防止内存泄漏
        this.model = null
        if (!isViewDetached()) {
            weakReference?.clear()
            weakReference = null
        }
    }

    /**
     * 是否与View断开连接
     */
    fun isViewDetached(): Boolean {
        return weakReference == null || weakReference?.get() == null
    }

    /**
     * 获取View
     */
    fun getView(): V? {
        return mProxyView
    }

    /**
     * 获取Model
     */
    fun getModel(): BaseModel? {
        return model
    }

    fun showLoadding() {
        getView()?.showLoadding()
    }

    fun getContext(): Context? {
        return getView()?.getContext2()
    }

    fun getLifecycleOwner(): LifecycleOwner? {
        return getView()?.getLifecycleOwner()
    }

    fun dismissLoadding() {
        getView()?.dismissLoadding()
    }

    /**
     * 如果model不存在则创建一个Model
     */
    abstract fun createModel(): M

    /**
     * 开始
     */
    abstract fun start()
    inner class MvpViewHandler : InvocationHandler {
        private var mvpView: IBaseView? = null

        constructor(mvpView: IBaseView?) {
            this.mvpView = mvpView
        }

        override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any? {
            //如果V层没有被销毁，则执行V层的方法
            if (!isViewDetached()) {
                return method!!.invoke(mvpView, *(args ?: arrayOfNulls<Any>(0)))

//                return method?.invoke(mvpView, args)
            }
            return null
        }

    }
}

/**
 * MVP模式的View基类
 * create by yangwei
 * on 2020/7/23 16:44
 */
interface IBaseView {
    /**
     * 显示加载框
     */
    fun showLoadding()

    /**
     * 关闭加载框
     */
    fun dismissLoadding()

    /**
     * 当从module中获取到的数据为空的时候调用
     */
    fun onEmpty(any: Any?)

    /**
     * 当发生错误的时候调用
     */
    fun onError(any: Any?, errorMsg: String)

    /**
     * 上下文环境变量
     */
    fun getContext2(): Context?

    /**
     * 返回页面生命周期
     */
    fun getLifecycleOwner(): LifecycleOwner?
}

/**
 * 所有要使用Mvp模式的Activity的基类
 * create by yangwei
 * on 2020/7/23 16:39
 */
abstract class BaseMvpActivity<P : BasePresenter<*, *>> : BaseActivity(),
    IBaseView {
    //这里的*，*就是kotlin中传说的泛型通配符，上面有提到
    private var presenter: P? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    		//在onCreate方法中创建presenter
        presenter = createPresenter()
        presenter?.attachView(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        //解除绑定
        presenter?.detachView()
        presenter = null
    }

    //显示加载框
    override fun showLoadding() {

    }

    /**
     * 创建一个presenter，在子类中对presenter进行初始化
     */
    abstract fun createPresenter(): P
}

三、重点总结

以上的例子中想要看的明白首先要对：泛型、模板方法模式、动态代理需要有一定的了解

如果不是很明白，大家去补充下这些基础知识

四、结束语

恩，本小节就这样结束了，复制代码走一遍试试看。主要是大家把这个架子搭建好，然后基于这个架子，自己写一下子类然后跑一遍，之后才能理解的更深一点。