Android 使用kotlin+注解+反射+泛型实现MVP架构

一，MVP模式的定义

①Model：用于存储数据。它负责处理领域逻辑以及与数据库或网络层的通信。

②View：UI层，提供数据可视化界面，并跟踪用户的操作，以便通知presenter。

③Presenter：从Model层获取数据，并且应用UI逻辑来决定显示什么。它管理View的状态，并且根据来自于View的用户的输入执行动作。

实现mvp模式的核心点就是将view层和presenter绑定，将view层和model层解耦

二，代码实现

首先，我们先三个基本的接口：

/**
*View层接口
*/
interface IView {

    fun getContext(): Context?

    fun getRootViews(): View?

    fun <T : View?> getView(id: Int): T

    fun getActivity(): Activity?

    fun getFragment(): Fragment?
}

/**
 * module层接口
 * */
interface IModule {
}

/**
 * Presenter层接口
 * */
interface IPresenter {
    fun onCreate(savedInstanceState: Bundle?, mContext: Context?)

    fun onResume()

    fun onStart()

    fun onRestart()

    fun onPause()

    fun onStop()

    fun onDestroy()

    fun onSaveInstanceState(outState: Bundle)

    fun onRestoreInstanceState(savedInstanceState :Bundle)

    fun onActivityResult( requestCode :Int, resultCode :Int, data : Intent)


}

View层主要是获取Activity，布局文件等操作

Presenter层主要是控制Activity生命周期等

Module层就是用户根据自己的业务逻辑具体的自己去定义

接下来我们就利用反射+注解，在系统启动activity的时候，自动的生成相应的presenter实例，这样就不用手动去绑定view和presenter了

创建一个注解：

@Retention(AnnotationRetention.RUNTIME)
annotation class Request(val value:KClass<*>)

在运行时生效，传入kotlin的Class实例KClass

采用工厂模式来生产presenter

先创建一个工厂模式的接口：

interface IPresenterFactory<P> {

    /**
     * 创建presenter
     * */
    fun createPresenter():P
}

因为我的Presenter需要等到运行的时候才会知道是哪个，所以使用泛型P代表

创建具体的Presenter工厂类，在静态方法findClass中，通过传入的Activity获得Activity的注解，并通过注解获得相应的presenter的Class

在createPresenter方法中，通过presenter的Class反射生成presenter对象

class PresenterFactory<P>() :IPresenterFactory<P>{

    private var presenterKClass :KClass<*> ?=null

    constructor(presenterKClass :KClass<*>): this(){
        this.presenterKClass =presenterKClass
    }

    companion object{
        fun <P> findClass(viewClass:Class<*>) : PresenterFactory<P>{
            val annotation = viewClass.getAnnotation(Request::class.java)
            val value:KClass<*> =annotation.value
            return PresenterFactory(value)
        }
    }

    override fun createPresenter(): P {
        return presenterKClass?.java!!.newInstance() as P
    }

}

创建一个BasePresenter，实现IPresenter接口，将具体的View层的实例传过来。因为不知道具体的View是哪一个，所以使用泛型T表示

abstract class BasePresenter<T> :IPresenter{

    protected var mView: @UnsafeVariance T? = null

    fun attachViewCompont(view: T) {
        mView = view
    }

    fun detechViewCompont() {
        mView = null
    }

    abstract fun setListeners()
}

为了实现设计模式的单一性原则，我们增加一个工厂类的代理类，来控制presenter的创建，已及view的绑定等操作：

class PresenterDelegate<P,V>() where P:BasePresenter<V>,V:IView {

    private var presenterFactory :IPresenterFactory<P>?=null

    private var presenter :P ?=null

    constructor(presenterFactory :IPresenterFactory<P>):this(){
        this.presenterFactory =presenterFactory
    }

    open fun getPresenter():P{
        if(presenter!=null){
            return presenter!!
        }
        if (presenterFactory != null) {
            if (presenter == null) {
                presenter = presenterFactory?.createPresenter()
            }
        }
        return presenter!!
    }

    open fun setPresenter(presenter: P) {
        this.presenter = presenter
    }

   

    open fun bindViewCompont(view: IView) {
        if (presenter == null) {
            getPresenter()
        }
        if (presenter != null) {
            presenter!!.attachViewCompont(view as V)
        }
    }

