基于ASM的组件化框架

作者: lycknight | 来源:发表于2019-03-25 14:09 被阅读148次

背景

我们在开发一个应用时，会随着时间、人员和需求的增多，我们的代码也会以一个非常快的速度在迭代，同时由于每个人的开发水平不一样，就会有各种各样的问题，如果一直在一个project中开发，很快演变成一个高耦合、臃肿和复杂的项目，所以我们就需要对项目进行优化，我们经常听的有模块化、组件化和插件化，这三者的差异可以看下这篇文章

本文主要介绍组件化，现有的组件化方案：

SPI(Service Provider Interface,服务提供方接口)：服务通常是指一个接口或者一个抽象类，一般通过Android提供的ServiceLoader类来反射加载实现类。SPI提供了一种动态的对应用程序进行扩展的机制，通常用作框架服务的拓展或者可替换的服务组件，缺点就是由于需要I/O操作和反射，会比较耗时，在早起的抖音项目中，组件化就使用这个解决方案，后面接口文件类达到了100多个，整个I/O操作超过了500ms，而且无法对组件做生命周期的管理，不能卸载。更详细的介绍可以看这篇文章
Atlas：是阿里开源的一套成熟的解决方案，但是集成比较麻烦，而且hook了系统服务，兼容性比较差
通过对字节码的改动，实现接口和实现的关联。

划重点

组件化的目的
对比插件化前后的模块间的关系
自定义插件化框架的实现原理
怎样对kotlin进行ASM编码

组件化的目的

第一个阶段-模块化

一个项目伊始，肯定就是一个application模块，所有的代码在一个module中开发，随着人员的增多和需求的迭代，整个项目会越来越大，然后会对项目做一些优化，将不同功能按照包名进行区分-模块化。
缺点：

耦合严重，所有代码放在一起，牵一发而动全身，越往后修改的成本就越大
代码臃肿，编译时间线性增长
由于并行开发，造成每次合代码冲突严重
包体积大小不断增大，只大不小

第二个阶段-组件化

痛定思痛，需要对工程做一个“手术”，将可以独立的功能和模块，分离开，形成独立的library，首先可以将工具类的东西放入framework-library中，然后对可以独立的功能进行拆分，例如live、im等模块
优点：

低耦合、高内聚，有利于后面的扩展
代码层级变的清晰可辨，其他library以aar形式打包，减少编译时间
没有量级的代码冲突，这部分人力解放出来。

由于这个阶段，还是由application依赖各个library，所以整个apk的包体积不会减少，只不过把代码用library的形式进行编译，架构比较清晰。

出现的问题：

随着module的增多，各个模块相互依赖，耦合慢慢的增大。
由于使用了aar依赖，又会有版本的差异。
资源没有隔离，每个模块相互使用资源。
每个组件没有生命周期，完全依赖主工程

第三个阶段-插件化

首先说明一个概念，这里说的插件化，并不是我们平时说的类似Thinker之类的技术，而是一种思维，是组件化的一种提升，也就是每个组件可以进行插拔，既可以放入主工程中进行编译，同时也可以抽离这部分，也可以自己独立运行
优点：

为插件化做好前提，完全支持可插拔，支持下发
各个module之间代码和资源完全隔离，通过接口的形式进行相互调用，更加松耦合
每个组件都有自己的生命周期，可卸载
可以独立运行，不依赖主工程，对于module级别的需求，不需要编译整个项目，更加省时

对比插件化前后的框架

模块化

image

可以看到虽然已经有了比较清晰的层级划分，但是个个模块之前还是相互依赖，造成耦合性非常严重。

组件化

image

这是组件化的升级版，模块之间通过桥接层进行通讯，不直接相互依赖，这样整个工程的模块依赖关系就清爽了很多

自定义插件化框架的实现原理

首先我们思考一下，我们这个插件化的框架都需要什么功能？

一个ServiceManager，管理所有module和moduleService之前的映射关系，管理moduleApplication的生命周期。
在编译时期，使用ASM，将个个module的Application注入到ServiceManager，再将ServiceManager的attachBaseContext、onCreate...等方法，注入到主applicaiotn中，实现module的生命周期。
在编译时期，使用ASM，将module和moduleService之间的映射关系注入到ServiceManager

