基于ASM的组件化框架

背景

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

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

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

划重点

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

组件化的目的

第一个阶段-模块化

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

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

第二个阶段-组件化

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

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

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

出现的问题：

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

第三个阶段-插件化

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

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

对比插件化前后的框架

模块化

image

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

组件化

image

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

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

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

  1. 一个ServiceManager，管理所有module和moduleService之前的映射关系，管理moduleApplication的生命周期。
  2. 在编译时期，使用ASM，将个个module的Application注入到ServiceManager，再将ServiceManager的attachBaseContext、onCreate...等方法，注入到主applicaiotn中，实现module的生命周期。
  3. 在编译时期，使用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扫描阶段我们需要找到目标类：

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

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

  1. 找到ServiceManager类，对其进行代码注入
  2. 使用注解@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
  1. 对Java代码进行使用ASM Bytecode Viewer进行编译，生成对应ASMCode。
  2. 找到你预先要织入的代码，也就是图片中红框的部分
  3. 右侧对应的红框就是要织入的代码，上面的变量需要我们替换一下，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。

源码

Plugin实现

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 162,158评论 4赞 370
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 68,600评论 1赞 307
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 111,785评论 0赞 254
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,655评论 0赞 220
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 53,075评论 3赞 295
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 41,002评论 1赞 225
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 32,146评论 2赞 318
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,918评论 0赞 211
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,671评论 1赞 250
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,838评论 2赞 254
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,318评论 1赞 265
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,636评论 3赞 263
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,343评论 3赞 244
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,187评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,982评论 0赞 201
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 36,126评论 2赞 285
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,934评论 2赞 279