    open fun unbindViewCompont() {
        if (presenter != null) {
            presenter!!.detechViewCompont()
        }
    }

}

创建一个BaseActivity，继承AppCompatActivity实现IView接口，在BaseActivity中，通过创建工厂类的装饰类，创建具体的P层，并将P层和View层绑定

abstract class BaseActivity<P,V> :AppCompatActivity(),IView where P:BasePresenter<V>,V:IView{

    private var presenterDelegate = PresenterDelegate<P,V>(PresenterFactory.findClass(javaClass))
    protected val mViews = SparseArray<View>()

    protected var rootView: View? = null
    protected var mDecorView: View? = null

    open fun <T : View?> bindView(id: Int): T? {
        var view: T? = mViews[id] as T
        if (view == null) {
            view = rootView?.findViewById(id)
            mViews.put(id, view)
        }
        return view
    }

    override fun getContext(): Context? {
        return this
    }

    override fun getRootViews(): View? {
        return rootView
    }

    override fun <T : View?> getView(id: Int): T {
        return bindView<View>(id) as T
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        presenterDelegate.bindViewCompont(this)
        rootView = layoutInflater.inflate(getLayoutId(), null, false)
        setContentView(rootView)
        initFields()
        bindEventListener()
        getPresenter().onCreate(savedInstanceState,this)
        getPresenter().setListeners()
        mDecorView = window.decorView
    }

    override fun onStart() {
        super.onStart()
        getPresenter().onStart()

    }

    override fun onRestart() {
        super.onRestart()
        getPresenter().onRestart()
    }


    override fun onResume() {
        super.onResume()
        getPresenter().onResume()
    }

    override fun onPause() {
        super.onPause()
        getPresenter().onPause()

    }

    override fun onStop() {
        super.onStop()
        getPresenter().onStop()
    }

    override fun onDestroy() {
        getPresenter().onDestroy()
        presenterDelegate.unbindViewCompont()
        super.onDestroy()
    }

   
    protected open fun onSaveInstanceState(outState: Bundle?) {
        super.onSaveInstanceState(outState!!)
        getPresenter().onSaveInstanceState(outState!!)
    }

    protected open fun onRestoreInstanceState(savedInstanceState: Bundle?) {
        super.onRestoreInstanceState(savedInstanceState!!)
        getPresenter().onRestoreInstanceState(savedInstanceState!!)
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        getPresenter().onActivityResult(requestCode, resultCode, data!!)
    }

    /**
     * 返回layout 布局文件的id
     *
     * @return
     */
    abstract fun getLayoutId(): Int


    /**
     * 初始化其他属性
     */
    abstract fun initFields()

    /**
     * 设置监听
     */
    abstract fun bindEventListener()


    open fun getPresenter(): P {
        return presenterDelegate.getPresenter()
    }

    open fun setPresenter(presenter: P) {
        presenterDelegate.setPresenter(presenter)
    }


}

这样一个mvp架构就搭建完毕了，下面看看使用：

interface ITestView :IView {

    fun setContent(string: String)

}

Module层：

class TestModule :IModule{

    fun doNetWork(){
        println("网络请求")
    }
}

Presenter层：

class TestPresenter: BasePresenter<ITestView>() {

    var module:TestModule? =null

    override fun setListeners() {

    }

    override fun onCreate(savedInstanceState: Bundle?, mContext: Context?) {
        module =TestModule()
    }

    override fun onResume() {
        module?.doNetWork()
        mView?.setContent("222222222")
    }

    override fun onStart() {
    }

    override fun onRestart() {
    }

    override fun onPause() {
    }

    override fun onStop() {
    }

    override fun onDestroy() {
    }

    override fun onSaveInstanceState(outState: Bundle) {
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    }

}

View层：

@Request(TestPresenter::class)
class TestActivity :BaseActivity<TestPresenter,ITestView>(),ITestView {

    var textView:TextView?=null

    override fun getLayoutId(): Int {
        return R.layout.activity_main
    }

    override fun initFields() {
        textView =findViewById<TextView>(R.id.txt)
    }

    override fun bindEventListener() {
    }

    override fun setContent(string: String) {
        textView?.text =string
    }

    override fun getActivity(): Activity? {
        return this
    }

    override fun getFragment(): Fragment? {
        return null
    }
}