本文以kotlin为语言基础，白手做一个组件化插件，选择kotlin一是因为groovy语言编写起来不太友好，二是顺便学习一下kotlin；选择做一个插件，是因为插件可以hook编译、打包的各个过程，达到给组件解耦（ARouter）；优化资源(McImage)，同时学习asm字节码注入。
如何设计？
正常组件之间调用，组件 A调用组件B的方法，要达到解耦那就不能直接调用，那就写个中间层吧，组件池：CRouteFactory，A、B通过组件池间接调用达到解耦目的
各个组件分别把自己注入CRouteFactory，表明自己的身份（name）以及自己的能干什么（action），以及完成每个功能所需要的参数(params),这样CRouteFactory就相当于一个组件池
当组件之间需要通信时，当A需要调用B时，A将自己的意图（name,action,params ）告知CRouteFactory，组件池通过name找到需要调用哪个组件，同时透传action和 params给目标组件，让目标组件内部自己处理，这里需要每个组件都继承同一个接口以提供给组件池调用，定义这个接口为IRoute，这样组件化框架的雏形就基本成型了
设计组件池CRouteFactory
RoutePool:组件池，所有组件注入的地方，并根据name找到目标组件，执行调用
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!!)
//调用组件方法
return iRoute.excute(cBuilder.context!!, cBuilder.action!!, cBuilder.params)
}
}
}
IRoute：组件入口，每个需要成为单独组件的module都需要有一个入口，并注入到CRouteFactory，需要一个getName获取当前组件名称，以及一个excute，组件执行入口
interface IRoute {
fun getRouteName(): String
fun excute(context: Context, action: String, params: MutableMap<String, String>):Any
}
CBuilder：组件调用数据构建类,使用链式调用，组件之间一般涉及到activity跳转，所以构建时需要传入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)
}
}
创建一个组件常量池RouteConstants
每个组件之间通信都是通过 name,action,params相互通信，这样每个组件就应该有一个固定的name,以及固定的action，所以这里创建一个组件常量模块，给所有需要组件通信的模块使用,每个组件建议建立一个单独的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，这样才能让组件池找到自己，并调用自己的入口
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，直接调用入口函数注入？如果是这样的话，各个子组件就需要依赖组件池，就达不到组件化解耦的目的了。看上图中的设计，原本就没想让子组件依赖组件池，那怎么注入呢 ？
可以通过自定义gradle插件，在transform时遍历input，将继承至IRoute的class通过ASM注入到RoutePool中
自定义gradle插件
1.新建一个android library，取名crregister
2.保留src目录、build.gradle，其余全部删除
3.修改build.gradle，引入插件开发需要的库，并支持发布到本地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 {
//发布到本地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.完善字节码注入过程的所有代码，此处不做详细接受，文章结尾会有源代码传送门
9.gradle面板，uploadArchives，发布插件到本地repo仓库
10.项目根目录build.gradle引入发布的插件
repositories {
//增加本地仓依赖
maven {
url uri('repo')
}
}
dependencies {
//引入发布的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
创建的组件ComponentA、ComponentB都已经扫描到了，并注入到RoutePool，并且打印出了组件池所在的jar路径，通过jd-gui查看字节码注入后的jar
代码注入的很完美，但是有个问题，正如图中所标示的：kotlin的静态方法是通过comopanion伴生对象访问的在static里面应该调用不到，在主APP里通过以下代码跳转ComponentA中的Actiivty
CBuilder.create(this)
.name(ComponentA.name)
.action(ComponentA.action1)
.params(mutableMapOf())
.build()
果不其然，crash了，找不到静态方法resisterComponent
asm字节码注入对kotlin还是不太友好，先不折腾了，把RoutePool改用java重新写一遍，再次通过jd-gui查看注入的代码
从主APP通过CBuilder跳转ComponentA中的activity也成功了
感谢大家看到这里，最后附上源码：GitHub CRoute
网友评论