devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

可使用AOP实现Android端非侵入式埋点数据上报的构想_android埋点上报

作者：小丑西瓜9 | 2024-03-19 03:04:42

赞

踩

android埋点上报

目录

一、OOP跟AOP

二、AspectJ是什么

三、AspectJ中的几个名词术语解释

四、AOP编程的具体使用场景

五、注入代码的时机

六、几个常用的工具和类库

七、为什么选择AspectJ

八、举例说明

这里我们有两点需要知道：

创建用于控制监听的类

封装一下android.util.Log

关键的Aspect类的实现

在build.gradle文件中的一些必要的配置

测试方法

运行结果：

总结

一、OOP跟AOP

OOP的精髓是把功能或问题模块化，每个模块处理自己的家务事。但在现实世界中，并不是所有问题都能完美得划分到模块中。举个最简单而又常见的例子：现在想为每个模块加上日志功能，要求模块运行时候能输出日志。在不知道AOP的情况下，一般的处理都是：先设计一个日志输出模块，这个模块提供日志输出API，比如Android中的Log类。然后，其他模块需要输出日志的时候调用Log类的几个函数，比如e(TAG,…)，w(TAG,…)，d(TAG,…)，i(TAG,…)等。

但是，从OOP角度看，除了日志模块本身，其他模块的家务事绝大部分情况下应该都不会包含日志输出功能。以ActivityManagerService为例，你能说它的家务事里包含日志输出吗？显然，ActivityManagerService的功能点中不包含输出日志这一项。但实际上，软件中的众多模块确实又需要打印日志。这个日志输出功能，从整体来看，都是一个面上的。而这个面的范围，就不局限在单个模块里了，而是横跨多个模块。

在AOP中：

第一，我们要认识到OOP世界中，有些功能是横跨并嵌入众多模块里的，比如打印日志，数据上报等。这些功能在各个模块里分散得很厉害，可能到处都能见到。 
第二，AOP的目标是把这些功能集中起来，放到一个统一的地方来控制和管理。如果说，OOP如果是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。比如我们可以设计两个Aspects，一个是管理某个软件中所有模块的日志输出的功能，另外一个是管理该软件中一些特殊函数调用的权限检查。

二、AspectJ是什么


正如面向对象编程是对常见问题的模块化一样，面向切面编程是对横向的同一问题进行模块化，比如在某个包下的所有类中的某一类方法中都需要解决一个相似的问题，可以通过AOP的编程方式对此进行模块化封装，统一解决。关于AOP的具体解释，可以参照维基百科。而AspectJ就是面向切面编程在Java中的一种具体实现。

AspectJ向Java引入了一个新的概念——join point，它包括几个新的结构： pointcuts，advice，inter-type declarations 和 aspects。

join point是在程序流中被定义好的点。pointcut在那些点上选出特定的join point和值。advice是到达join point时被执行的代码。

AspectJ还具有不同类型的类型间声明（inter-type declarations），允许程序员修改程序的静态结构，即其类的成员和类之间的关系。

三、AspectJ中的几个名词术语解释


Cross-cutting concerns：即使在面向对象编程中大多数类都是执行一个单一的、特定的功能，它们也有时候需要共享一些通用的辅助功能。比如我们想要在一个线程进入和退出一个方法时，在数据层和UI层加上输出log的功能。尽管每一个类的主要功能时不同的，但是它们所需要执行的辅助功能是相似的。

Advice：需要被注入到.class字节码文件的代码。通常有三种：before，after和around，分别是在目标方法执行前，执行后以及替换目标代码执行。除了注入代码到方法中外，更进一步的，你还可以做一些别的修改，例如添加成员变量和接口到一个类中。

Join point：程序中执行代码插入的点，例如方法调用时或者方法执行时。

Pointcut：告诉代码注入工具在哪里注入特定代码的表达式（即需要在哪些Joint point应用特定的Advice）。它可以选择一个这样的点（例如，一个单一方法的执行）或者许多相似的点（例如，所有被自定义注解@DebugTrace标记的方法）。

Aspect： Aspect将pointcut和advice 联系在一起。例如，我们通过定义一个pointcut和给出一个准确的advice实现向我们的程序中添加一个打印日志功能的aspect。

Weaving：向目标位置（join point）注入代码（advice）的过程。

上面几个名词间的关系的示意图如下：

这里写图片描述

四、AOP编程的具体使用场景


日志记录
持久化
行为监测
数据验证
缓存 
…


五、注入代码的时机


运行时：你的代码对增强代码的需求很明确，比如，必须使用动态代理（这可以说并不是真正的代码注入）。

加载时：当目标类被Dalvik或者ART加载的时候修改才会被执行。这是对Java字节码文件或者Android的dex文件进行的注入操作。

