本文紧接着前一章Android组件化开发实践（八）：组件生命周期如何实现自动注册管理，主要讲解怎么通过自定义插件来实现组件生命周期的自动注册管理。
1. 采用groovy创建插件
新建一个Java Library module，命名为lifecycle-plugin，删除 src->main 下面的java目录，新建一个groovy目录，在groovy目录下创建类似java的package，在 src->main 下面创建一个 resources 目录，在resources目录下依次创建 META-INF/gradle-plugins 目录，最后在该目录下创建一个名为 com.hm.plugin.lifecycle.properties的文本文件，文件名是你要定义的插件名，按需自定义即可。最后的工程结构如图所示：
修改module的build.gradle文件，引入groovy插件等：
apply plugin: 'java-library'
apply plugin: 'groovy'
apply plugin: 'maven'
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
compile gradleApi()
compile localGroovy()
compile 'com.android.tools.build:transform-api:1.5.0'
compile 'com.android.tools.build:gradle:3.0.1'
}
sourceCompatibility = "1.7"
targetCompatibility = "1.7"
//通过maven将插件发布到本地的脚本配置，根据自己的要求来修改
uploadArchives {
repositories.mavenDeployer {
pom.version = '1.0.0'
pom.artifactId = 'hmlifecyclepluginlocal'
pom.groupId = 'com.heima.iou'
repository(url: "file:///Users/hjy/.m2/repository/")
}
}
这里有几点需要说明的是：
- 通常都是采用groovy语言来创建gradle plugin的，groovy是兼容java的，你完全可以采用java来编写插件。关于groovy语言，了解一些基础语法就足够支撑我们去编写插件了。
- 在 src/main/resources/META-INF/gradle-plugins目录下定义插件声明，*.properties文件的文件名就是插件名称。
2. 实现Plugin接口
要编写一个插件是很简单的，只需实现Plugin接口即可。
package com.hm.iou.lifecycle.plugin
import com.android.build.gradle.AppExtension
import org.gradle.api.Plugin
import org.gradle.api.Project
class LifeCyclePlugin implements Plugin{
@Override
void apply(Project project) {
println "------LifeCycle plugin entrance-------"
}
}
接着在com.hm.plugin.lifecycle.properties文件里增加配置：
implementation-class=com.hm.iou.lifecycle.plugin.LifeCyclePlugin
其中implementation-class的值为Plugin接口的实现类的全限定类名，至此为止一个最简单的插件编写好了，它的功能很简单，仅仅是在控制台打印一句文本而已。
我们通过maven将该插件发布到本地的maven仓库里，发布成功后，我们在app module里引入该插件，修改app module目录下的build.gradle文件，增加如下配置：
apply plugin: 'com.android.application'
//引入自定义插件，插件名与前面的*.properties文件的文件名是一致的
apply plugin: 'com.hm.plugin.lifecycle'
buildscript {
repositories {
google()
jcenter()
//自定义插件maven地址，替换成你自己的maven地址
maven { url 'file:///Users/hjy/.m2/repository/' }
}
dependencies {
//通过maven加载自定义插件
classpath 'com.heima.iou:hmlifecyclepluginlocal:1.0.0'
}
}
我们build一下工程，在Gradle Console里会打印出"------LifeCycle plugin entrance-------"来，这说明我们的自定义插件成功了。
讲到这里可以看到，按这个步骤实现一个gradle插件是很简单的，它并没有我们想象中那么高深莫测，你也可以自豪地说我会制作gradle插件了。
3. Gradle Transform
然而前面这个插件并没有什么卵用，它仅仅只是在编译时，在控制台打印一句话而已。那么怎么通过插件在打包前去扫描所有的class文件呢，幸运的是官方给我们提供了 Gradle Transform技术，简单来说就是能够让开发者在项目构建阶段即由class到dex转换期间修改class文件，Transform阶段会扫描所有的class文件和资源文件，具体技术我这里不详细展开，下面通过伪代码部分说下我的思路。
//只需要继承Transform类即可
class LifeCycleTransform extends Transform {
Project project
LifeCycleTransform(Project project) {
this.project = project
}
//该Transform的名称，自定义即可，只是一个标识
@Override
String getName() {
return "LifeCycleTransform"
}
//该Transform支持扫描的文件类型，分为class文件和资源文件，我们这里只处理class文件的扫描
@Override
Set getInputTypes() {
return TransformManager.CONTENT_CLASS
}
//Transfrom的扫描范围，我这里扫描整个工程，包括当前module以及其他jar包、aar文件等所有的class
@Override
Set getScopes() {
return TransformManager.SCOPE_FULL_PROJECT
}
//是否增量扫描
@Override
boolean isIncremental() {
return true
}
@Override
void transform(Context context, Collection inputs, Collection referencedInputs,
TransformOutputProvider outputProvider, boolean isIncremental) throws IOException, TransformException, InterruptedException {
println "\nstart to transform-------------->>>>>>>"
def appLikeProxyClassList = []
//inputs就是所有扫描到的class文件或者是jar包，一共2种类型
inputs.each { TransformInput input ->
//1.遍历所有的class文件目录
input.directoryInputs.each { DirectoryInput directoryInput ->
//递归扫描该目录下所有的class文件
if (directoryInput.file.isDirectory()) {
directoryInput.file.eachFileRecurse {File file ->
//形如 Heima$$****$$Proxy.class 的类，是我们要找的目标class，直接通过class的名称来判断，也可以再加上包名的判断，会更严谨点
if (ScanUtil.isTargetProxyClass(file)) {
//如果是我们自己生产的代理类，保存该类的类名
appLikeProxyClassList.add(file.name)
}
}
}
//Transform扫描的class文件是输入文件(input)，有输入必然会有输出(output)，处理完成后需要将输入文件拷贝到一个输出目录下去，
//后面打包将class文件转换成dex文件时，直接采用的就是输出目录下的class文件了。
//必须这样获取输出路径的目录名称
def dest = outputProvider.getContentLocation(directoryInput.name, directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)
FileUtils.copyDirectory(directoryInput.file, dest)
}
//2.遍历查找所有的jar包
input.jarInputs.each { JarInput jarInput ->
println "\njarInput = ${jarInput}"
//与处理class文件一样，处理jar包也是一样，最后要将inputs转换为outputs
def jarName = jarInput.name
def md5 = DigestUtils.md5Hex(jarInput.file.getAbsolutePath())
if (jarName.endsWith(".jar")) {
jarName = jarName.substring(0, jarName.length() - 4)
}
//获取输出路径下的jar包名称，必须这样获取，得到的输出路径名不能重复，否则会被覆盖
def dest = outputProvider.getContentLocation(jarName + md5, jarInput.contentTypes, jarInput.scopes, Format.JAR)
if (jarInput.file.getAbsolutePath().endsWith(".jar")) {
File src = jarInput.file
//先简单过滤掉 support-v4 之类的jar包，只处理有我们业务逻辑的jar包
if (ScanUtil.shouldProcessPreDexJar(src.absolutePath)) {
//扫描jar包的核心代码在这里，主要做2件事情：
//1.扫描该jar包里有没有实现IAppLike接口的代理类;
//2.扫描AppLifeCycleManager这个类在哪个jar包里，并记录下来，后面需要在该类里动态注入字节码；
List list = ScanUtil.scanJar(src, dest)
if (list != null) {
appLikeProxyClassList.addAll(list)
}
}
}
//将输入文件拷贝到输出目录下
FileUtils.copyFile(jarInput.file, dest)
}
}
println ""
appLikeProxyClassList.forEach({fileName ->
println "file name = " + fileName
})
println "\n包含AppLifeCycleManager类的jar文件"
println ScanUtil.FILE_CONTAINS_INIT_CLASS.getAbsolutePath()
println "开始自动注册"
//1.通过前面的步骤，我们已经扫描到所有实现了 IAppLike接口的代理类；
//2.后面需要在 AppLifeCycleManager 这个类的初始化方法里，动态注入字节码；
//3.将所有 IAppLike 接口的代理类，通过类名进行反射调用实例化
//这样最终生成的apk包里，AppLifeCycleManager调用init()方法时，已经可以加载所有组件的生命周期类了
new AppLikeCodeInjector(appLikeProxyClassList).execute()
println "transform finish----------------<<<<<<<\n"
}
}
我们来看看ScanUtil类里的代码逻辑：
class ScanUtil {
static final PROXY_CLASS_PREFIX = "Heima\$\$"
static final PROXY_CLASS_SUFFIX = "\$\$Proxy.class"
//注意class文件名中的包名是以“/”分隔开，而不是“.”分隔的，这个包名是我们通过APT生成的所有 IAppLike 代理类的包名
static final PROXY_CLASS_PACKAGE_NAME = "com/hm/iou/lifecycle/apt/proxy"
//AppLifeCycleManager是应用生命周期框架初始化方法调用类
static final REGISTER_CLASS_FILE_NAME = "com/hm/lifecycle/api/AppLifeCycleManager.class"
//包含生命周期管理初始化类的文件，即包含 com.hm.lifecycle.api.AppLifeCycleManager 类的class文件或者jar文件
static File FILE_CONTAINS_INIT_CLASS
/**
* 判断该class是否是我们的目标类
*
* @param file
* @return
*/
static boolean isTargetProxyClass(File file) {
if (file.name.endsWith(PROXY_CLASS_SUFFIX) && file.name.startsWith(PROXY_CLASS_PREFIX)) {
return true
}
return false
}
/**
* 扫描jar包里的所有class文件：
* 1.通过包名识别所有需要注入的类名
* 2.找到AppLifeCycleManager类所在的jar包，后面我们会在该jar包里进行代码注入
*
* @param jarFile
* @param destFile
* @return
*/
static List scanJar(File jarFile, File destFile) {
def file = new JarFile(jarFile)
Enumeration enumeration = file.entries()
List list = null
while (enumeration.hasMoreElements()) {
//遍历这个jar包里的所有class文件项
JarEntry jarEntry = enumeration.nextElement()
//class文件的名称，这里是全路径类名，包名之间以"/"分隔
String entryName = jarEntry.getName()
if (entryName == REGISTER_CLASS_FILE_NAME) {
//标记这个jar包包含 AppLifeCycleManager.class
//扫描结束后，我们会生成注册代码到这个文件里
FILE_CONTAINS_INIT_CLASS = destFile
} else {
//通过包名来判断，严谨点还可以加上类名前缀、后缀判断
//通过APT生成的类，都有统一的前缀、后缀
if (entryName.startsWith(PROXY_CLASS_PACKAGE_NAME)) {
if (list == null) {
list = new ArrayList<>()
}
list.addAll(entryName.substring(entryName.lastIndexOf("/") + 1))
}
}
}
return list
}
static boolean shouldProcessPreDexJar(String path) {
return !path.contains("com.android.support") && !path.contains("/android/m2repository")
}
}
修改Plugin接口实现类，在插件中注册该Transfrom：
class LifeCyclePlugin implements Plugin{
@Override
void apply(Project project) {
println "------LifeCycle plugin entrance-------"
def android = project.extensions.getByType(AppExtension)
android.registerTransform(new LifeCycleTransform(project))
}
}
前面的代码里，先注释掉LifeCycleTransform类里的AppLikeCodeInjector相关代码，这块我们后面再讲。我们再新建一个Android Library module，在该module里创建 ModuleCAppLike、ModuleDAppLike，同样都实现IAppLike接口并采用@AppLifeCycle作为注解。最后采用最新的插件重新build一下工程，看看Gradle Console里的输出信息。
file name = Heima$$ModuleCAppLike$$Proxy.class
file name = Heima$$ModuleDAppLike$$Proxy.class
file name = Heima$$ModuleAAppLike$$Proxy.class
file name = Heima$$ModuleBAppLike$$Proxy.class
包含AppLifeCycleManager类的jar文件
/Users/hjy/Desktop/heima/code/gitlab/HM-AppLifeCycleMgr/app/build/intermediates/transforms/LifeCycleTransform/debug/17.jar
可以看到，在Transform过程中，我们找到了ModuleAAppLike、ModuleBAppLike、ModuleCAppLike、ModuleDAppLike这4个类的代理类，以及AppLifeCycleManager这个class文件所在的jar包。
在app->build->intermediates->transforms中，可以看到所有的Transform，包括我们刚才自定义的Transform。从上图中可以看到，这里的0.jar、1.jar、2.jar等等，都是通过outputProvider.getContentLocation()方法来生成的，这个Transform目录下的class文件、jar包等，会当做下一个Transform的inputs传递过去。
4. 通过ASM动态修改字节码
到现在，我们只剩下最后一步了，那就是如何注入代码了。ASM 是一个 Java 字节码操控框架，它能被用来动态生成类或者增强既有类的功能。我这里对ASM不做详细介绍了，主要是介绍使用ASM动态注入代码的思路。
首先，我们修改一下AppLifeCycleManager类，增加动态注入字节码的入口方法：
/**
* 通过插件加载 IAppLike 类
*/
private static void loadAppLike() {
}
//通过反射去加载 IAppLike 类的实例
private static void registerAppLike(String className) {
if (TextUtils.isEmpty(className))
return;
try {
Object obj = Class.forName(className).getConstructor().newInstance();
if (obj instanceof IAppLike) {
APP_LIKE_LIST.add((IAppLike) obj);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 初始化
*
* @param context
*/
public static void init(Context context) {
//通过插件加载 IAppLike 类
loadAppLike();
Collections.sort(APP_LIKE_LIST, new AppLikeComparator());
for (IAppLike appLike : APP_LIKE_LIST) {
appLike.onCreate(context);
}
}
相比之前，这里增加了一个loadAppLike()方法，在init()方法调用时会先执行。通过前面Transform步骤之后，我们现在的目标是把代码动态插入到loadAppLike()方法里，下面这段代码是我们期望插入后的结果：
private static void loadAppLike() {
registerAppLike("com.hm.iou.lifecycle.apt.proxy.Heima$$ModuleAAppLike$$Proxy");
registerAppLike("com.hm.iou.lifecycle.apt.proxy.Heima$$ModuleBAppLike$$Proxy");
registerAppLike("com.hm.iou.lifecycle.apt.proxy.Heima$$ModuleCAppLike$$Proxy");
registerAppLike("com.hm.iou.lifecycle.apt.proxy.Heima$$ModuleDAppLike$$Proxy");
}
这样在初始化时，就已经知道要加载哪些生命周期类，来看看具体实现方法，关于ASM不了解的地方，需要先搞清楚其使用方法再来阅读：
class AppLikeCodeInjector {
//扫描出来的所有 IAppLike 类
List proxyAppLikeClassList
AppLikeCodeInjector(List list) {
proxyAppLikeClassList = list
}
void execute() {
println("开始执行ASM方法======>>>>>>>>")
File srcFile = ScanUtil.FILE_CONTAINS_INIT_CLASS
//创建一个临时jar文件，要修改注入的字节码会先写入该文件里
def optJar = new File(srcFile.getParent(), srcFile.name + ".opt")
if (optJar.exists())
optJar.delete()
def file = new JarFile(srcFile)
Enumeration enumeration = file.entries()
JarOutputStream jarOutputStream = new JarOutputStream(new FileOutputStream(optJar))
while (enumeration.hasMoreElements()) {
JarEntry jarEntry = enumeration.nextElement()
String entryName = jarEntry.getName()
ZipEntry zipEntry = new ZipEntry(entryName)
InputStream inputStream = file.getInputStream(jarEntry)
jarOutputStream.putNextEntry(zipEntry)
//找到需要插入代码的class，通过ASM动态注入字节码
if (ScanUtil.REGISTER_CLASS_FILE_NAME == entryName) {
println "insert register code to class >> " + entryName
ClassReader classReader = new ClassReader(inputStream)
// 构建一个ClassWriter对象，并设置让系统自动计算栈和本地变量大小
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS)
ClassVisitor classVisitor = new AppLikeClassVisitor(classWriter)
//开始扫描class文件
classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES)
byte[] bytes = classWriter.toByteArray()
//将注入过字节码的class，写入临时jar文件里
jarOutputStream.write(bytes)
} else {
//不需要修改的class，原样写入临时jar文件里
jarOutputStream.write(IOUtils.toByteArray(inputStream))
}
inputStream.close()
jarOutputStream.closeEntry()
}
jarOutputStream.close()
file.close()
//删除原来的jar文件
if (srcFile.exists()) {
srcFile.delete()
}
//重新命名临时jar文件，新的jar包里已经包含了我们注入的字节码了
optJar.renameTo(srcFile)
}
//插入字节码的逻辑，都在这个类里面
class AppLikeClassVisitor extends ClassVisitor {
AppLikeClassVisitor(ClassVisitor classVisitor) {
super(Opcodes.ASM5, classVisitor)
}
@Override
MethodVisitor visitMethod(int access, String name,
String desc, String signature,
String[] exception) {
println "visit method: " + name
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exception)
//找到 AppLifeCycleManager里的loadAppLike()方法，我们在这个方法里插入字节码
if ("loadAppLike" == name) {
mv = new LoadAppLikeMethodAdapter(mv, access, name, desc)
}
return mv
}
}
class LoadAppLikeMethodAdapter extends AdviceAdapter {
LoadAppLikeMethodAdapter(MethodVisitor mv, int access, String name, String desc) {
super(Opcodes.ASM5, mv, access, name, desc)
}
@Override
protected void onMethodEnter() {
super.onMethodEnter()
println "-------onMethodEnter------"
//遍历插入字节码，其实就是在 loadAppLike() 方法里插入类似registerAppLike("");的字节码
proxyAppLikeClassList.forEach({proxyClassName ->
println "开始注入代码：${proxyClassName}"
def fullName = ScanUtil.PROXY_CLASS_PACKAGE_NAME.replace("/", ".") + "." + proxyClassName.substring(0, proxyClassName.length() - 6)
println "full classname = ${fullName}"
mv.visitLdcInsn(fullName)
mv.visitMethodInsn(INVOKESTATIC, "com/hm/lifecycle/api/AppLifeCycleManager", "registerAppLike", "(Ljava/lang/String;)V", false);
})
}
@Override
protected void onMethodExit(int opcode) {
super.onMethodExit(opcode)
println "-------onMethodEnter------"
}
}
}
最后重新编译插件再运行，验证结果。
这里有个比较困难的地方，就是需要使用ASM编写class字节码。我这里推荐一个比较好用的方法：
- 将要注入的java源码先写出来；
- 通过javac编译出class文件；
- 通过asm-all.jar反编译该class文件，可得到所需的ASM注入代码；
执行命令如下：
java -classpath "asm-all.jar" org.objectweb.asm.util.ASMifier com/hm/lifecycle/api/AppLifeCycleManager.class
从中找到loadAppLike()方法字节码处，这样通过ASM注入代码就比较简单了：
{
mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC, "loadAppLike", "()V", null, null);
mv.visitCode();
mv.visitLdcInsn("com.hm.iou.lifecycle.apt.proxy.Heima$$ModuleAAppLike$$Proxy");
mv.visitMethodInsn(INVOKESTATIC, "com/hm/lifecycle/api/AppLifeCycleManager", "registerAppLike", "(Ljava/lang/String;)V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 0);
mv.visitEnd();
}
5. 小结
结合前一章我们基本上实现了自动注册加载组件的生命周期管理类，做到了无侵入式的服务注册，离我们的彻底组件化解耦更近一步了。本文有些地方借鉴了阿里的路由框架ARouter，其基本思路是一致的，弄懂了这些也基本上就弄懂了ARouter的实现原理 ，原理弄清楚了之后，在此基础上咱们写出自己的框架也不是什么难事了。
源码地址：https://github.com/houjinyun/Android-AppLifecycleMgr
源码已经托管到github上了， 有兴趣的可以跟我留言，互相交流学习进步。
系列文章
Android组件化开发实践（一）：为什么要进行组件化开发？
Android组件化开发实践（二）：组件化架构设计
Android组件化开发实践（三）：组件开发规范
Android组件化开发实践（四）：组件间通信问题
Android组件化开发实践（五）：组件生命周期管理
Android组件化开发实践（六）：老项目实施组件化
Android组件化开发实践（七）：开发常见问题及解决方案
Android组件化开发实践（八）：组件生命周期如何实现自动注册管理
Android组件化开发实践（九）：自定义Gradle插件
Android组件化开发实践（十）：通过Gradle插件统一规范