Android知识体系之Aop Aspectj

Android知识体系

AspectJ基础知识

AspectJ in Android （一），AspectJ 基础概念
AspectJ in Android （二），AspectJ 语法
Android中AOP实践之三AspectJ解析篇

AspectJ 是使用最为广泛的 AOP 实现方案，适用于 Java 平台，官网地址：http://www.eclipse.org/aspectj/ 。
AspectJ 是在静态织入代码，即在编译期注入代码的。

AspectJ 提供了一套全新的语法实现，完全兼容 Java（跟 Java 之间的区别，只是多了一些关键词而已）。同时，还提供了纯 Java 语言的实现，通过注解的方式，完成代码编织的功能。因此我们在使用 AspectJ 的时候有以下两种方式：

• 使用 AspectJ 的语言进行开发
• 通过 AspectJ 提供的注解在 Java 语言上开发

在 Android Studio 上一般使用注解的方式使用 AspectJ，因为 Android Studio 没有 AspectJ 插件，无法识别 AspectJ 的语法。

基本概念

• Aspect ：切面，一个关注点的模块化，这个关注点可能会横切多个对象。
• Join Point ：连接点，程序中可切入的点，例如方法调用时、读取某个变量时。
• Pointcut ：切入点，代码注入的位置，其实就是有条件限定的 Join Point，例如只在特定方法中注入代码。
• Advice ：在切入点注入的代码，一般有 before、after、around 三种类型。
• Target Object ：被一个或多个 aspect 横切拦截操作的目标对象。
• Weaving ： 把 Advice 代码织入到目标对象的过程。
• Inter-type declarations : 用来给一个类型声明额外的方法或属性。

把下面的一个例子拿上来，我们来理解一下这些概念：

class Cat {
    public void eat() {...}
}
class A {
    public void test() {
        new Cat().eat();
    }
}
@Aspect
public class Test {
    @Before("call(* Cat.eat())")
    public void testCall(JoinPoint joinPoint) {
        // ....
        System.out.println("1111")
    }
    @After("execution(* Cat.eat())")
    public void testExecution(JoinPoint joinPoint) {
        // ....
    }
}

我们来看testCall()：

• Pointcut是execution(* Cat.eat())
• Join Point是Cat里面的eat()方法
• 在eat()执行前，打印“1111”
• Advice是Before

我们再来看testExecution()：

• Pointcut是call(* Cat.eat())
• Join Point是new Cat().eat()
• 在执行new Cat().eat()之后，打印“1111”
• Advice是After

Join Point

Join Point 表示连接点，即 AOP 可织入代码的点，下表列出了 AspectJ 的所有连接点：

个人感觉Join Point是能力，就是Aspectj有那些功能

Pointcuts

Pointcuts 是具体的切入点，可以确定具体织入代码的地方，基本的 Pointcuts 是和 Join Point 相对应的。

除了上面与 Join Point 对应的选择外，Pointcuts 还有其他选择方法：

Pointcut 表达式还可以 ！、&&、|| 来组合

上面 Pointcuts 的语法中涉及到一些 Pattern，下面是这些 Pattern 的规则，[]里的内容是可选的：

类型匹配的通配符

示例

execution

public interface Waiter {
    void greetTo(String name);
    void serveTo(String name);
}
public class NaiveWaiter implements Waiter {
    @Override
    public void greetTo(String name) {
        System.out.println("NaiveWaiter：greet to " + name + "...");
    }
    @Override
    public void serveTo(String name) {
        System.out.println("NaiveWaiter：serving to " + name + "...");
    }
    public void smile(String clientName,int times){
        System.out.println("NaiveWaiter:smile to  "+clientName+ times+"times...");
    }
}
public class NaughtyWaiter implements Waiter {
    public void greetTo(String clientName) {
        System.out.println("NaughtyWaiter:greet to " + clientName + "...");
    }
    public void serveTo(String clientName) {
        System.out.println("NaughtyWaiter:serving " + clientName + "...");
    }
    public void joke(String clientName, int times) {
        System.out.println("NaughtyWaiter:play " + times + " jokes to " + clientName + "...");
    }
    private void privateMethod() {}
}

spring AspectJ的Execution表达式-备忘笔记(转)

call

