目标
实现自定义gradle插件,通过ASM实现在MainActivity的onCreate中插入Log打印语句
1. 自定义Gradle插件实现
gradle实现自定义插件一般有三种方式:
1. build.gradle中直接编写,项目内使用
2. 创建buildSrc module,项目内使用
3. 创建独立module,可发布远程仓库
考虑到灵活性,选择第三种方式实现自定义插件
1.1 创建module
创建一个新的module,删除不必要的文件,只留下build.gradle, src/main这两个文件和文件夹
1.2 创建目录和配置文件
1.2.1 在src/main下创建java和groovy目录以及resources/META-INF/gradle-plugins
目录,META-INF和gradle-plugins均为package
1.2.2 在resources/META-INF/gradle-plugins下创建xxxx.properties文件, xxxx为apply plugin时用到的名字,文件中内容为implementation-class = 插件的完整路径,这里可以先空着,后面创建了插件后再填入
1.3 build.gradle编写
build.gradle中引入groovy和maven插件,然后引入gradle插件,asm以及gradle api和库,最后进行编译
注意:此处的定义的group + 此module名(或者archivesBaseName定义) + version 即是插件的依赖地址,下方仓库设置中的pom.groupId, pom.artifactId, pom.version是同样的效果,同时设置会生成两个不同地址
apply plugin: 'groovy'
apply plugin: 'maven'
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation gradleApi()
implementation localGroovy()
implementation 'com.android.tools.build:gradle:3.5.3'
}
group='danny.lifecycle.plugin'
version='1.0.0'
uploadArchives {
repositories {
mavenDeployer {
// pom.groupId = 'com.xxx.plugin.gradle' //groupId
// pom.artifactId = 'xxx' //artifactId
// pom.version = '1.0.2' //版本号
//本地的Maven地址设置
repository(url: uri('../asm_lifecycle_repo'))
}
}
}
1.4 编写插件
编译完成后在groovy中添加package,创建实现Plugin<>接口的类文件,先使用java文件便于包和类的引入,具体实现如下,编写完成后将.java后缀改成.groovy,这就是自定义插件的入口
public class LifeCyclePlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
}
}
同级目录下创建继承Transform的类文件,同样使用java文件导入包和引用类,具体实现如下,编写完成后后缀改为.groovy,Transform的作用是可以在项目构建过程中.class文件转换成.dex文件期间获取到.class文件进行读取修改操作
public class LifeCycleTransform extends Transform {
@Override
public String getName() {
return "LifeCycleTransform";
}
@Override
public Set<QualifiedContent.ContentType> getInputTypes() {
return TransformManager.CONTENT_CLASS;
}
@Override
public Set<? super QualifiedContent.Scope> getScopes() {
return TransformManager.PROJECT_ONLY;
}
@Override
public boolean isIncremental() {
return false;
}
@Override
public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
}
}
getName(): 这里可以指定此task的名字,不过最终名字需要做一些拼接,transformClassesWith名字ForDebug/Release
getInputTypes(): 处理的文件类型,此处为class文件
getScopes(): 作用范围,此处为只处理当前项目文件
isIncremental(): 是否支持增量编译
transform(TransformInvocation transformInvocation): 主要处理文件和jar包的方法
编写完transform后,在plugin中进行注册,AppExtension就是指的build.gradle中的android{}闭包
public class LifeCyclePlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
def extension = project.extensions.getByType(AppExtension)
LifeCycleTransform transform = new LifeCycleTransform();
extension.registerTransform(transform)
}
}
1.5 生成仓库
此时在gradle任务中生成了uploadArchives任务,双击后即可生成插件仓库
1.6 自定义gradle插件引入和使用
在项目的根目录build.gradle中添加仓库路径,然后在dependencies中添加classpath,引入插件
buildscript {
repositories {
google()
jcenter()
maven {
url uri('./asm_lifecycle_repo')
}
}
dependencies {
classpath 'com.android.tools.build:gradle:3.5.3'
classpath 'danny.lifecycle.plugin:asm_lifecycle_plugin3:1.0.0'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
接着在要使用的module的build.gradle中通过apply plugin引入插件使用
apply plugin: 'com.android.application'
apply plugin: 'danny.asm.lifecycle'
这样,就完成了自定义gradle插件的编写和使用
2. ASM实现字节码插桩
2.1 引入ASM
完成自定义gradle插件后,在插件的build.gradle中添加ASM依赖
apply plugin: 'groovy'
apply plugin: 'maven'
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation gradleApi()
implementation localGroovy()
implementation 'com.android.tools.build:gradle:3.5.3'
//ASM相关依赖
implementation 'org.ow2.asm:asm:7.1'
implementation 'org.ow2.asm:asm-commons:7.1'
}
group='danny.lifecycle.plugin'
version='1.0.0'
uploadArchives {
repositories {
mavenDeployer {
// pom.groupId = 'com.xxx.plugin.gradle' //groupId
// pom.artifactId = 'xxx' //artifactId
// pom.version = '1.0.2' //版本号
//本地的Maven地址设置
repository(url: uri('../asm_lifecycle_repo'))
}
}
}
2.2 创建Visitor
在自定义插件module中的src/main/java下添加package,然后创建继承ClassVisitor的类文件,实现visit,visitMethod方法
public class LifecycleClassVisitor extends ClassVisitor {
private String className;
private String superName;
public LifecycleClassVisitor(ClassVisitor classVisitor) {
super(Opcodes.ASM5, classVisitor);
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
super.visit(version, access, name, signature, superName, interfaces);
this.className = name;
this.superName = superName;
}
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
MethodVisitor methodVisitor = cv.visitMethod(access, name, descriptor, signature, exceptions);
if (className.equals("com/example/lifecycledemo/MainActivity") && superName.equals("androidx/appcompat/app/AppCompatActivity")) {
if (name.startsWith("onCreate")) {
return new LifeCycleMethodVisitor(Opcodes.ASM5, methodVisitor, access, name, descriptor, className, superName);
}
}
return methodVisitor;
}
@Override
public void visitEnd() {
super.visitEnd();
System.out.println("ClassVisitor visitEnd()");
}
}
在visit方法中获取类名,超类名,在visitMethod方法中筛选类名MainActivity,超类AppCompatActivity的文件,接着筛选onCreate方法,最后返回一个继承 AdviceAdater的类
public class LifeCycleMethodVisitor extends AdviceAdapter {
private String className;
private String methodName;
protected LifeCycleMethodVisitor(int api, MethodVisitor methodVisitor, int access, String name, String descriptor, String className, String superName) {
super(api, methodVisitor, access, name, descriptor);
this.className = className;
this.superName = superName;
System.out.println("MethodVisitor Constructor");
}
@Override
protected void onMethodEnter() {
super.onMethodEnter();
System.out.println("MethodVisitor visitCode========");
mv.visitLdcInsn("TAG");
mv.visitLdcInsn(className + "---->" + methodName);
mv.visitMethodInsn(Opcodes.INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
mv.visitInsn(Opcodes.POP);
}
@Override
protected void onMethodExit(int opcode) {
mv.visitLdcInsn("TAG");
mv.visitLdcInsn("this is end");
mv.visitMethodInsn(Opcodes.INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
mv.visitInsn(Opcodes.POP);
super.onMethodExit(opcode);
}
}
在继承了AdviceAdapter的类中,实现onMethodEnter和onMethodExit方法,对应onCreate方法的开始和结束节点,在这两个节点通过MethodVisitor的一系列api调用插入Log打印语句
visitLdcInsn(final Object value)对应LDC指令
visitMethodInsn(final int opcode, final String owner, final String name, final String descriptor, final boolean isInterface)是访问方法指令,此处用到的五个参数
opcode: 对应字节码指令操作码,此处传入了 调用类方法的指令
owner: 方法所在包
name: 方法名
descriptor: 方法描述符,前一个Ljava/lang/String:Ljava/lang/String指明方法有两个String类型参数,最后的 I 表示方法返回int类型
isInterface: 是否是接口类的实现方法
visitInsn()对应空操作数指令,比如POP, DUP
注:此处也可直接继承MethodVisitor,实现visitCode方法插入代码,但要实现在方法结束前插入代码需要另外实现visitInsn(int opcode)方法,根据opcode == RETURN来判断指令执行到方法末尾了,插入代码后再调用super方法即可
2.3 读取class文件数据
在自定义继承Transform类的transform方法中进行操作,通过getInputs()获取输入的class文件和jar包的路径,outputProvider管理输出路径,接着遍历inputs,directoryInputs获取到class文件的路径集合,再次遍历,筛选出class文件,通过ClassReader进行读取,ClassWriter进行写入,将classWiter传入自定义的ClassVisitor中,接着调用classReader的accept方法正式对class文件进行读取并调用classVisitor中的方法,比如visit(),visitMethod()等,我们在里面对MainActivity的onCreate方法中加入了一行Log打印语句,然后通过classWriter的toByteArray()方法输出修改后的class文件btye数组,覆盖掉原来的class文件,最后将修改后的class文件目录整个copy新的目录下,这个新目录是根据输入的内容,作用范围等信息生成的,供下一个Task使用
@Override
public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
Collection<TransformInput> inputs = transformInvocation.getInputs()
TransformOutputProvider outputProvider = transformInvocation.outputProvider
inputs.each {TransformInput input ->
input.directoryInputs.each {DirectoryInput directoryInput ->
File dir = directoryInput.file
if (dir) {
dir.traverse (type: FileType.FILES, nameFilter: ~/.*\.class/) { File file ->
println("find class: " + file.name)
//对class文件进行读取
ClassReader classReader = new ClassReader(file.bytes)
//对class文件的写入
ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS)
//访问class文件相应的内容,解析到某一个结构就会通知到classVisitor相应的方法
println("before visit")
ClassVisitor visitor = new LifecycleClassVisitor(classWriter)
println("after visit")
//依次调用ClassVisitor接口的各个方法
classReader.accept(visitor, ClassReader.EXPAND_FRAMES)
println("after accept")
//toByteArray方法会将最终修改的字节码以byte数组形式返回
byte[] bytes = classWriter.toByteArray()
//通过文件流写入方式覆盖掉原先的内容,实现class文件的改写
FileOutputStream fileOutputStream = new FileOutputStream(file.path)
fileOutputStream.write(bytes)
fileOutputStream.close()
}
}
def dest = outputProvider.getContentLocation(directoryInput.name, directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)
FileUtils.copyDirectory(directoryInput.file, dest)
}
}
}
2.4 运行
代码都全部编写之后,再次点击uploadArchives任务生成本地仓库,然后就可以运行项目检测插桩是否成功了,这是项目中的MainActivity文件,可以看到只在onCreate中第一行打印了一个log
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
Log.i("TAG", "is this the first log?");
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
项目运行后,在LogCat中筛选TAG,可以看到打印语句的输出,onMethodEnter中插入的语句最先输出,接着是在onCreate方法开头的语句,最后是在onMethodExit中插入的语句
3. 总结
自定义Gradle插件遵循一定的规则,手动实现几次就能掌握,插件和ASM的衔接在Transform中完成,插件负责输入数据,ASM接收数据后进行字节码修改,最后再重新输出,ASM的使用主要还是流程和api的掌握,比较不好编写的是最终插入和修改字节码的api,如果对字节码指令不太熟悉的话可以安装一个ASM Bytecode Viewer插件,将相关操作在java文件中完成,运用插件编译成字节码和ASM指令格式,照搬过来就行