推广

埋点的探索，自动注入的方案

iseeyu2年前 (2024-02-22)推广130

img1.png

(2)在resources 文件夹下创建 xxxx.properties 文件并设置implementation-class ，properties 文件名为插件对外引用名称既主项目引用插件名，implementation-class 定义插件主文件。

implementation-class=com.awarmisland.plugin.CusPlugin

(3) 设置buildSrc 的 build 文件，引入groovy ,和 gradle api 同步下项目

apply plugin: 'groovy'  //必须
apply plugin: 'maven'
dependencies {
    implementation gradleApi() //必须
    implementation localGroovy() //必须
    //如果要使用android的API，需要引用这个，实现Transform的时候会用到
    implementation 'com.android.tools.build:gradle:3.1.3'
    implementation 'com.android.tools.build:gradle-api:3.1.3'
}
repositories {
    google()
    jcenter()
    mavenCentral() //必须
}

(4)主项目引入buildSrc插件

apply plugin: 'com.awarmisland.plugin'

(5) CusPlugin 继承 PluginProject, 通过apply 添加需要执行的task，Transform 就是我们需要编写的自定义编译class task 可以引入多个task，当我们执行build project时候，在AS build窗口会看到我们自定义的task。

def android = project.extensions.getByType(AppExtension)
 //注册Transform
android.registerTransform(new ActivityLifecycleTransform(project),Collections.EMPTY_LIST)
android.registerTransform(new FragmentLifecycleTransform(project),Collections.EMPTY_LIST)
android.registerTransform(new RecordTransform(project),Collections.EMPTY_LIST)

(6)定义BaseTransform 主要设计目的是为了抽离编译过程的代码，统筹分类处理。Transform task 任务是依次执行，所以当我们读取了class 文件修改处理后，需要覆盖原来文件，交给下一个task 执行。p.s. 理论大概就是这样，这里需要小心处理，不然很容易编译不通过。

abstract class BaseTransform extends Transform implements TransformInterface{
@Override
void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        def transformName = getName();
        println '--------------- '+transformName+' visit start --------------- '
        def startTime = System.currentTimeMillis()
        Collection<TransformInput> inputs = transformInvocation.inputs
        TransformOutputProvider outputProvider = transformInvocation.outputProvider
        //删除之前的输出
        if (outputProvider != null)
            outputProvider.deleteAll()
        //遍历inputs
        inputs.each { TransformInput input ->
            //遍历directoryInputs
            input.directoryInputs.each { DirectoryInput directoryInput ->
                //处理directoryInputs
                handleDirectoryInput(directoryInput, outputProvider)
            }

            //遍历jarInputs
            input.jarInputs.each { JarInput jarInput ->
                //处理jarInputs
                handleJarInputs(jarInput, outputProvider)
            }
        }
        def cost = (System.currentTimeMillis() - startTime) / 1000
        println '--------------- '+transformName+' visit end --------------- '
        println transformName+" cost ： $cost s"
}

 /**
     * 遍历sdk 中的class
     * 处理Jar中的class文件
     */
     void handleJarInputs(JarInput jarInput, TransformOutputProvider outputProvider) {
        if (jarInput.file.getAbsolutePath().endsWith(".jar")) {
            //重名名输出文件,因为可能同名,会覆盖
            def jarName = jarInput.name
            def md5Name = DigestUtils.md5Hex(jarInput.file.getAbsolutePath())
            if (jarName.endsWith(".jar")) {
                jarName = jarName.substring(0, jarName.length() - 4)
            }

            JarFile jarFile = new JarFile(jarInput.file)
            Enumeration enumeration = jarFile.entries()
            File tmpFile = new File(jarInput.file.getParent() + File.separator + "classes_temp.jar")
            //避免上次的缓存被重复插入
            if (tmpFile.exists()) {
                tmpFile.delete()
            }
            JarOutputStream jarOutputStream = new JarOutputStream(new FileOutputStream(tmpFile))
            //用于保存
            while (enumeration.hasMoreElements()) {
                JarEntry jarEntry = (JarEntry) enumeration.nextElement()
                String entryName = jarEntry.getName()
                ZipEntry zipEntry = new ZipEntry(entryName)
                InputStream inputStream = jarFile.getInputStream(jarEntry)
//                println("className: "+entryName)
                jarOutputStream.putNextEntry(zipEntry)
                //处理 插桩class
                if(isModifyClass(entryName)&&entryName.endsWith(".class")){
                    byte[] code = modifyClass(entryName, IOUtils.toByteArray(inputStream))
                    if(code){
                        jarOutputStream.write(code)
                    }else{
                        jarOutputStream.write(IOUtils.toByteArray(inputStream))
                    }
                }else{
                    jarOutputStream.write(IOUtils.toByteArray(inputStream))
                }
                jarOutputStream.closeEntry()
            }
            //结束
            jarOutputStream.close()
            jarFile.close()

            def dest = outputProvider.getContentLocation(jarName + md5Name,
                    jarInput.contentTypes, jarInput.scopes, Format.JAR)
            FileUtils.copyFile(tmpFile, dest)
            tmpFile.delete()
        }
    }

