Gradle插件开发(2) - extensions和Task

经过前边两篇介绍，我们了解了Gradle的基础知识和如何写一个自己的插件，我们今天,开始实战，搞点有趣的东西。

准备

今天前面的介绍，我们是可以实现自己的自定义task，当时android在构建是一个很琐碎的过程，之前的各个环节都是task，为了让开发人员更少也更好写业务代码，后来出了一套Transform API。

Transform

Transform 介绍

Transform是特意为Android打造的，按照官网的解释如下:

Starting with 1.5.0-beta1, the Gradle plugin includes a Transform API allowing 3rd party plugins to manipulate compiled class files before they are converted to dex files.
(The API existed in 1.4.0-beta2 but it’s been completely revamped in 1.5.0-beta1)

The goal of this API is to simplify injecting custom class manipulations without having to deal with tasks, and to offer more flexibility on what is manipulated. The internal code processing (jacoco, progard, multi-dex) have all moved to this new mechanism already in 1.5.0-beta1.
Note: this applies only to the javac/dx code path. Jack does not use this API at the moment.

简单解释下就是：

  1. Transforms是重新引入的，主要作用在对class的处理上，也是在生成dex文件前。
  2. Transforms有很强大功能，避免了大家使用task，内部可以处理jacoco, progard, multi-dex等过程。

在Android studio下我们若是执行./gradlew tasks就会发现很多以那么Transforms开头的task。

Transform API

我们可以注册多个transform,这个类似于task流式关系。
这写API可以参考如何理解 Transform API，可以认为transform是码头搬运的师父，你加入一个人，不影响个整体的码头的云端，前提是你要按照码头的规矩办事。
那么transform遵循码头的那些规矩呢？当然就是Transforms的API了,你要严格按照这个API定义每一步。
那么Transforms 有哪些API呢：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class XXXTransform extends Transform {
    @Override
    public String getName() {
        return null;
    }

    @Override
    public Set<QualifiedContent.ContentType> getInputTypes() {
        return null;
    }

    @Override
    public Set<? super QualifiedContent.Scope> getScopes() {
        return null;
    }

    @Override
    public boolean isIncremental() {
        return false;
    }

    @Override
    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        super.transform(transformInvocation);
    }
}

来解释下每个函数的作用：

  1. getName定义transform的名字，便于程序区分

  2. getInputTypes拦截输入的流的类型，哪些它会拦截呢？

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class TransformManager extends FilterableStreamCollection {

        public static final Set<ContentType> CONTENT_CLASS;
        public static final Set<ContentType> CONTENT_JARS;
        public static final Set<ContentType> CONTENT_RESOURCES;
        public static final Set<ContentType> CONTENT_NATIVE_LIBS;
        public static final Set<ContentType> CONTENT_DEX;
        public static final Set<ContentType> CONTENT_JACK;

    }

  3. getScopes是指transform的作用域，可以管理子模块还是其他的，具体参考TransformManager：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public static final Set<Scope> SCOPE_FULL_PROJECT = Sets.immutableEnumSet(
            Scope.PROJECT,
            Scope.PROJECT_LOCAL_DEPS,
            Scope.SUB_PROJECTS,
            Scope.SUB_PROJECTS_LOCAL_DEPS,
            Scope.EXTERNAL_LIBRARIES);
                 
    public static final Set<QualifiedContent.ScopeType> SCOPE_FULL_INSTANT_RUN_PROJECT =
            new ImmutableSet.Builder<QualifiedContent.ScopeType>()
                    .addAll(SCOPE_FULL_PROJECT)
                    .add(InternalScope.MAIN_SPLIT)
                    .build();

    public static final Set<Scope> SCOPE_FULL_LIBRARY = Sets.immutableEnumSet(
            Scope.PROJECT,
            Scope.PROJECT_LOCAL_DEPS);

  4. isIncremental：用于指明是否是增量构建

  5. transform(TransformInvocation transformInvocation)是整个类的核心，inputs中是传过来的输入流，其中有两种格式，一种是jar包格式一种是目录格式。outputProvider 获取到输出目录，最后将修改的文件复制到输出目录，这一步必须做不然编译会报错。

注册Transform

