AspectJ

客官°小女子只卖身不卖艺 2022-06-07 04:41 189阅读 0赞

![AspectJ][]

**面向切面编程（AOP，Aspect-oriented programming）** 在 Android 中最流行的实践工具就是 AspectJ。

这篇文章就是来介绍 AspectJ 以及在 Android 中使用。

### AspectJ ###

AspectJ 是一种几乎和 Java 完全一样的语言，而且完全兼容 Java（AspectJ 应该就是一种扩展Java）。

使用 AspectJ 有两种方法：

*  纯 AspectJ 的语言。这语言一点也不难，和Java几乎一样，也能在AspectJ中调用Java的任何类库。AspectJ只是多了一些关键词罢了。
 *  纯 Java 语言开发，然后使用 AspectJ 注解，简称 `@AspectJ`。

不论哪种方法，最后都需要 AspectJ 的编译工具 **ajc** 来编译。由于 AspectJ 实际上脱胎于 Java，所以 **ajc** 工具也能编译 java 源码。

[AspectJ官方网站][AspectJ 1]

[AspectJ文档][AspectJ 2]

### AspectJ 简单概念 ###

要使用 AspectJ ，必须要先弄懂几个概念。

#### Join Points（连接点） ####

**Join Points** 是 **AspectJ** 中最关键的一个概念，它表示程序中可能作为代码注入目标的特定的点和入口。

比如说，一个方法的调用或者方法的执行是一个 **Join Points** ，设置或者读取一个变量也是一个**Join Points** 。

理论上说，一个程序中很多地方都可以被看做是 **Join Points**，但是 AspectJ 中，只有下面所示的几种执行点被认为是 **Join Points** ：

<table> 
 <thead> 
  <tr> 
   <th>Join Points</th> 
   <th>说明</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>method call</strong></td> 
   <td>函数调用</td> 
   <td>比如调用Log.e()，这是一处<strong>Join Points</strong></td> 
  </tr> 
  <tr> 
   <td><strong>method execution</strong></td> 
   <td>函数执行</td> 
   <td>比如Log.e()的执行内部，是一处<strong>Join Points</strong>。</td> 
  </tr> 
  <tr> 
   <td><strong>constructor call</strong></td> 
   <td>构造方法调用</td> 
   <td>和 method call 类似</td> 
  </tr> 
  <tr> 
   <td><strong>constructor execution</strong></td> 
   <td>构造函数执行</td> 
   <td>和method execution类似</td> 
  </tr> 
  <tr> 
   <td><strong>field get</strong></td> 
   <td>获取某个变量</td> 
   <td>比如读取 DemoActivity.debug 成员</td> 
  </tr> 
  <tr> 
   <td><strong>field set</strong></td> 
   <td>设置某个变量</td> 
   <td>比如设置DemoActivity.debug成员</td> 
  </tr> 
  <tr> 
   <td><strong>pre-initialization</strong></td> 
   <td>Object在构造方法中做得一些工作。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>initialization</strong></td> 
   <td>Object在构造方法中做得工作</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>static initialization</strong></td> 
   <td>类初始化</td> 
   <td>比如类的static{}</td> 
  </tr> 
  <tr> 
   <td><strong>handler</strong></td> 
   <td>异常处理</td> 
   <td>比如try catch(xxx)中，对应catch内的执行</td> 
  </tr> 
  <tr> 
   <td><strong>advice execution</strong></td> 
   <td>这个后面说</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

简单直白点说， **Join Points** 就是一个程序中的关键方法（包括构造方法）和代码段（staticblock）。

你想把新的代码插在程序的哪个地方，是插在构造方法中，还是插在某个方法调用前，或者是插在某个方法中，这个地方就是 **Join Points** ，当然，不是所有地方都能给你插的，只有支持的地方，才叫 **Join Points** 。

#### Advice（通知） ####

Advice 有三种方式 **Before、After、Around** ，分别表示在目标方法执行之前、执行后和完全替代目标方法执行的代码。

例如：

@Before("execution(* android.app.Activity.on**(..))")
    public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {
    }

这里会分成几个部分，我们依次来看：

