Android动态编译技术 Plugin Transform Javassist操作Class文件

前言

继续上一章节自定义Gradle插件,利用plugin进一步做一些事情

本章节利用Google提供的Transform API 在编译的过程中操作.class文件。

先说一下Transform是什么

gradle从1.5开始,gradle插件包含了一个叫Transform的API,这个API允许第三方插件在class文件转为为dex文件前操作编译好的class文件,这个API的目标是简化自定义类操作,而不必处理Task,并且在操作上提供更大的灵活性。并且可以更加灵活地进行操作。
官方文档:http://google.github.io/android-gradle-dsl/javadoc/
我们接着在上面的demo中继续完成使用Transform API,

在我们自定义的gradle插件的build.gradle中引入transform的包,下面会进行代码注入,就一起引入的其他包

compile 'com.android.tools.build:transform-api:1.5.0'
compile 'javassist:javassist:3.12.1.GA'
compile 'commons-io:commons-io:2.5'

项目地址:TransformPlugin

接下来创建一个类继承Transform 并实现其方法

package zxy.com.plugin

import com.android.build.api.transform.*
import com.android.build.gradle.internal.pipeline.TransformManager
import org.apache.commons.codec.digest.DigestUtils
import org.apache.commons.io.FileUtils
import org.gradle.api.Project



public class MyClassTransform extends Transform {

private Project mProject;

public MyClassTransform(Project p) {
    this.mProject = p;
}

//transform的名称
//transformClassesWithMyClassTransformForDebug 运行时的名字
//transformClassesWith + getName() + For + Debug或Release
@Override
public String getName() {
    return "MyClassTransform";
}

//需要处理的数据类型,有两种枚举类型
//CLASSES和RESOURCES,CLASSES代表处理的java的class文件,RESOURCES代表要处理java的资源
@Override
public Set getInputTypes() {
    return TransformManager.CONTENT_CLASS;
}

//    指Transform要操作内容的范围,官方文档Scope有7种类型:

//    EXTERNAL_LIBRARIES        只有外部库
//    PROJECT                       只有项目内容
//    PROJECT_LOCAL_DEPS            只有项目的本地依赖(本地jar)
//    PROVIDED_ONLY                 只提供本地或远程依赖项
//    SUB_PROJECTS              只有子项目。
//    SUB_PROJECTS_LOCAL_DEPS   只有子项目的本地依赖项(本地jar)。
//    TESTED_CODE                   由当前变量(包括依赖项)测试的代码
@Override
public Set getScopes() {
    return TransformManager.SCOPE_FULL_PROJECT;
}

//指明当前Transform是否支持增量编译
@Override
public boolean isIncremental() {
    return false;
}

//    Transform中的核心方法,
//    inputs中是传过来的输入流,其中有两种格式,一种是jar包格式一种是目录格式。
//    outputProvider 获取到输出目录,最后将修改的文件复制到输出目录,这一步必须做不然编译会报错
@Override
public void transform(Context context,
                      Collection inputs,
                      Collection referencedInputs,
                      TransformOutputProvider outputProvider,
                      boolean isIncremental) throws IOException, TransformException, InterruptedException {
    System.out.println("你愁啥----------------进入transform了--------------")
    //遍历input
    inputs.each { TransformInput input ->
        //遍历文件夹
        input.directoryInputs.each { DirectoryInput directoryInput ->
            //注入代码
            MyInjects.inject(directoryInput.file.absolutePath, mProject)

            // 获取output目录
            def dest = outputProvider.getContentLocation(directoryInput.name,
                    directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)

            // 将input的目录复制到output指定目录
            FileUtils.copyDirectory(directoryInput.file, dest)
        }

        ////遍历jar文件 对jar不操作,但是要输出到out路径
        input.jarInputs.each { JarInput jarInput ->
            // 重命名输出文件(同目录copyFile会冲突)
            def jarName = jarInput.name
            println("jar = " + jarInput.file.getAbsolutePath())
            def md5Name = DigestUtils.md5Hex(jarInput.file.getAbsolutePath())
            if (jarName.endsWith(".jar")) {
                jarName = jarName.substring(0, jarName.length() - 4)
            }
            def dest = outputProvider.getContentLocation(jarName + md5Name, jarInput.contentTypes, jarInput.scopes, Format.JAR)
            FileUtils.copyFile(jarInput.file, dest)
        }
    }
    System.out.println("瞅你咋地--------------结束transform了----------------")
}

}