注册一个Transform到项目里，需要通过Plugin实现，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class TranPlugin implements Plugin<Project> {
    void apply(Project project) {
        System.out.println("------------------开始----------------------");
        //AppExtension就是build.gradle中android{...}这一块
        def android = project.extensions.getByType(AppExtension)

        //注册自己的Transform
        def classTransform = new ClassTransform(project);
        android.registerTransform(classTransform);

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

}

实现自己的Transform

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public class ClassTransform extends Transform {

    private Project mProject;

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

    /** transform的名称
     * transformClassesWithMyClassTransformForDebug 运行时的名字
     */
    @Override
    public String getName() {
        return "MyClassTransform";
    }

    //需要处理的数据类型，有两种枚举类型
    //CLASSES和RESOURCES，CLASSES代表处理的java的class文件，RESOURCES代表要处理java的资源
    @Override
    public Set<QualifiedContent.ContentType> 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<QualifiedContent.Scope> getScopes() {
        return TransformManager.SCOPE_FULL_PROJECT;
    }

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

    /**
     * Transform中的核心方法
     * inputs中是传过来的输入流，其中有两种格式，一种是jar包格式一种是目录格式。
     * outputProvider 获取到输出目录，最后将修改的文件复制到输出目录，这一步必须做不然编译会报错
     */
    @Override
    public void transform(Context context,
                          Collection<TransformInput> inputs,
                          Collection<TransformInput> referencedInputs,
                          TransformOutputProvider outputProvider,
                          boolean isIncremental) throws IOException, TransformException, InterruptedException {
        System.out.println("----------------进入transform了--------------")

       
        System.out.println("--------------结束transform了----------------")

    }

}

若这样，什么都不写，是我们的transform会报错，我们可以将遍历input文件，:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//遍历input
        inputs.each {
            TransformInput input ->
                //遍历文件夹
                input.directoryInputs.each {
                    DirectoryInput directoryInput ->
                       

                        // 获取output目录
                        def dest = outputProvider.getContentLocation(directoryInput.name,
                                directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)
                        println(directoryInput.file.getPath() + " ---> " + dest.toPath())

                        // 将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)
                }
        }

可以看到我们什么都没做，就是copy，不过copy文件是需要重新命名一个文件。
这样就可以将码头搬运过程中，从上一个工人人的东西，直接传给了下一个工人，只是有少些的改动。
那我们若是想在其中进行少些的改动呢？这就需要用到一个神奇的工具javassist。

Javassist

Javaassist可以用 Javassist 改变 Java 类的字节码，而无需真正了解关于字节码或者 Java 虚拟机(Java virtual machine JVM)结构的任何内容，这样他就可以直接修改class文件的字节码。

Javassist 基础

Javassist 使您可以检查、编辑以及创建 Java 二进制类。检查方面基本上与通过 Reflection API 直接在 Java 中进行的一样，但是当想要修改类而不只是执行它们时，则另一种访问这些信息的方法就很有用了。这是因为 JVM 设计上并没有提供在类装载到 JVM 中后访问原始类数据的任何方法，这项工作需要在 JVM 之外完成。

Javassist 使用 javassist.ClassPool 类跟踪和控制所操作的类。这个类的工作方式与 JVM 类装载器非常相似，但是有一个重要的区别是它不是将装载的、要执行的类作为应用程序的一部分链接，类池使所装载的类可以通过 Javassist API 作为数据使用。

装载到类池中的类由 javassist.CtClass 实例表示。与标准的 Java java.lang.Class 类一样， CtClass 提供了检查类数据（如字段和方法）的方法。不过，这只是 CtClass 的部分内容，它还定义了在类中添加新字段、方法和构造函数、以及改变类、父类和接口的方法。奇怪的是，Javassist 没有提供删除一个类中字段、方法或者构造函数的任何方法。

字段、方法和构造函数分别由 javassist.CtField、javassist.CtMethod 和 javassist.CtConstructor 的实例表示。这些类定义了修改由它们所表示的对象的所有方法的方法，包括方法或者构造函数中的实际字节码内容。

读写

1
2
3
4
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("me.cyning.cc.Rectangle");
cc.setSuperclass(pool.get("me.cyning.cc.Point"));
cc.writeFile();

这样就将test.Rectangle的父类设置为test.Point,其中 pool.get("test.Rectangle")就是用默认的ClassPool来装寨对应的class，并且可以使用装载的CtClass.

调用 writeFile() 后，这项修改会被写入原始类文件.
怎么验证呢？

1
2
Class rc = cc.toClass();
System.out.println(rc.getSuperclass());

函数

我们可以寨函数的前面和后面插入我们的值，如何做呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String[] args) throws Exception {
        ClassPool cp = ClassPool.getDefault();

        CtClass cc = cp.get("me.cyning.Hello");

        CtMethod m = cc.getDeclaredMethod("say");
        m.insertBefore("{ System.out.println(\"before Hello.say():\"); }");
        m.insertAfter("{ System.out.println(\"after Hello.say():\"); }");

        Class c = cc.toClass();
        Hello h = (Hello)c.newInstance();
        h.say();

}


public class Hello {
    public void say() {
        System.out.println("Hello");
    }
}

先将me.cyning.Helloload到Javassist的ClassPool中，获取到me.cyning.Hello类中的say方法，可以在方法开始和结尾来加入函数。
是不是有点意思。

打点统计

于是我们可以在我们类中直接使用Javassist来修改我们的class字节码。
接着transform中的transform方法来处理，所有的class到transform方法中都是以class文件存在的，所以拦截文件夹。

只需要在适当的方法里注入如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  ``````````````````````println("方法名 = " + mMethod.getName())
                        println("返回类型 = " + mMethod.getReturnType().getName())
//                        println("参数类型 = " + mMethod.getParameterTypes())


                        // 开始时间
                        mMethod.addLocalVariable("startMs", CtClass.longType);

                        mMethod.insertBefore("startMs = System.currentTimeMillis();");
                        String body = "{" +
                                "final long endMs = System.currentTimeMillis();" +

                                "System.out.println(\"Executed in ms: [" + className + "," + mMethod.getName() +
                                "] ---> \" + (endMs-startMs));}"


                        println(body)
                        mMethod.insertAfter(body)

找到对应的class的看下，生效：

最后的代码：
https://github.com/ownwell/Gradle-plugin

参考文章

Transform API
Android Plugin Transform 初探
Gradle通过Transform API实现代码注入
深入理解 Android 之 Gradle
Tutorial 1
Android ASM 插桩初步实现
Android热修复技术——QQ空间补丁方案解析(3)

网易乐得-Android AOP之字节码插桩