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

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

1.需求导向 1.1.需求导向,背景描述 产品期望埋点需求,一般是页面访问统计,使用时长, 某按钮或模块点击事件统计或者是复杂行为统计。总的来说产品期望看到的统计数据是丰富而且能够尽量灵活满足多变需求,但app 总会因为变更需求而需要更新版本,这算是产品变化需...

1.需求导向

1.1.需求导向,背景描述

产品期望埋点需求,一般是页面访问统计,使用时长, 某按钮或模块点击事件统计或者是复杂行为统计。总的来说产品期望看到的统计数据是丰富而且能够尽量灵活满足多变需求,但app 总会因为变更需求而需要更新版本,这算是产品变化需求与本身开发设计的博弈。所以,我们设计埋点方案时候,就得归纳出产品常见需要统计的数据是哪些,常见的统计功能和报表,另外就是开发设计上的灵活。

1.2.常见统计需求

  • 页面访问次数
  • 页面访问人数
  • 页面访问时长
  • 页面流向分布
  • 自定义事件统计

2.常见的埋点统计方案

目前常见的埋点统计方案一般是引入第三方库,使用其平台观测数据,如友盟统计,能够满足绝大部分统计场景,还支持多渠道数据监测。但是第三方统计的方式相对固定,所以未必能满足自定义统计需求,缺点是局限于第三方统计到的数据,而且不能将数据源导出到自身运营统计平台上。所以为了满足产品的需求,我们得设计一套符合自己产品的埋点统计方案。

2.1.雏形方案

思路

2.1.1.页面统计

定义BaseActivity,BaseFragment基类,在onResume ,onPause 方法处,设置埋点方法记录页面生命周期。因为onResume,onPause是对称出现的(忽略其它因素导致onPause不执行影响),所以可以根据它们统计出页面使用时长。

    @Override
    protected void onResume() {
        super.onResume();
        DotComponent.getInstance().recordLifecycle(getClass().getName(),"onResume");
    }
    @Override
    protected void onPause() {
        super.onPause();
        DotComponent.getInstance().recordLifecycle(getClass().getName(),"onPause");
    }

2.1.2.点击事件统计

在BaseActivity,BaseFragment 的onCreate方法中,加入hookView核心方法,遍历需要 “关注的view” 。view的点击事件是存放在ListenerInfo这个类里面,通过反射获取OnClickListener 变量,最后通过动态代理方式,创建带有埋点功能的代理点击事件,替换换原来OnClickListener。

//定义某个页面 某个控件,需要埋点的事件
//ListenerProxyEnum 统计事件类型
 configList.put(MainActivity.class.getName(), new ArrayList(){{
            add(new ViewProxyEvent(MainActivity.class.getName(),R.id.btn_test,"btn_test",ListenerProxyEnum.CLICK_PROXY));
        }});
 private  void hookView(View view,ViewProxyEvent event){
        try {
            ListenerProxyEnum proxyEnum = event.proxyEnum;
            Class viewClazz = Class.forName("android.view.View");
            //事件监听器都是这个实例保存的
            Method listenerInfoMethod = viewClazz.getDeclaredMethod("getListenerInfo");
            if (!listenerInfoMethod.isAccessible()) {
                listenerInfoMethod.setAccessible(true);
            }
            Object listenerInfoObj = listenerInfoMethod.invoke(view);
            Class listenerInfoClazz = Class.forName("android.view.View$ListenerInfo");
            //需要更换的目标事件
            Field onClickListenerField = listenerInfoClazz.getDeclaredField(proxyEnum.listenName);
            if (!onClickListenerField.isAccessible()) {
                onClickListenerField.setAccessible(true);
            }
            Object mListener =   onClickListenerField.get(listenerInfoObj);
            //自定义代理事件监听器
            BaseListenerProxy proxy = getProxyInstance(proxyEnum.cls,mListener,event);
            //更换
            onClickListenerField.set(listenerInfoObj, proxy);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 public BaseListenerProxy getProxyInstance(Class proxyClass, Object sourceEvent,ViewProxyEvent event{
     //点击事件代理 OnClickListenerProxy 为加入埋点自定义事件
     if(proxyClass.getSimpleName().equals(OnClickListenerProxy.class.getSimpleName())){
            return new OnClickListenerProxy((View.OnClickListener) sourceEvent,event);
     }
     //其它事件
     //...
     return null;
}
//自定义代理事件
public class OnClickListenerProxy extends BaseListenerProxy implements View.OnClickListener {
    public OnClickListenerProxy(View.OnClickListener object, ViewProxyEvent event) {
        this.object = object;
        this.event = event;
    }
    @Override
    public void onClick(View v) {
            //执行注入事件
            execute();
            if(object != null) {
                object.onClick(v);
            }
        }
    }
   @Override
   protected void execute() {
         DotComponent.getInstance().recordViewClick(event.className, event.viewIdName);
   }
}

总结:

此方案虽然能够满足一般埋点要求,但是扩展性和维护性并不高,默认要求了相同展示页面下,viewID不能相同,而且需要配置”关注view” 的事件,配置列表会越来越大。

3.最后研究的优化方案

3.1 ASM引述

ASM 是一个 Java 字节码操控框架。它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件,也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .class 文件里,这些类文件拥有足够的元数据来解析类中的所有元素:类名称、方法、属性以及 Java 字节码(指令)。ASM 从类文件中读入信息后,能够改变类行为,分析类信息,甚至能够根据用户要求生成新类。说白了asm是直接通过字节码来修改class文件。

3.2 思路

ASM 可以在编译时候修改字节码,也就是说,我们可以通过ASM 动态注入 埋点代码。对于原有项目入侵小,不需要额外增加基类,同时可以把埋点 业务逻辑抽离出来作为module单独维护。

3.3 实现步骤

1.利用buildSrc 方式 构建gradle 插件(方便实时修改调试)
2.再利用Plugin Transform 在编译class 文件时候 注入代码
以下是图文介绍具体步骤
(1)创建以buildSrc 命名的 moudle ,删除多余文件,新建groovy文件夹

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 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  -----------'
        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

文章来源于互联网:埋点的探索,自动注入的方案

0

评论0

鱼翔浅底,鹰击长空,驼走大漠
没有账号? 注册  忘记密码?