明确了需求之后，我们来开始开发

ServiceManager

class ServiceManager {

    companion object {
        /**
         * @JvmStatic 是为了在Java可以直接调用改静态方法，不用添加COMPANION
         * 懒加载模式的单例，是不是比Java的单例更加简单
         */
        @JvmStatic
        val ins: ServiceManager by lazy {
            ServiceManager()
        }

        const val TAG = "ServiceManager"
    }
    // 各个module的Application集合，是为了方面管理各个module的生命周期
    private val moduleApplications = ArrayList<Application>()
    // module和moduleService之前的映射关系哈希表
    private val serviceImplMap = HashMap<Class<*>, Class<*>>()
    // module的实例对应哈希表，仅在第一次调用的时候初始化
    private val serviceImplInstanceMap = HashMap<Class<*>, Any>()

    private constructor()

    // 该方法会被注入到主app的Application中，按照Application的生命周期进行调用，以下的方法都是一个意思
    fun attachBaseContext(context: Context) {
        moduleApplications.forEach {
            val attachBaseContext = ContextWrapper::class.java.getDeclaredMethod("attachBaseContext", Context::class.java)
            attachBaseContext.isAccessible = true
            attachBaseContext.invoke(it, context)
        }
        Log.i(TAG, "attachBaseContext: " + moduleApplications.size)

    }

    fun onCreate() {
        moduleApplications.forEach {
            it.onCreate()
        }
        Log.i(TAG, "onCreate: " + moduleApplications.size)

    }

    fun onConfigurationChanged(configuration: Configuration) {
        moduleApplications.forEach {
            it.onConfigurationChanged(configuration)
        }
    }

    fun onLowMemory() {
        moduleApplications.forEach {
            it.onLowMemory()
        }
    }

    fun onTerminate() {
        moduleApplications.forEach {
            it.onTerminate()
        }
    }

    fun onTrimMemory(level: Int) {
        moduleApplications.forEach {
            it.onTrimMemory(level)
        }
    }

    // 同步调用ModuleService的实例，各个module的实例是在这里被创建的
    @Synchronized
    fun <T> getService(classType: Class<T>): T? {
        Log.i(TAG, "getService1: " + serviceImplMap.size)
        val classNewInstance = serviceImplInstanceMap[classType]
        classNewInstance?.let {
            Log.i(TAG, "getService2: $it")
            return it as T
        } ?: serviceImplMap[classType]?.let {
            return (it.newInstance() as T).apply {
                Log.i(TAG, "getService3: $this")
                serviceImplInstanceMap[classType] = this as Any
            }
        } ?: Log.e(TAG, "no ${classType.name} type, please checkout your code~~~")

        return null
    }
}

代码织入

将module与moduleService建立映射关系

在第一次Transform扫描阶段我们需要找到目标类：

使用注解@ModuleSpec来标示每个的module的application，通过注解，来找到module的application，暂时放入一个list中
使用注解@ServiceImpl来标示每个module对外提供服务的实现类，通过注解找到实现类和其接口，使用哈希表暂时存放起来

在第二次Transform阶段我们需要进行代码注入：

找到ServiceManager类，对其进行代码注入
使用注解@AppSpec对主Application进行标示，找到主Application，然后进行代码注入，主要是对Application的生命周期方法添加ServiceManager的相同方法

注入之后的代码，大概如下

@AppSpec
class MyApplication : Application() {

    override fun attachBaseContext(base: Context?) {
        super.attachBaseContext(base)
        ServiceManager.ins.attachBaseContext(base!!)
    }

    override fun onCreate() {
        super.onCreate()
        ServiceManager.ins.onCreate()
    }

    override fun onConfigurationChanged(newConfig: Configuration?) {
        super.onConfigurationChanged(newConfig)
        ServiceManager.ins.onConfigurationChanged(newConfig!!)
    }

    override fun onLowMemory() {
        super.onLowMemory()
        ServiceManager.ins.onLowMemory()
    }