编译时：在打包发布程序之前，通过向编译过程添加额外的步骤来修改被编译的类。

具体使用哪一种方式视使用情况而定。

六、几个常用的工具和类库


AspectJ：和Java语言无缝衔接的面向切面的编程的扩展工具（可用于Android）。

Javassist for Android：一个移植到Android平台的非常知名的操纵字节码的java库。

DexMaker：用于在Dalvik VM编译时或运行时生成代码的基于java语言的一套API。

ASMDEX：一个字节码操作库（ASM），但它处理Android可执行文件（DEX字节码）。

七、为什么选择AspectJ


非常强大

易于使用

支持编译时和加载时的代码注入

八、举例说明

现在有一个需求，我们需要计算一个方法的运行时间，我们想通过给这个方法加上我们自定义的注解@DebugTrace来实现这个需求，而不是在业务代码中很生硬地插入计算时间的代码。这里我们就可以通过AspectJ来实现我们的目的。

这里我们有两点需要知道：

1、注解将在我们编译过程中的一个新步骤中被处理。

2、必要的模板代码将会被生成和注入到被注解的方法中。

在这个实例中，我们将分出两个module，一个用于业务代码，一个用于利用AspectJ进行代码注入。（这里要说明一下，AspectJ本身是一套java library，为了让AspectJ在Android上正确运行，我们使用了android library，因为我们必须在编译应用程序时使用一些钩子，只能使用android-library gradle插件。）
创建注解

  1. @Retention(RetentionPolicy.CLASS)
  2. @Target({ ElementType.CONSTRUCTOR, ElementType.METHOD })
  3. public @interface DebugTrace {}

创建用于控制监听的类

  1. /**
  2.  * Class representing a StopWatch for measuring time.
  3.  */
  4. public class StopWatch {
  5.   private long startTime;
  6.   private long endTime;
  7.   private long elapsedTime;
  8.  
  9.   public StopWatch() {
  10.     //empty
  11.   }
  12.  
  13.   private void reset() {
  14.     startTime = 0;
  15.     endTime = 0;
  16.     elapsedTime = 0;
  17.   }
  18.  
  19.   public void start() {
  20.     reset();
  21.     startTime = System.nanoTime();
  22.   }
  23.  
  24.   public void stop() {
  25.     if (startTime != 0) {
  26.       endTime = System.nanoTime();
  27.       elapsedTime = endTime - startTime;
  28.     } else {
  29.       reset();
  30.     }
  31.   }
  32.  
  33.   public long getTotalTimeMillis() {
  34.     return (elapsedTime != 0) ? TimeUnit.NANOSECONDS.toMillis(endTime - startTime) : 0;
  35.   }
  36. }

封装一下android.util.Log

  1. /**
  2.  * Wrapper around {@link android.util.Log}
  3.  */
  4. public class DebugLog {
  5.  
  6.   private DebugLog() {}
  7.  
  8.   /**
  9.    * Send a debug log message
  10.    *
  11.    * @param tag Source of a log message.
  12.    * @param message The message you would like logged.
  13.    */
  14.   public static void log(String tag, String message) {
  15.     Log.d(tag, message);
  16.   }
  17. }

关键的Aspect类的实现

  1. /**
  2.  * Aspect representing the cross cutting-concern: Method and Constructor Tracing.
  3.  */
  4. @Aspect
  5. public class TraceAspect {
  6.  
  7.   private static final String POINTCUT_METHOD =
  8.       "execution(@org.android10.gintonic.annotation.DebugTrace * *(..))";
  9.  
  10.   private static final String POINTCUT_CONSTRUCTOR =
  11.       "execution(@org.android10.gintonic.annotation.DebugTrace *.new(..))";
  12.  
  13.   @Pointcut(POINTCUT_METHOD)
  14.   public void methodAnnotatedWithDebugTrace() {}
  15.  
  16.   @Pointcut(POINTCUT_CONSTRUCTOR)
  17.   public void constructorAnnotatedDebugTrace() {}
  18.  
  19.   @Around("methodAnnotatedWithDebugTrace() || constructorAnnotatedDebugTrace()")
  20.   public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
  21.     MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  22.     String className = methodSignature.getDeclaringType().getSimpleName();
  23.     String methodName = methodSignature.getName();
  24.  
  25.     final StopWatch stopWatch = new StopWatch();
  26.     stopWatch.start();
  27.     // 被注解的方法在这一行代码被执行
  28.     Object result = joinPoint.proceed();
  29.     stopWatch.stop();
  30.  
  31.     DebugLog.log(className, buildLogMessage(methodName, stopWatch.getTotalTimeMillis()));
  32.  
  33.     return result;
  34.   }
  35.  
  36.   /**
  37.    * Create a log message.
  38.    *
  39.    * @param methodName A string with the method name.
  40.    * @param methodDuration Duration of the method in milliseconds.
  41.    * @return A string representing message.
  42.    */
  43.   private static String buildLogMessage(String methodName, long methodDuration) {
  44.     StringBuilder message = new StringBuilder();
  45.     message.append("Gintonic --> ");
  46.     message.append(methodName);
  47.     message.append(" --> ");
  48.     message.append("[");
  49.     message.append(methodDuration);
  50.     message.append("ms");
  51.     message.append("]");
  52.  
  53.     return message.toString();
  54.   }
  55. }