在我们自定义的gradle插件的apply方法中注册自定义的Transform,上一章节已经有介绍过apply入口

def android = project.extensions.getByType(AppExtension)
//注册一个Transform
def classTransform = new MyClassTransform(project);
android.registerTransform(classTransform);

BuildConfig这个类大家并不陌生,在项目里会用到,大家知道这个类可以增加我们自定义的属性吗,可是你知道怎么生成的么?

//我们自定义的
testCreatJavaConfig{
str = "动态生成java类的字符串"
}

然后回到我们的自定义的Plugin中,贴一下整个代码

import com.android.build.gradle.AppExtension
import com.android.build.gradle.AppPlugin
import org.gradle.api.Plugin
import org.gradle.api.Project
/**
* @author:xinyu.zhou
*/
public class MyPlugin implements Plugin {

void apply(Project project) {
    System.out.println("------------------开始----------------------");
    System.out.println("这是我们的自定义插件!");
    //AppExtension就是build.gradle中android{...}这一块
    def android = project.extensions.getByType(AppExtension)

    //注册一个Transform
    def classTransform = new MyClassTransform(project);
    android.registerTransform(classTransform);

    //创建一个Extension,名字叫做testCreatJavaConfig 里面可配置的属性参照MyPlguinTestClass
    project.extensions.create("testCreatJavaConfig", MyPlguinTestClass)

    //生产一个类
    if (project.plugins.hasPlugin(AppPlugin)) {
        //获取到Extension,Extension就是 build.gradle中的{}闭包
        android.applicationVariants.all { variant ->
                //获取到scope,作用域
                def variantData = variant.variantData
            def scope = variantData.scope

            //拿到build.gradle中创建的Extension的值
            def config = project.extensions.getByName("testCreatJavaConfig");

            //创建一个task
            def createTaskName = scope.getTaskName("CeShi", "MyTestPlugin")
            def createTask = project.task(createTaskName)
            //设置task要执行的任务
            createTask.doLast {
                //生成java类
                createJavaTest(variant, config)
            }
            //设置task依赖于生成BuildConfig的task,然后在生成BuildConfig后生成我们的类
            String generateBuildConfigTaskName = variant.getVariantData().getScope().getGenerateBuildConfigTask().name
            def generateBuildConfigTask = project.tasks.getByName(generateBuildConfigTaskName)
            if (generateBuildConfigTask) {
                createTask.dependsOn generateBuildConfigTask
                generateBuildConfigTask.finalizedBy createTask
            }
        }

    }
    System.out.println("------------------结束了吗----------------------");
}

static def void createJavaTest(variant, config) {
    //要生成的内容
    def content = """package com.zxy.plugin;

 

    public class MyPlguinTestClass {
        public static final String str = "${config.str}";
    }
    """;
    //获取到BuildConfig类的路径
    File outputDir = variant.getVariantData().getScope().getBuildConfigSourceOutputDir()

    def javaFile = new File(outputDir, "MyPlguinTestClass.java")

    javaFile.write(content, 'UTF-8');
}
 }

class MyPlguinTestClass {
def str = "默认值";
}

编译一下看一下效果


Android动态编译技术 Plugin Transform Javassist操作Class文件_第1张图片

可以看到我在app目录下的build.gradle文件里配置的testCreatJavaConfig 生效了,可以取到str的值

接下来要使用javassist,简单介绍下

  • Javassist是一个动态类库,可以用来检查、”动态”修改以及创建 Java类。其功能与jdk自带的反射功能类似,但比反射功能更强大
  • ClassPool:javassist的类池,使用ClassPool 类可以跟踪和控制所操作的类,它的工作方式与 JVM 类装载器非常相似,
    CtClass: CtClass提供了检查类数据(如字段和方法)以及在类中添加新字段、方法和构造函数、以及改变类、父类和接口的方法。不过,Javassist 并未提供删除类中字段、方法或者构造函数的任何方法。
    CtField:用来访问域
    CtMethod :用来访问方法
    CtConstructor:用来访问构造器

想了解更多请自行查阅资料

下面我们利用Transform在MainActivity中动态的插入代码,先看一下现在的MainAcitivity

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    TextView textView= findViewById(R.id.tv);
    textView.setText(com.zxy.plugin.MyPlguinTestClass.str);
}
}