    override fun onTerminate() {
        super.onTerminate()
        ServiceManager.ins.onTerminate()
    }

    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        ServiceManager.ins.onTrimMemory(level)
    }
}

ServiceManager注入后的代码


private constructor(){
        moduleApplications.add(Application())
        
        serviceImplMap.put(String.javaClass,String.javaClass)
    }

对Kotlin进行ASM编码

在上一篇文章中，描述了如何编译Java代码，查看对应ASM代码，那么是不是有什么方法来看相应的Kotlin的ASM代码呢？答案是没有的，起码现在是没有第三方插件支持的，但是不要灰心，我们可以通过看kotlin的字节码来大概对比一下Java的代码，就可以，其实还是比较简单的。

image

对Java代码进行使用ASM Bytecode Viewer进行编译，生成对应ASMCode。
找到你预先要织入的代码，也就是图片中红框的部分
右侧对应的红框就是要织入的代码，上面的变量需要我们替换一下，new Application()和(String.class,String.class)需要替换为真正需要织入的类

再在已有的框架中写入ASMCode

open class FindTargetClassAdapter(context: Context, cv: ClassVisitor) : BaseClassVisitor<Context>(context, cv) {

    var interfaces: Array<String>? = null
    val extension = context.extension as ComponentExtension

    override fun visit(version: Int, access: Int, name: String, signature: String?, superName: String?, interfaces: Array<String>?) {
        super.visit(version, access, name, signature, superName, interfaces)
        this.interfaces = interfaces
    }

    override fun visitAnnotation(descriptor: String?, visible: Boolean): AnnotationVisitor {
        when (descriptor) {
            "L${extension.modulePath};" -> {
                println("modularization: modulePath -> $className")
                context.moduleApplications.add(className)
            }
            "L${extension.serviceImpl};" -> {
                interfaces?.forEach {
                    println("modularization: moduleImpl -> $className")
                    context.serviceImpl[it] = className
                }
            }
        }
        return super.visitAnnotation(descriptor, visible)
    }
}

继承了框架的classvisitor，只需要专注于代码织入的编写，第一次遍历项目中所有的类，找到目标类。


class WeaveCodeClassVisitor(context: Context, cv: ClassVisitor) : BaseClassVisitor<Context>(context, cv) {
    val extension = context.extension as ComponentExtension

    var isAppModule = false
    var isServiceManager = false
    override fun visitAnnotation(descriptor: String?, visible: Boolean): AnnotationVisitor {
        isAppModule = descriptor == "L${extension.appPath};"//通过注解判断是否为@AppSpec目标类
        return super.visitAnnotation(descriptor, visible)
    }

    override fun visit(version: Int, access: Int, name: String, signature: String?, superName: String?, interfaces: Array<String>?) {
        super.visit(version, access, name, signature, superName, interfaces)
        isServiceManager = name == extension.serviceManagerPath//是否为ServiceManager
    }


    override fun visitMethod(access: Int, name: String?, descriptor: String?, signature: String?, exceptions: Array<out String>?): MethodVisitor {
        val visitMethod = super.visitMethod(access, name, descriptor, signature, exceptions)
        if (isAppModule) {//找到主app的各个方法，对其进行相应的代码织入
            println("modularization: application -> $className")
            when (name + descriptor) {
                "onCreate()V" -> return AddCallAppInjectMethodVisitor(context, visitMethod, "onCreate", "()V", false, false)
                "attachBaseContext(Landroid/content/Context;)V" -> return AddCallAppInjectMethodVisitor(context, visitMethod, "attachBaseContext", "(Landroid/content/Context;)V", true, false)
                "onConfigurationChanged(Landroid/content/res/Configuration;)V" -> return AddCallAppInjectMethodVisitor(context, visitMethod, "onConfigurationChanged", "(Landroid/content/res/Configuration;)V", true, false)
                "onLowMemory()V" -> return AddCallAppInjectMethodVisitor(context, visitMethod, "onLowMemory", "()V", false, false)
                "onTerminate()V" -> return AddCallAppInjectMethodVisitor(context, visitMethod, "onTerminate", "()V", false, false)
                "onTrimMemory(I)V" -> return AddCallAppInjectMethodVisitor(context, visitMethod, "onTrimMemory", "(I)V", false, true)
            }
        }

        if (isServiceManager && access == 2 && name == "<init>" && descriptor == "()V") {//找到目标类的私有构造方法
            println("modularization: serviceManager -> $className")
            return AddCodeToConstructorVisitor(context, visitMethod)
        }
        return visitMethod

    }
}