关于上面这段代码这里提两点：

我们声明了两个公共方法和两个pointcut用于过滤所有被”org.android10.gintonic.annotation.DebugTrace”标记的方法和构造器。

我们定义的 “weaveJointPoint(ProceedingJoinPoint joinPoint)” 这个方法被添加了”@Around”注解，这意味着我们的代码注入将发生在被”@DebugTrace”注解标记的方法前后。
 

在build.gradle文件中的一些必要的配置

要是AspectJ在Android上正确运行，还需要在build.gradle文件中进行一些必要的配置，如下：

  1. import com.android.build.gradle.LibraryPlugin
  2. import org.aspectj.bridge.IMessage
  3. import org.aspectj.bridge.MessageHandler
  4. import org.aspectj.tools.ajc.Main
  5.  
  6. buildscript {
  7.   repositories {
  8.     mavenCentral()
  9.   }
  10.   dependencies {
  11.     classpath 'com.android.tools.build:gradle:0.12.+'
  12.     classpath 'org.aspectj:aspectjtools:1.8.1'
  13.   }
  14. }
  15.  
  16. apply plugin: 'android-library'
  17.  
  18. repositories {
  19.   mavenCentral()
  20. }
  21.  
  22. dependencies {
  23.   compile 'org.aspectj:aspectjrt:1.8.1'
  24. }
  25.  
  26. android {
  27.   compileSdkVersion 19
  28.   buildToolsVersion '19.1.0'
  29.  
  30.   lintOptions {
  31.     abortOnError false
  32.   }
  33. }
  34.  
  35. android.libraryVariants.all { variant ->
  36.   LibraryPlugin plugin = project.plugins.getPlugin(LibraryPlugin)
  37.   JavaCompile javaCompile = variant.javaCompile
  38.   javaCompile.doLast {
  39.     String[] args = ["-showWeaveInfo",
  40.                      "-1.5",
  41.                      "-inpath", javaCompile.destinationDir.toString(),
  42.                      "-aspectpath", javaCompile.classpath.asPath,
  43.                      "-d", javaCompile.destinationDir.toString(),
  44.                      "-classpath", javaCompile.classpath.asPath,
  45.                      "-bootclasspath", plugin.project.android.bootClasspath.join(
  46.         File.pathSeparator)]
  47.  
  48.     MessageHandler handler = new MessageHandler(true);
  49.     new Main().run(args, handler)
  50.  
  51.     def log = project.logger
  52.     for (IMessage message : handler.getMessages(null, true)) {
  53.       switch (message.getKind()) {
  54.         case IMessage.ABORT:
  55.         case IMessage.ERROR:
  56.         case IMessage.FAIL:
  57.           log.error message.message, message.thrown
  58.           break;
  59.         case IMessage.WARNING:
  60.         case IMessage.INFO:
  61.           log.info message.message, message.thrown
  62.           break;
  63.         case IMessage.DEBUG:
  64.           log.debug message.message, message.thrown
  65.           break;
  66.       }
  67.     }
  68.   }
  69. }

测试方法

  1. @DebugTrace
  2.   private void testAnnotatedMethod() {
  3.     try {
  4.       Thread.sleep(10);
  5.     } catch (InterruptedException e) {
  6.       e.printStackTrace();
  7.     }
  8.   }

运行结果：

Gintonic --> testAnnotatedMethod --> [10ms]

我们可以通过对apk文件进行反编译来查看被注入后的代码。

总结

AOP编程在进行用户行为统计是是一种非常可靠的解决方案，避免了直接在业务代码中进行埋点，而AOP编程的应用还不仅于此，它在性能监控，数据采集等方面也有着广泛的应用，后续将继续研究，并整理发布。AspectJ是一个很强大的用于AOP编程的库，使用AspectJ关键在于掌握它的pointcut的语法，这里给一个AspectJ的官方的doc链接，需要注意的是，经过实际测试，有一些语法在Android中是无法使用的，需要在实际使用过程中进行总结。

参考文章：

1、https://blog.csdn.net/fly0078/article/details/80719863

2、https://blog.csdn.net/cmder1000/article/details/70193988

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号