kotlin寫一個最精簡的組件化框架

本文以kotlin為語言基礎，白手做一個組件化插件，選擇kotlin一是因為groovy語言編寫起來不太友好，二是順便學習一下kotlin；選擇做一個插件，是因為插件可以hook編譯、打包的各個過程，達到給組件解耦（ARouter）；優(yōu)化資源(McImage)，同時學習asm字節(jié)碼注入。

如何設計？

正常組件之間調(diào)用，組件 A調(diào)用組件B的方法，要達到解耦那就不能直接調(diào)用，那就寫個中間層吧，組件池：CRouteFactory，A、B通過組件池間接調(diào)用達到解耦目的

各個組件分別把自己注入CRouteFactory，表明自己的身份（name）以及自己的能干什么（action），以及完成每個功能所需要的參數(shù)(params),這樣CRouteFactory就相當于一個組件池

當組件之間需要通信時，當A需要調(diào)用B時，A將自己的意圖（name,action,params ）告知CRouteFactory，組件池通過name找到需要調(diào)用哪個組件，同時透傳action和 params給目標組件，讓目標組件內(nèi)部自己處理，這里需要每個組件都繼承同一個接口以提供給組件池調(diào)用，定義這個接口為IRoute，這樣組件化框架的雛形就基本成型了

設計組件池CRouteFactory

RoutePool:組件池，所有組件注入的地方，并根據(jù)name找到目標組件，執(zhí)行調(diào)用

class RoutePool {
    companion object {
        //組件列表
        private var pools: MutableMap<String, IRoute> = mutableMapOf()
        //組件注入方法
        fun registerComponent(name: String) {
            if (name.isNullOrEmpty()) {
                return
            }
            if (pools.containsKey(name)) {
                throw Exception("has register same components,please change other name")
            }
            var name = name.replace(File.separator, ".")
            try {
                //獲取真正的組件名稱
                name = name.substring(0, name.length - 6)
                //反射獲取組件入口實例
                val cls = Class.forName(name)
                val iRoute = cls.newInstance() as IRoute
                val componentName: String = iRoute.getRouteName()
                if (TextUtils.isEmpty(componentName)) {
                    return
                }
                //添加到組件池子
                pools.put(componentName, iRoute)
            } catch (e: ClassNotFoundException) {
                e.printStackTrace()
            } catch (e: IllegalAccessException) {
                e.printStackTrace()
            } catch (e: InstantiationException) {
                e.printStackTrace()
            }
        }
        
        fun excute(cBuilder: CBuilder):Any {
            if (!pools.keys.contains(cBuilder.name)) {
                return false
            }
            //尋找目標組件
            var iRoute = pools.getValue(cBuilder.name!!)
            //調(diào)用組件方法
            return iRoute.excute(cBuilder.context!!, cBuilder.action!!, cBuilder.params)
        }
    }
}

IRoute：組件入口，每個需要成為單獨組件的module都需要有一個入口，并注入到CRouteFactory，需要一個getName獲取當前組件名稱，以及一個excute，組件執(zhí)行入口

interface IRoute {
    fun getRouteName(): String
    fun excute(context: Context, action: String, params: MutableMap<String, String>):Any
}

CBuilder：組件調(diào)用數(shù)據(jù)構(gòu)建類,使用鏈式調(diào)用，組件之間一般涉及到activity跳轉(zhuǎn)，所以構(gòu)建時需要傳入context

class CBuilder {
    var context: Context? = null
    var name: String? = null
    var action: String? = null
    var params: MutableMap<String, String> = mutableMapOf()

    companion object {
        fun create(context: Context): CBuilder {
            var cBuilder = CBuilder()
            cBuilder.context = context
            return cBuilder
        }
    }

    fun params(params: MutableMap<String, String>): CBuilder {
        if (!params.isNullOrEmpty())
            this.params.putAll(params)
        return this
    }

    fun name(name: String): CBuilder {
        this.name = name
        return this
    }

    fun action(action: String): CBuilder {
        this.action = action
        return this
    }

    fun build(): Any {
        return RoutePoolJava.excute(this)
    }
}
創(chuàng)建一個組件常量池RouteConstants

每個組件之間通信都是通過 name,action,params相互通信，這樣每個組件就應該有一個固定的name,以及固定的action，所以這里創(chuàng)建一個組件常量模塊，給所有需要組件通信的模塊使用,每個組件建議建立一個單獨的class表明自己的身份以及能力

class ComponentA {
    companion object{
        val name = ComponentA::class.java.simpleName
        val action1 = "startActivity"
        val action2 = "getResult"
        val p1 = "p1"
        val p2 = "p2"
    }
}
設計幾個Component