第二次遍历所有的类，进行代码织入

class AddCodeToConstructorVisitor(val context: Context, mv: MethodVisitor) : MethodVisitor(Opcodes.ASM5, mv) {
    val extension = context.extension as ComponentExtension


    override fun visitInsn(opcode: Int) {

        when (opcode) {
            Opcodes.IRETURN,
            Opcodes.FRETURN,
            Opcodes.ARETURN,
            Opcodes.LRETURN,
            Opcodes.DRETURN,
            Opcodes.RETURN -> {
                context.moduleApplications.forEach {
                    insertApplicationAdd(it)
                }
                context.serviceImpl.forEach { t, u ->
                    insertRoutersPut(t, u)
                }
            }
        }
        super.visitInsn(opcode)
    }

    private fun insertApplicationAdd(applicationName: String) {
        println("modularization: insertApplicationAdd -> $applicationName ")
        mv.visitVarInsn(Opcodes.ALOAD, 0)
        mv.visitFieldInsn(Opcodes.GETFIELD, extension.serviceManagerPath, extension.serviceApplicationListName, "Ljava/util/ArrayList;")
        mv.visitTypeInsn(Opcodes.NEW, applicationName)
        mv.visitInsn(Opcodes.DUP)
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, applicationName, "<init>", "()V", false)
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/ArrayList", "add", "(Ljava/lang/Object;)Z", false)
        mv.visitInsn(Opcodes.POP)
    }

    private fun insertRoutersPut(router: String, impl: String) {
        println("modularization: insertCode -> $router ; $impl")
        mv.visitVarInsn(Opcodes.ALOAD, 0)
        mv.visitFieldInsn(Opcodes.GETFIELD, extension.serviceManagerPath, extension.serviceImplMapName, "Ljava/util/HashMap;")
        mv.visitLdcInsn(Type.getObjectType(router))
        mv.visitLdcInsn(Type.getObjectType(impl))
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/HashMap", "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", false)
        mv.visitInsn(Opcodes.POP)
    }

对serviceManager进行代码织入，也就是上面图中的的代码，直接写到相应的位置就ok

class AddCallAppInjectMethodVisitor(val context: Context, mv: MethodVisitor,
                                    val methodName: String, val methodDes: String,
                                    val aLoad1: Boolean, val iLoad1: Boolean) : MethodVisitor(Opcodes.ASM5, mv) {
    val extension = context.extension as ComponentExtension

    override fun visitInsn(opcode: Int) {
        when (opcode) {
            Opcodes.IRETURN,
            Opcodes.FRETURN,
            Opcodes.ARETURN,
            Opcodes.LRETURN,
            Opcodes.DRETURN,
            Opcodes.RETURN -> {
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, extension.serviceManagerPath, "getIns", "()L${extension.serviceManagerPath};", false)
                if (aLoad1) {
                    mv.visitVarInsn(Opcodes.ALOAD, 1)
                }
                if (iLoad1) {
                    mv.visitVarInsn(Opcodes.ILOAD, 1)
                }
                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, extension.serviceManagerPath, methodName, methodDes, false)
            }
        }
        super.visitInsn(opcode)
    }

}

对主application进行代码织入

image

右边的红框，是不是和ASM很像，基本一致，这里需要注意的是，kotlin的List接口和Map接口没有add和put函数，所以这里需要定义为HashMap和ArrayList。

基于ASM的组件化框架

背景

划重点

组件化的目的

第一个阶段-模块化

第二个阶段-组件化

第三个阶段-插件化

对比插件化前后的框架

模块化

组件化

自定义插件化框架的实现原理

ServiceManager

代码织入

将module与moduleService建立映射关系

对Kotlin进行ASM编码

源码

Plugin实现

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android收藏集