• call(@retrofit2.http.GET public com.johnny.core.http..(..)) – ‘com.johnny.core.http’开头的包下面的所有 GET 方法调用时

• call(android.support.v4.app.Fragment+.new(..)) – support 包中的 Fragment 及其子类的构造函数调用时

@Before("call(* *.*(..)) && this(foo)")
public void callFromFoo(Foo foo) {
    Log.d(TAG, "call from Foo:" + foo);
}

代表在Foo里面调用的任何方法

set

• set(@Inject ) – 写入所有 @Inject 注解修饰的属性时

handler

• handler(IOException) && within(com.johnny.core.http..) – ‘com.johnny.core.http’开头的包代码中处理 IOException 时

Pointcut 声明

• Pointcuts 可以在普通的 class 或 Aspect class 中定义
• 由 org.aspectj.lang.annotation.Pointcut 注解修饰的方法声明
• 方法返回值只能是 void
• @Pointcut 修饰的方法只能由空的方法实现而且不能有 throws 语句
• 方法的参数和 pointcut 中的参数相对应。

我们来看一个例子：

@Aspect
class Test {
    @Pointcut("execution(void Foo.foo(..)")
    public void executFoo() {}
    @Pointcut("executFoo() && cflowbelow(executFoo()) && target(foo) && args(i)")
    public void loopExecutFoo(Foo foo, int i) {}
}

• @Aspect修饰的类
• 使用@Pointcut注解来声明
• executFoo和loopExecutFoo 都是void的方法
• executFoo和loopExecutFoo 都是 空方法
• loopExecutFoo(Foo foo, int i)的参数 与 @Pointcut中的一一对应

execution() 与 call()

• execution，表示的Join Point，在方法执行的位置
• call，表示的Join Point，在方法调用的位置

举个例子：

class Cat {
    public void eat() {...}
}
class A {
    public void test() {
        new Cat().eat();
    }
}

• execution(* Cat.eat())，Pointcut 选取的 Join Point是Cat里面的eat()方法
• call(* Cat.eat())，Pointcut 选取的 Join Point是A里面test()方法new Cat().eat()这一行

target() 与 this()

AspectJ之this和target的区别（四）

target() 与 this() 很容易混淆，我们有必要强调一下：

• target() 是指 Pointcut 选取的 Join Point 的所有者；
• this() 是指 Pointcut 选取的 Join Point 的调用的所有者。

简单地说就是，PointcutA 选取的是 methodA，那么 target 就是 methodA() 这个方法的对象，而 this 就是 methodA 被调用时所在类的对象。

我们来举个例子：

class Cat {
    public void eat() {...}
}
public class TargetThisActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_target_this);
        eat();
    }
    public void eat(){
        new Cat().eat();
    }
}
@Before("call(* *..eat(..)) && target(com.xxx.Cat)")
    public void hookRun(JoinPoint joinPoint) {
        Log.d("test", "eat:" + joinPoint.getSourceLocation().getLine() + " " + joinPoint.getTarget() + " " + joinPoint.getThis());
    }

我们来分析一下：

call(* *..eat(..))，表示任何调用方法名为eat的方法

调用eat()的地方有两个:

• TargetThisActivity的onCreate()里面调用了eat()，target是TargetThisActivity对象，this是TargetThisActivity对象
• TargetThisActivity的eat()里面调用了Cat的eat()，target是Cat对象，this是TargetThisActivity对象

所以，再次强调一下：

• target() 是指 Pointcut 选取的 Join Point 的所有者；
• this() 是指 Pointcut 选取的 Join Point 的调用的所有者。

因为target(com.xxx.Cat)，所以只有第二个调用eat()的地方会被织入代码。

假如我们把上面的call(* *..eat(..))，换成execution(* *..eat(..))，那么会怎么样呢？

execution(* *..eat(..))，表示任何方法名为eat的方法

有两个eat():

• TargetThisActivity的eat()方法，target是TargetThisActivity对象，this是TargetThisActivity对象
• Cat的eat()方法，target是Cat对象，this是Cat对象

Advice

Advice 是在切入点上织入的代码，在 AspectJ 中有五种类型：Before、After、AfterReturning、AfterThrowing、Around。

需要注意的是：