上面說了，每個組件都必須有一個入口繼承IRoute，并注入到RoutePool，這樣才能讓組件池找到自己，并調(diào)用自己的入口

class ComponentA : IRoute {
    override fun getRouteName(): String {
        return ComponentA.name
    }

    override fun excute(context: Context, action: String, params: MutableMap<String, String>): Any {
        when (action) {
            ComponentA.action1 -> {
                context.startActivity(Intent(context, ComponentAActivity::class.java))
                return true
            }
            ComponentA.action2 -> {
                return ComponentAActivity.getResult(params)
            }
        }
        return true
    }
}

到這里差不多所有的就設計完了，總共一下幾個moule
app：主app
CRouteFactory :組件池
RouteConstants:組件常量基礎庫
Components：若干組件

各組件如何注入到組件池？

CRouteFactory提供組件注入入口registerComponent，讓各個子組件依賴CRouteFactory，直接調(diào)用入口函數(shù)注入？如果是這樣的話，各個子組件就需要依賴組件池，就達不到組件化解耦的目的了?？瓷蠄D中的設計，原本就沒想讓子組件依賴組件池，那怎么注入呢 ？



可以通過自定義gradle插件，在transform時遍歷input，將繼承至IRoute的class通過ASM注入到RoutePool中

自定義gradle插件

1.新建一個android library，取名crregister
2.保留src目錄、build.gradle，其余全部刪除
3.修改build.gradle，引入插件開發(fā)需要的庫，并支持發(fā)布到本地repo

apply plugin: 'groovy'
apply plugin: 'maven'
apply plugin: 'kotlin'
dependencies {
    implementation gradleApi()
    implementation localGroovy()
    implementation 'com.android.tools.build:gradle:3.5.0'
}
buildscript {
    ext.kotlin_version = '1.3.72'
    repositories {
        jcenter()
        google()
        mavenCentral()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

allprojects {
    repositories {
        jcenter()
        google()
    }
}
uploadArchives {
    //發(fā)布到本地repo倉庫，以提供給app使用
    repositories {
        mavenDeployer {
            pom.groupId = 'com.code.crregister'
            pom.artifactId = 'crregister'
            pom.version = '1.0.0'
            repository(url: uri('../repo'))
        }
    }
}

4.build project，此時會在gradle面板中多出upload task: uploadArchives

5.main目錄下新建resouces/META-INF/gradle-plugins完整目錄，并在該目錄下新建ccregister.properties文件
6.在java/packagename目錄下新建kotlin class,CRoutePlugin
7.ccregister.properties中增加以下代碼，指向步驟6中的插件類

implementation-class=com.code.crregister.CRoutePlugin

8.完善字節(jié)碼注入過程的所有代碼，此處不做詳細接受，文章結(jié)尾會有源代碼傳送門


9.gradle面板，uploadArchives，發(fā)布插件到本地repo倉庫
10.項目根目錄build.gradle引入發(fā)布的插件

repositories {
//增加本地倉依賴
        maven {
            url uri('repo')
        }
    }
    dependencies {
        //引入發(fā)布的crregister
        classpath 'com.code.crregister:crregister:1.0.0'
       ...
    }

11.在app module目錄下的build.gradle引用插件

apply plugin: 'crregister'

12.運行app查看build log

********CRoutePlugin  start
isIncremental:true
components:[com/code/componentb/ComponentB.class, com/code/componenta/ComponentA.class]
pool path:/Users/balance/git-project/CRoute/app/build/intermediates/transforms/com.code.crregister.CRoutePlugin/debug/33.jar
inject finish const:1334
********CRoutePlugin  end

創(chuàng)建的組件ComponentA、ComponentB都已經(jīng)掃描到了，并注入到RoutePool，并且打印出了組件池所在的jar路徑，通過jd-gui查看字節(jié)碼注入后的jar


代碼注入的很完美，但是有個問題，正如圖中所標示的：kotlin的靜態(tài)方法是通過comopanion伴生對象訪問的在static里面應該調(diào)用不到，在主APP里通過以下代碼跳轉(zhuǎn)ComponentA中的Actiivty

CBuilder.create(this)
                .name(ComponentA.name)
                .action(ComponentA.action1)
                .params(mutableMapOf())
                .build()

果不其然，crash了，找不到靜態(tài)方法resisterComponent



asm字節(jié)碼注入對kotlin還是不太友好，先不折騰了，把RoutePool改用java重新寫一遍，再次通過jd-gui查看注入的代碼



從主APP通過CBuilder跳轉(zhuǎn)ComponentA中的activity也成功了


感謝大家看到這里，最后附上源碼：GitHub CRoute

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

友情鏈接更多精彩內(nèi)容