(7)现在来看看实践，我们需要在 Activity 生命周期中埋点，记录Activity 生命周期事件。这个时候我们就得在基类FragmentActivity 中注入我们的埋点代码。
    前面的BaseTransform 基类已经封装好遍历class 的调度方法。我们继承它定义一个ActivityLifecycleTransform，isModifyClass 用于过滤需要修改的class 文件，modifyClass为主要处理注入代码逻辑方法。
    重点来了，如何实现代码注入呢？代码注入就是需要修改class 文件，ASM 帮到你。（其实还有其它库，比如Javassist）
    ASM是字节码处理库，常用处理元素ClassVisitor MethodVisitor 对应类访问，方法访问。在modifyClass 方法中，我们通过ClassReader 读取 class 文件，再通过ClassWrite 授权修改class 文件。

class ActivityLifecycleTransform extends BaseTransform {

    ActivityLifecycleTransform(Project p) {
        super(p)
    }

    @Override
    String getName() {
        return "ActivityLifecycleTransform"
    }

    @Override
    boolean isModifyClass(String className) {
        if ("android/support/v4/app/FragmentActivity.class".equals(className)) {
            return true
        }
        return false
    }

    byte[] modifyClass(String className, byte[] classBytes) {
        println '----------- deal with "class" file <' + className + '> -----------'
        ClassReader classReader = new ClassReader(classBytes)
        ClassWriter classWriter = new ClassWriter(classReader,ClassWriter.COMPUTE_MAXS)
        ClassVisitor cv = new LifecycleClassVisitor(classWriter)
        classReader.accept(cv,EXPAND_FRAMES)
        return classWriter.toByteArray()
    }
}

(8)自定义LifecycleClassVisitor 集成ClassVisitor , ClassVisitor 对类内部元素读取也是有规律的，我们暂时不研究，对方法的读取回调在visitMethod ，我们可以获取到方法名name, 通过方法名过滤出需要埋点的方法。

public class LifecycleClassVisitor extends ClassVisitor {
    private String mClassName;

    public LifecycleClassVisitor(ClassVisitor cv) {
        super(Opcodes.ASM5,cv);
    }

    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
//        System.out.println("LifecycleClassVisitor:visit----->started"+name);
        this.mClassName = name;
        super.visit(version, access, name, signature, superName, interfaces);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { ;
        MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
        LifecycleMethodVisitor method  = new LifecycleMethodVisitor(mv);
        //匹配FragmentActivity
        if ("onResume".equals(name)
                ||"onStop".equals(name)) {
            //处理onCreate
            method.setLifecycleName(name);
            return method;
        }
        return mv;
    }
}

(9) 和ClassVistor 一样，MethodVisitor 用于访问 method 中代码，也是有其访问规律，可以说是访问的生命周期。 visitCode 开始访问代码，此时，我们开始在这里注入字节代码。mv.xxxx 6行代码其实代表着 DotComponent.getInstance().recordLifecycle(this.getClass().getName(), lifecycleName); 这一句埋点执行逻辑代码。java在编译成class 文件前，会先转化成机器可识别的字节码，然后再编译成二进制码。现在我们就用ASM 语法手动创建了需要注入的逻辑代码的字节码。这个时候肯定有人问，那注入代码岂不是需要另外学习字节码的语法规则? 其实总得来说，如果你需要深入定制，就有必要学习了，但是我们只是简单使用的话，知道一点皮毛就ok ，而且我们是可以通过工具生成字节码的。

public class LifecycleMethodVisitor extends MethodVisitor {

    private String lifecycleName;

    public LifecycleMethodVisitor(MethodVisitor mv){
        super(Opcodes.ASM5, mv);
    }

    @Override
    public void visitCode() {
        super.visitCode();
        //方法执行后插
        //  DotComponent.getInstance().recordLifecycle(this.getClass().getName(), lifecycleName);
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, DOT_PATH, "getInstance", "()L"+DOT_PATH+";", false);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;", false);
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "getName", "()Ljava/lang/String;", false);
        mv.visitLdcInsn(lifecycleName);
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, DOT_PATH, "recordLifecycle", "(Ljava/lang/String;Ljava/lang/String;)V", false);
    }
}

Plugins 搜索 ASM 找到ASM Bytecode Outline 安装，然后就可以在需要注入的java 文件右键生成字节码，具体的方法可以找度娘，很多介绍的

img2.png

最后~ build project 就会将代码注入到FragmentActivity onResume 方法中

img3.png

img4.jpg

4.Github地址

https://github.com/awarmisland/BuryingPoint

5.参考文章

http://www.woshipm.com/data-analysis/450268.html
https://blog.csdn.net/jiang547860818/article/details/64121698?utm_source=blogkpcl0
https://www.jianshu.com/p/a1e6b3abd789
关于plugin debug 可参考这个文章
https://www.jianshu.com/p/99c8e953654e