可以看到上面的setText中使用的是我们上面动态生成的类中的字段,看一下怎么利用Transform插入代码,先看一下Transform中代码

//    Transform中的核心方法,
//    inputs中是传过来的输入流,其中有两种格式,一种是jar包格式一种是目录格式。
//    outputProvider 获取到输出目录,最后将修改的文件复制到输出目录,这一步必须做不然编译会报错
@Override
public void transform(Context context,
                      Collection inputs,
                      Collection referencedInputs,
                      TransformOutputProvider outputProvider,
                      boolean isIncremental) throws IOException, TransformException, InterruptedException {
    System.out.println("你愁啥----------------进入transform了--------------")
    //遍历input
    inputs.each { TransformInput input ->
        //遍历文件夹
        input.directoryInputs.each { DirectoryInput directoryInput ->
            //注入代码
            MyInjects.inject(directoryInput.file.absolutePath, mProject)

            // 获取output目录
            def dest = outputProvider.getContentLocation(directoryInput.name,
                    directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)

            // 将input的目录复制到output指定目录
            FileUtils.copyDirectory(directoryInput.file, dest)
        }

        ////遍历jar文件 对jar不操作,但是要输出到out路径
        input.jarInputs.each { JarInput jarInput ->
            // 重命名输出文件(同目录copyFile会冲突)
            def jarName = jarInput.name
            println("jar = " + jarInput.file.getAbsolutePath())
            def md5Name = DigestUtils.md5Hex(jarInput.file.getAbsolutePath())
            if (jarName.endsWith(".jar")) {
                jarName = jarName.substring(0, jarName.length() - 4)
            }
            def dest = outputProvider.getContentLocation(jarName + md5Name, jarInput.contentTypes, jarInput.scopes, Format.JAR)
            FileUtils.copyFile(jarInput.file, dest)
        }
    }
    System.out.println("瞅你咋地--------------结束transform了----------------")
}

生成代码在MyInjects类中,在这个类中我们传入了两个参数,一个是当前变量的文件夹,一个是当前的工程对象,来看一下代码

 public class MyInjects {
//初始化类池
private final static ClassPool pool = ClassPool.getDefault();

public static void inject(String path,Project project) {
    //将当前路径加入类池,不然找不到这个类
    pool.appendClassPath(path);
    //project.android.bootClasspath 加入android.jar,不然找不到android相关的所有类
    pool.appendClassPath(project.android.bootClasspath[0].toString());
    //引入android.os.Bundle包,因为onCreate方法参数有Bundle
    pool.importPackage("android.os.Bundle");

    File dir = new File(path);
    if (dir.isDirectory()) {
        //遍历文件夹
        dir.eachFileRecurse { File file ->
            String filePath = file.absolutePath
            println("filePath = " + filePath)
            if (file.getName().equals("MainActivity.class")) {

                //获取MainActivity.class
                CtClass ctClass = pool.getCtClass("com.zxy.plugin.MainActivity");
                println("ctClass = " + ctClass)
                //解冻
                if (ctClass.isFrozen())
                    ctClass.defrost()

                //获取到OnCreate方法
                CtMethod ctMethod = ctClass.getDeclaredMethod("onCreate")

                println("方法名 = " + ctMethod)

                String insetBeforeStr = """ android.widget.Toast.makeText(this,"WTF emmmmmmm.....我是被插了的Toast代码~!!",android.widget.Toast.LENGTH_SHORT).show();
                                            """
                //在方法开头插入代码
                ctMethod.insertBefore(insetBeforeStr);
                ctClass.writeFile(path)
                ctClass.detach()//释放
            }
        }
    }

}
}

通过反编译可以看到我们成功的注入了一个Toast


Android动态编译技术 Plugin Transform Javassist操作Class文件_第2张图片

运行效果


总结

还是那句话,本章节是让我们了解plugin和javassist结合使用入门,很多插件化等技术都会用到javassist,需要我们更多的深入了解和探索,无论是自定义gradle还是注入代码这些技术都是通往大牛之路的必备技能,有描述错误的地方欢迎童鞋们指出。


点赞加关注是给我最大的鼓励!

你可能感兴趣的:(Android动态编译技术 Plugin Transform Javassist操作Class文件)