*  **@Before** ：这个就是Advice，表示具体插入的方式。
 *  **execution** ：处理Join Point的类型，例如call、execution
 *  **(\* android.app.Activity.on\*\*(..))** ：这个是最重要的表达式，代表源码中需要 hook 的地方。
    
    第一个位置表示返回值，\* 表示返回值为任意类型，如果用注解，这里也需要填写`@注解全名` 。
    
    第二个位置表示具体位置，可是包名路径，其中可以包含 \* 来进行通配，几个 \* 没区别。
    
    第三个位置()代表这个方法的参数，你可以指定类型，例如android.os.Bundle，或者(..)这样来代表任意类型、任意个数的参数。
    
    同时，这里可以通过&&、||、!来进行条件组合。
 *  **public void onActivityMethodBefore** ：实际切入的代码。

**Before** 和 **After** 其实还是很好理解的，也就是在 Pointcuts 之前和之后，插入代码， **Around** 可以完全替代目标方法执行的代码，他包含了 **Before** 和 **After** 的全部功能，代码如下：

@Around("execution(* com.xys.aspectjxdemo.MainActivity.testAOP())")
    public void onActivityMethodAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        String key = proceedingJoinPoint.getSignature().toString();
        Log.d(TAG, "onActivityMethodAroundFirst: " + key);
        proceedingJoinPoint.proceed();
        Log.d(TAG, "onActivityMethodAroundSecond: " + key);
    }

其中，proceedingJoinPoint.proceed() 代表执行原始的方法，在这之前、之后，都可以进行各种逻辑处理，也可以不执行原始方法，进行完全替换。

#### Pointcut（切入点） ####

告诉代码注入工具，在何处注入一段特定代码的表达式。

#### Aspect（切面） ####

Pointcut 和 Advice 的组合看做切面。例如，我们在应用中通过定义一个 pointcut 和给定恰当的advice，添加一个日志切面。

#### Weaving（织入） ####

注入代码（advices）到目标位置（joint points）的过程。

一张图简要总结了一下上述这些概念。

![AspectJ][AspectJ 3]

#### AspectJ 的使用 ####

在 **Android**中配置 **Aspectj** 是特别麻烦的，我也试过最原始的配置方式，花了好长时间才搞定，非常麻烦。

好在江户的工作组已经简化的这件事情。他们在 Github 上开源了 [gradle\_plugin\_android\_aspectjx][gradle_plugin_android_aspectjx] 这个库，非常棒，这里就直接使用这个库，省下了很多繁琐的步骤。

#### 接入说明 ####

1.  在项目的根目录的build.gradle文件中添加依赖，修改后文件如下

repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.0'
        classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:1.0.8'
    
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }

1.  在编写 AspectJ 的项目或者库中，在其 build.gradle 文件中添加 AspectJ 的依赖

compile 'org.aspectj:aspectjrt:1.8.9'

1.  在使用 AspectJ 的项目中加入 AspectJX 的插件：

apply plugin: 'android-aspectjx'

**aspectjx** 默认会遍历项目编译后所有的 **.class** 文件和依赖的第三方库，去查找符合织入条件的切点，为了提升编译效率，可以加入过滤条件指定遍历某些库或者不遍历某些库。

`includeJarFilter` 和 `excludeJarFilter` 可以支持 groupId 过滤，artifactId 过滤，或者依赖路径匹配过滤

aspectjx {
        //织入遍历符合条件的库
        includeJarFilter 'universal-image-loader', 'AspectJX-Demo/library'
        //排除包含‘universal-image-loader’的库
        excludeJarFilter 'universal-image-loader'
    }

更多详细用法，直接查看 [Github 文档][gradle_plugin_android_aspectjx]。

#### 使用 ####

我们首先应用一个最简单的案例。

创建一个 AspectTest 的类：

@Aspect  //必须添加@Aspect 注解
    public class AspectTest { 
        final String TAG = AspectTest.class.getSimpleName();
    
        @Before("execution(* *..MainActivity+.on**(..))")
        public void method(JoinPoint joinPoint) throws Throwable {
            MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
            String className = joinPoint.getThis().getClass().getSimpleName();
    
            Log.e(TAG, "class:" + className);
            Log.e(TAG, "method:" + methodSignature.getName());
        }
    }