• Advice 注解修改的方法必须为 public
• Before、After、AfterReturning、AfterThrowing 四种类型修饰的方法返回值也必须为 void
• Around 的目标是替代原 Join Point 的，所以它一般会有返回值，而且返回值的类型需要匹配被选中的 Join Point 的代码
• Handler Pointcut 不能使用 After 和 Around。
• Around使用的ProceedingJoinPoint，其他的是JoinPoint

Aspect

Aspect 就是 AOP 中的关键单位 – 切面，我们一般会把相关 Pointcut 和 Advice 放在一个 Aspect 类中。

• 在基于 AspectJ 注解开发方式中只需要在类的头部加上 @Aspect 注解即可
• @Aspect 不能修饰接口。

Android Studio引入aspectj

方法一

• 在工程的build.gradle里面，buildscript-dependencies下面添加

classpath 'org.aspectj:aspectjtools:1.8.9'

• 在你开发aspectj的library module的build.gradle里面添加

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
apply plugin: 'com.android.library'
android {
    // ...
}
dependencies {
    // ...
    // 这里！！！！
    implementation 'org.aspectj:aspectjrt:1.8.9'
    api project(':logaop-annotation')
}
// 这里！！！！
android.libraryVariants.all { variant ->
    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
        String[] args = [
                "-showWeaveInfo",
                "-1.7",
                "-inpath", javaCompile.destinationDir.toString(),
                "-aspectpath", javaCompile.classpath.asPath,
                "-d", javaCompile.destinationDir.toString(),
                "-classpath", javaCompile.classpath.asPath,
                "-bootclasspath", android.bootClasspath.join(File.pathSeparator)
        ]
        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler)
        def log = project.logger
        for (IMessage message : handler.getMessages(null, true)) {
            switch (message.getKind()) {
                case IMessage.ABORT:
                case IMessage.ERROR:
                case IMessage.FAIL:
                    log.error message.message, message.thrown
                    break;
                case IMessage.WARNING:
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}

• 在App的build.gradle里面，添加

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
apply plugin: 'com.android.application'
android {
    // ...
}
dependencies {
    // ...
    compile project(path: ':logaop-annotation')
    // 这里！！！！
    implementation 'org.aspectj:aspectjrt:1.8.9'
}
// 这里！！！！
final def log = project.logger
final def variants = project.android.applicationVariants
variants.all { variant ->
    if (!variant.buildType.isDebuggable()) {
        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
        return;
    }
    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
        String[] args = ["-showWeaveInfo",
                         "-1.7",
                         "-inpath", javaCompile.destinationDir.toString(),
                         "-aspectpath", javaCompile.classpath.asPath,
                         "-d", javaCompile.destinationDir.toString(),
                         "-classpath", javaCompile.classpath.asPath,
                         "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]
        log.debug "ajc args: " + Arrays.toString(args)
        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler);
        for (IMessage message : handler.getMessages(null, true)) {
            switch (message.getKind()) {
                case IMessage.ABORT:
                case IMessage.ERROR:
                case IMessage.FAIL:
                    log.error message.message, message.thrown
                    break;
                case IMessage.WARNING:
                    log.warn message.message, message.thrown
                    break;
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}

好了，大功告成，可以开始开发了

注意

如果是其他module需要该功能，则每一个需要的module，都需要加上

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
apply plugin: 'com.android.library'
android {
    // ...
}
dependencies {
    // ...
    // 这里！！！！
    implementation 'org.aspectj:aspectjrt:1.8.9'
    api project(':logaop-annotation')
}
// 这里！！！！
android.libraryVariants.all { variant ->
    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
        String[] args = [
                "-showWeaveInfo",
                "-1.7",
                "-inpath", javaCompile.destinationDir.toString(),
                "-aspectpath", javaCompile.classpath.asPath,
                "-d", javaCompile.destinationDir.toString(),
                "-classpath", javaCompile.classpath.asPath,
                "-bootclasspath", android.bootClasspath.join(File.pathSeparator)
        ]
        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler)
        def log = project.logger
        for (IMessage message : handler.getMessages(null, true)) {
            switch (message.getKind()) {
                case IMessage.ABORT:
                case IMessage.ERROR:
                case IMessage.FAIL:
                    log.error message.message, message.thrown
                    break;
                case IMessage.WARNING:
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}

并且也需要依赖你编写aspectj的那个module，类似上面:logaop-annotation

方法二

gradle_plugin_android_aspectjx
直接利用这个gradle插件就可以，具体的可以参考这个的read me

AspectJ使用方式

AspectJ in Android （三），AspectJ 两种用法以及常见问题
以 Pointcut 切入点作为区分，AspectJ 有两种用法：

侵入式

侵入式用法，一般会使用自定义注解，以此作为选择切入点的规则。

下面以 JakeWharton 大神的 hugo 为例，分析自定义注解 AOP 的使用。hugo 是用于在开发环境中打印方法调用信息的，只会打印注解修饰的方法。

首先看下新增的自定义注解：

@Target({TYPE, METHOD, CONSTRUCTOR}) @Retention(CLASS)
public @interface DebugLog {
}

上面定义了@DebugLog注解，可以修饰类、接口、方法和构造函数，可在 Class 文件中保留，编译期可用。

再看 hugo 的切面代码，代码说明在注释中：

@Aspect
public class Hugo {
  private static volatile boolean enabled = true;
  // @DebugLog 修饰的类、接口的 Join Point
  @Pointcut("within(@hugo.weaving.DebugLog *)")
  public void withinAnnotatedClass() {} 
  // synthetic 是内部类编译后添加的修饰语，所以 !synthetic 表示非内部类的
  // 执行 @DebugLog 修饰的类、接口中的方法，不包括内部类中方法
  @Pointcut("execution(!synthetic * *(..)) && withinAnnotatedClass()")
  public void methodInsideAnnotatedType() {} 
  // 执行 @DebugLog 修饰的类中的构造函数，不包括内部类的构造函数
  @Pointcut("execution(!synthetic *.new(..)) && withinAnnotatedClass()")
  public void constructorInsideAnnotatedType() {} 
  // 执行 @DebugLog 修饰的方法，或者 @DebugLog 修饰的类、接口中的方法
  @Pointcut("execution(@hugo.weaving.DebugLog * *(..)) || methodInsideAnnotatedType()")
  public void method() {} 
  // 执行 @DebugLog 修饰的构造函数，或者 @DebugLog 修饰的类中的构造函数
  @Pointcut("execution(@hugo.weaving.DebugLog *.new(..)) || constructorInsideAnnotatedType()")
  public void constructor() {} 
  ...
  @Around("method() || constructor()")
  public Object logAndExecute(ProceedingJoinPoint joinPoint) throws Throwable {
    enterMethod(joinPoint); // 打印切入点方法名、参数列表
    long startNanos = System.nanoTime();
    Object result = joinPoint.proceed(); // 调用原来的方法
    long stopNanos = System.nanoTime();
    long lengthMillis = TimeUnit.NANOSECONDS.toMillis(stopNanos - startNanos);
    exitMethod(joinPoint, result, lengthMillis); // 打印切入点方法名、返回值、方法执行时间
    return result;
  }
...
...

从上面代码可以看出 hugo 是以 @DebugLog 作为选择切入点的条件，只需要用 @DebugLog 注解类或者方法就可以打印方法调用的信息。

总结

所以，可以看出侵入式 AspectJ 的特点：

• 需要自定义注解
• 切入点需要添加注解，会侵入切入点代码
• 不需要修改 Aspect 切面代码，就可以随意修改切入点

非侵入式

非侵入式，就是不需要使用额外的注解来修饰切入点，不用修改切入点的代码。

下面以 Activity、Fragment 页面统计以及点击事件统计为例，分析非侵入式 Aspectj 在 Android 项目中的使用。

Activity 页面统计

AspectJ 无法在 Activity 中织入代码，因为 Activity 属于 android.jar，是安卓平台代码，Class 文件不会在编译时打包进 apk 中。
但是项目中继承自 Activity 的子类可以作为切入点，因为编译期会变成 Class 文件。

网上一些统计 Activity 例子是这样：

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

上面的代码是以 Activity 及其子类的 onXX 方法作为切入点，但是 Activity 类是无法切入的，而 Activity 的子类的话需要重写的 onXX 方法。那么，就会存在两个问题：

• 如果 BaseActivity 和 其子类 XXActivity 都重写了 onPause 方法，那么两个方法都会织入 AOP 代码，所以 XXActivity 执行 onPause 方法时，会调用两次数据统计的 AOP 代码；
• 如果 XXActivity 没有重写 onDestroy 方法，那么就 XXActivity.onDestroy 方法就无法作为切入点。

如果要解决这两个问题，可以这样：

有个 BaseActivity 作为所有 Activity 的基类，而且 BaseActivity 重写了 Activity 的所有 onXX 方法时，可以以 BaseActivity 作为切入点。Pointcut 表达式：execution(* BaseActivity.on**(..))

当然，如果直接在BaseActivity里面添加统计内容，应该更方便吧，哈哈

Fragment 页面统计

我们统计Fragment 的显示与隐藏，那么就不能仅仅依靠 onResume/onPause 两个来判断，在使用 Fragment Tab 时，tab 切换触发的回调是 onHiddenChanged 方法，而 ViewPager 中切换 Fragment 时触发的是 setUserVisibleHint，所以需要切入这四个方法。

@Pointcut("execution(void onHiddenChanged(boolean)) && within(android.support.v4.app.Fragment) && target(fragment) && args(hidden)")
public void onHiddenChanged(Fragment fragment, boolean hidden) {}
@Pointcut("execution(void setUserVisibleHint(..)) && within(android.support.v4.app.Fragment) && target(fragment) && args(visible)")
public void setUserVisibleHint(Fragment fragment, boolean visible) {}
@Pointcut("execution(void onResume()) && within(android.support.v4.app.Fragment) && target(fragment)")
public void onResume(Fragment fragment) {}
@Pointcut("execution(void onPause()) && within(android.support.v4.app.Fragment) && target(fragment)")
public void onPause(Fragment fragment) {}

Click 事件统计

很容易写出下面代码：

@Pointcut("execution(void android.view.View.OnClickListener.onClick(..))  && args(view)")
public void onClick(View view) {}

但是上面的 Pointcut 其实是不全面的，setOnClickListener(new OnClickListener() {…}) 这种匿名内部类写法时没问题，如果是实现 OnClickListener 接口的类则无法切入。所以应该加上 OnClickListener 的子类，使用 OnClickListener+。

@Pointcut("execution(void android.view.View.OnClickListener+.onClick(..))  && args(view)")
public void onClick(View view) {}

这种写法还可以监听到 ButterKnife 的点击事件，因为 ButterKnife 使用一个实现了 OnClickListener 的抽象接口。

总结

所以，从上面的示例可以看出非侵入式 AspectJ 的特点：

• 不需要额外的自定义注解
• 不会侵入切入点代码
• 很难精确控制切入点，需要修改切入点时，必须修改切面代码

实例

打印方法的开始和结束log，并且包含方法的执行时间。

参考：XMark

我们参考这个，来实现一个功能：打印方法的开始和结束log，并且包含方法的执行时间。

注解

我们定义一个注解，当被这个注解修饰的方法，我们才打印log

• 新建一个java library，比如说logaop-annotation
• 定义注解，如下：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
public @interface Log {
    /**
     * 日志的优先级(默认是0)
     */
    int priority() default 0;
}

aspectj library

然后，我们来利用aspectj，植入代码

• 新建一个android library，参照上面的“方法一”来设置build.gradle
• 然后新建一个LogAspectJ的类

@Aspect
public class LogAspectJ {
    @Pointcut("within(@com.meituan.qcs.android.logaop.annotation.Log *)")
    public void withinAnnotatedClass() {
    }
    @Pointcut("execution(!synthetic * *(..)) && withinAnnotatedClass()")
    public void methodInsideAnnotatedType() {
    }
    @Pointcut("execution(!synthetic *.new(..)) && withinAnnotatedClass()")
    public void constructorInsideAnnotatedType() {
    }
    @Pointcut("execution(@com.meituan.qcs.android.logaop.annotation.Log * *(..)) || methodInsideAnnotatedType()")
    public void method() {
    } //方法切入点
    @Pointcut("execution(@com.meituan.qcs.android.logaop.annotation.Log *.new(..)) || constructorInsideAnnotatedType()")
    public void constructor() {
    } //构造器切入点
    //@Around("(method() || constructor()) && @annotation(log)")
    @Around(value = "(method() || constructor()) && @annotation(log)", argNames = "joinPoint, log")
    //@Around("method() || constructor()")
    public Object logAndExecute(ProceedingJoinPoint joinPoint, Log log) throws Throwable {
        enterMethod(joinPoint, log);
        long startNanos = System.nanoTime();
        Object result = joinPoint.proceed();
        long stopNanos = System.nanoTime();
        long lengthMillis = TimeUnit.NANOSECONDS.toMillis(stopNanos - startNanos);
        exitMethod(joinPoint, log, result, lengthMillis);
        return result;
    }
    // ....
    // ....
}

具体的Pointcut就不讲了，上面都说说过了，我们来看下@Around，我一共写了三个，我们来一一看下：

• @Around("method() || constructor()")
  这个是没有传参数，它的logAndExecute只有一个参数，是这样的：

 public Object logAndExecute(ProceedingJoinPoint joinPoint) throws Throwable {

• @Around("(method() || constructor()) && @annotation(log)")
  这个是会把log对应的注解类型对象传进来的，我们可以通过log拿到Log的值，例如这里的priority
• @Around(value = "(method() || constructor()) && @annotation(log)", argNames = "joinPoint, log")
  这个跟第二个基本上一样

注意了！！！！！

• @annotation(log)，这里是log，不是Log，是参数，不是参数的类型，我就是卡在这里，卡了好久！！！！
• 上面写注解的时候，我们的Log是可以修饰类的，如果我们是第一个的写法，没问题，这个类的所有方法都会被织入，但是！！！！！第二个和第三个的写法，修饰类的时候，不起作用，不会织入代码，只能修饰方法可以，至于为什么？我也不知道～～～

使用

@Log(priority=6)
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    String className = mDatas.get(position).className;
    try {
        Intent intent = new Intent(this, Class.forName(className));
        startActivity(intent);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

这个方法被执行的时候，就会打印日志了，我们可以来看下生成的代码，在app-build-intermediates-classes下面来看，生成的class文件是否被织入了代码：

@Log(
        priority = 6
    )
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    StaticPart var10000 = ajc$tjp_0;
    Object[] var14 = new Object[]{parent, view, Conversions.intObject(position), Conversions.longObject(id)};
    JoinPoint var13 = Factory.makeJP(var10000, this, this, var14);
    LogAspectJ var16 = LogAspectJ.aspectOf();
    Object[] var15 = new Object[]{this, parent, view, Conversions.intObject(position), Conversions.longObject(id), var13};
    ProceedingJoinPoint var10001 = (new MainActivity$AjcClosure1(var15)).linkClosureAndJoinPoint(69648);
    Annotation var10002 = ajc$anno$0;
    if (ajc$anno$0 == null) {
        var10002 = ajc$anno$0 = MainActivity.class.getDeclaredMethod("onItemClick", AdapterView.class, View.class, Integer.TYPE, Long.TYPE).getAnnotation(Log.class);
    }
    var16.logAndExecute(var10001, (Log)var10002);
}

替换android.util.Log

auv1107/Hugo
我们来替换android.util.Log的所有打印代码

aspectj library

@Aspect
public class LogAspectJ2 {
    @Pointcut("within(com.android.logaop.*)")
    public void withinPlugin() {}
    @Pointcut("call(static * android.util.Log.*(String,String))")
    public void log() {}
    @Around("log() && !withinPlugin()")
    public Object printLog(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        String tag = (String) joinPoint.getArgs()[0];
        String msg = (String) joinPoint.getArgs()[1];
        Log.e("22222", tag + " ---> " + msg);
        return 0;
    }
}

我们不调用原来的代码，直接打印出来，当然这个是测试代码，我们可以拦截之后，使用其他更好的处理方法。

自定义Gradle插件

我们用上面的方法一引入的话，比较麻烦，这个时候我们可以通过自定义Gradle插件来实现。

原理

时机

aop方案对比

参考

https://zhuanlan.zhihu.com/p/56172076
2、hugo
http://www.mapeiyu.com/2017/03/22/add-logic-through-annotation/
https://xiaozhuanlan.com/topic/1428095376
https://blog.csdn.net/hp910315/article/details/52701809

3、aspectj
https://blog.csdn.net/woshimalingyi/article/details/73252013
https://github.com/xuexiangjys/XMark
https://github.com/xuexiangjys/XAOP
http://johnnyshieh.me/posts/aspectj-in-android-usage/
https://github.com/HujiangTechnology/gradle_plugin_android_aspectjx