MainActivty的代码如下：

public class MainActivity extends AppCompatActivity { 
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    }

这样完成了一个简单的应用。

**AspectJ** 一般会配合注解来使用，在特定注解的位置处理代码。

再来一个案例，通过注解来打印方法的耗时：

1.  定义注解
    
        @Retention(RetentionPolicy.CLASS) //注意，不能是 RetentionPolicy.SOURCE
        @Target({ElementType.METHOD,ElementType.CONSTRUCTOR})
        public @interface Dove { 
        }
    
    注意，配合 AspectJ 时，注解的生命周期一定要定义成 **CLASS 或 RUNTIME** ，如果定义成 **SOURCE**，根据其原理可知，它找不到这个注解的。
2.  创建 AspectJ 的处理类
    
        @Aspect  //必须添加@Aspect 注解
        public class AspectDovePlugin { 
        
         @Pointcut("execution(@com.deemons.dove.Dove * *(..))")//方法切入点
         public void methodAnnotated() {
         }
        
         @Pointcut("execution(@com.deemons.dove.Dove *.new(..))")//构造器切入点
         public void constructorAnnotated() {
         }
        
         @Around("methodAnnotated()||constructorAnnotated()")
         public Object method(ProceedingJoinPoint joinPoint) throws Throwable {
        //AspectJ 的一些 API，用于获取信息。
           MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
           String canonicalName = methodSignature.getMethod().getDeclaringClass().getCanonicalName();
           String methodName = methodSignature.getName();
           long startTime = System.nanoTime();
           Object result = joinPoint.proceed();//执行原方法
        
           //拼接方法调用的参数，以及 方法执行的时间。
           StringBuilder keyBuilder = new StringBuilder();
           keyBuilder.append(canonicalName);
           keyBuilder.append(String.format(" : %s (", methodName));
           for (Object obj : joinPoint.getArgs()) {
             if (obj != null) {
               String format =
                   String.format(Locale.getDefault(), "%s = %s", obj.getClass().getSimpleName(),
                       obj.toString());
               keyBuilder.append(format);
             } else {
               keyBuilder.append("null");
             }
           }
           long during = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
           keyBuilder.append(String.format(Locale.getDefault(), ") --->:[%d ms]", during));
           Log.d("Dove", (keyBuilder.toString()));// 打印时间差
           return result;
         }
        }
3.  使用注解
    
        public class MainActivity extends AppCompatActivity { 
        
           @Dove
           @Override
           protected void onCreate(Bundle savedInstanceState) {
               super.onCreate(savedInstanceState);
               setContentView(R.layout.activity_main);
        
               test("test param",88);
           }
        
           @Dove
           private void test(String s,int i) {
               Log.d("","do test()");
           }
        }
    
    打印结果如下：
    
        test (String = test paramInteger = 88)   --->:[0 ms]
        onCreate (null)   --->:[37 ms]
    
    这样就完成了方法耗时以及调用参数的打印工作。

### 参考 ###

*  [安卓AOP三剑客:APT,AspectJ,Javassist][AOP_APT_AspectJ_Javassist]
 *  [AspectJ基本用法][AspectJ 4]
 *  [android\_aspectj 插件][android_aspectj]
 *  [【翻译】Android中的AOP编程][Android_AOP]

[AspectJ]: http://oslynwh8c.bkt.clouddn.com/image/hexo/pexels-photo-586958.jpeg
[AspectJ 1]: http://www.eclipse.org/aspectj/
[AspectJ 2]: http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/index.html
[AspectJ 3]: http://oslynwh8c.bkt.clouddn.com/image/hexo/AspectJ.png
[gradle_plugin_android_aspectjx]: https://github.com/HujiangTechnology/gradle_plugin_android_aspectjx
[AOP_APT_AspectJ_Javassist]: http://www.jianshu.com/p/dca3e2c8608a?from=timeline
[AspectJ 4]: http://www.jianshu.com/p/27b997677149
[android_aspectj]: https://github.com/HujiangTechnology/gradle_plugin_android_aspectjx/blob/master/README-zh.md
[Android_AOP]: http://www.jianshu.com/p/0fa8073fd144