在Android中使用AspectJ进行AOP切面编程

最近有做用户行为统计的需求，为了尽可能使统计代码不侵入业务代码，就研究了下hook和Aop。研究了下AspectJ，虽然还是不能完美解决项目中的问题，不过确实是个好东西。

编译插桩是什么

顾名思义，所谓编译插桩就是在代码编译期间修改已有的代码或者生成新代码。实际上，我们项目中经常用到的 Dagger、ButterKnife 甚至是 Kotlin 语言，它们都用到了编译插桩的技术。

理解编译插桩之前，需要先回顾一下 Android 项目中 .java 文件的编译过程



从上图可以看出，我们可以在 1、2 两处对代码进行改造。
在 .java 文件编译成 .class 文件时，APT、AndroidAnnotation 等就是在此处触发代码生成。

在 .class 文件进一步优化成 .dex 文件时，也就是直接操作字节码文件，也是本课时主要介绍的内容。这种方式功能更加强大，应用场景也更多。但是门槛比较高，需要对字节码有一定的理解。
本课时主要介绍第 1种实现方式

一般情况下，我们经常会使用编译插桩实现如下几种功能：
  • 日志埋点；
  • 性能监控；
  • 动态权限控制；
  • 业务逻辑跳转时，校验是否已经登录；
  • 甚至是代码调试等。
常见AOP编程库

在Java中，常见的面向切面编程的开源库有：
AspectJ：和Java语言无缝衔接的面向切面的编程的扩展工具（可用于Android）。
Javassist for Android：一个移植到Android平台的非常知名的操纵字节码的java库。
DexMaker：用于在Dalvik VM编译时或运行时生成代码的基于java语言的一套API。
ASMDEX：一个字节码操作库（ASM），但它处理Android可执行文件（DEX字节码）。

Android集成AspectJ ，主要有两种方式：

1，插件的方式：网上有人在github上提供了集成的插件gradle-android-aspectj-plugin。这种方式配置简单方便，但经测试无法兼容databinding框架。

2，Gradle配置的方式：配置有点麻烦，不过国外一个大牛在build文件中添加了一些脚本，虽然有点难懂，但可以在AS中使用文章出处

方式一集成

首先，新建一个AS原工程，然后再创建一个aspectJLib module(Android Library) 。
项目根目录build文件添加
classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.0'

项目 aspectJLib module里面 的build文件里面添加

apply plugin: 'com.android.library'
apply plugin: 'android-aspectjx'  //添加代码
android {
  def version = rootProject.ext
  compileSdkVersion version.compileSdkVersion
  defaultConfig {
    minSdkVersion version.minSdkVersion
    targetSdkVersion version.targetSdkVersion
    versionCode version.versionCode
    versionName version.versionName
  }
}

dependencies {
  compile 'org.aspectj:aspectjrt:1.8.7'//添加代码
}

然后在使用的app module 里面的build 文件添加插件
apply plugin: 'android-aspectjx'

方式二集成

参考文章
主要是编写build脚本，添加任务，使得IDE使用ajc作为编译器编译代码，然后把该Module添加至主工程Module中。

项目根build目录添加
classpath 'org.aspectj:aspectjtools:1.8.1'
项目 aspectJLib module里面 的build文件里面添加

import com.android.build.gradle.LibraryPlugin
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main


apply plugin: 'android-library'




android {
  compileSdkVersion 19
  buildToolsVersion '19.1.0'

  lintOptions {
    abortOnError false
  }
}
dependencies {
  compile 'org.aspectj:aspectjrt:1.8.1'
}

//编写build脚本，添加任务
android.libraryVariants.all { variant ->
  LibraryPlugin plugin = project.plugins.getPlugin(LibraryPlugin)
  JavaCompile javaCompile = variant.javaCompile
  javaCompile.doLast {
    String[] args = ["-showWeaveInfo",
                     "-1.5",
                     "-inpath", javaCompile.destinationDir.toString(),
                     "-aspectpath", javaCompile.classpath.asPath,
                     "-d", javaCompile.destinationDir.toString(),
                     "-classpath", javaCompile.classpath.asPath,
                     "-bootclasspath", plugin.project.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;
      }
    }
  }
}

然后在主build.gradle(Module:app)中添加也要添加AspectJ依赖，同时编写build脚本，添加任务，目的就是为了建立两者的通信，使得IDE使用ajc编译代码。

apply plugin: 'com.android.application'import org.aspectj.bridge.IMessageimport org.aspectj.bridge.MessageHandlerimport org.aspectj.tools.ajc.Main

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.1'    }
}
repositories {
    mavenCentral()
}

android {


    compileSdkVersion 21    buildToolsVersion '21.1.2'
    defaultConfig {
        applicationId 'com.example.myaspectjapplication'        minSdkVersion 15        targetSdkVersion 21    }

    lintOptions {
        abortOnError true    }
}
final def log = project.loggerfinal 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.5",
                         "-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;
            }
        }
    }
}
dependencies {
 compile fileTree(include: ['*.jar'], dir: 'libs')
 compile project(':aspectJLib')
 compile 'org.aspectj:aspectjrt:1.8.1'
}

需要注意的是，由于不同版本的gradle在获取编译时获取类的路径等信息Api不同，所以以上groovy配置语句仅在Gradle Version高于3.3的版本上生效。

开始使用 本例子是按照方式一集成的

AspectJ 的两种用法
（1）用自定义注解修饰切入点，精确控制切入点，属于侵入式；
（2）不需要在切入点代码中做任何修改，属于非侵入式。

  • 侵入式
    侵入式用法，一般会使用自定义注解，以此作为选择切入点的规则。
  • 非侵入式
    非侵入式，就是不需要使用额外的注解来修饰切入点，不用修改切入点的代码。
侵入式

新增注解

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

新建一个Java类Aspect

打上@Aspect注解，则该类可以被ajc编译器识别为一个Asepct，在工程项目编译时便能非常方便地实现代码织入。看到AspectJ的三个要素，Join Point、Advice和Aspect。好像少了Join Point？Join Point早已定义在Pointcut的字符串常量中（即execution），即MainActivity的onCreate方法。Pointcut以注解的形式定义，注解了timeWatch方法，从而timeWatch就是这个Pointcut的名称，注解参数则使用定义好的字符串常量，作为Join Point的过滤规则。同样，Advice也是将类型关键字(此处为Around)注解在特定的方法saveJoinPoint之上，注解的参数为具名的Pointcut，即timeWatch。上文提到Around类型即用该方法替换原Join Point的实现，Object result = joinPoint.proceed()等价于原有的被Hook方法，即MainActivity的onCreate()。在该语句的前后，是性能统计的代码片段。


/**
 * Aspect representing the cross cutting-concern: Method and Constructor Tracing.
 * 侵入式的编译注解
 * 侵入式用法，一般会使用自定义注解，以此作为选择切入点的 Pointcut 规则。
 */


@Aspect
public class TraceAspect {
    /**
     * 针对所有继承 Activity 类的 onCreate 方法
     */
    @Pointcut("execution(* android.app.Activity+.onCreate(..))")
    public void activityOnCreatePointcut() {

    }


    //被"org.android10.gintonic.annotation.DebugTrace"标记的方法。
    //针对带有DebugTrace注解的方法
    @Pointcut("execution(@org.android10.gintonic.annotation.DebugTrace * *(..))")
    public void methodAnnotatedWithDebugTrace() {


    }

    //被"org.android10.gintonic.annotation.DebugTrace"标记的构造器。
    @Pointcut("execution(@org.android10.gintonic.annotation.DebugTrace *.new(..))")
    public void constructorAnnotatedDebugTrace() {

    }

    /**
     * 我们定义的 "weaveJointPoint(ProceedingJoinPoint joinPoint)"
     * 这个方法被添加了"@Around"注解，这意味着我们的代码注入将发生在被
     * "@DebugTrace"注解标记的方法前后。
     * 在用DebugTrace注解修饰的方法或者构造函数里面注入如下代码。
     */
    @Around("methodAnnotatedWithDebugTrace() || constructorAnnotatedDebugTrace() || activityOnCreatePointcut()")
    public Object saveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String className = methodSignature.getDeclaringType().getSimpleName();
        String methodName = methodSignature.getName();
        final StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Object result = joinPoint.proceed();
        stopWatch.stop();
        Log.d("TAG", className + "--" + buildLogMessage(methodName, stopWatch.getTotalTimeMillis()));
        return result;
    }

    /**
     * Create a log message.
     *
     * @param methodName     A string with the method name.
     * @param methodDuration Duration of the method in milliseconds.
     * @return A string representing message.
     */
    private static String buildLogMessage(String methodName, long methodDuration) {
        StringBuilder message = new StringBuilder();
        message.append("Gintonic --> ");
        message.append(methodName);
        message.append(" --> ");
        message.append("[");
        message.append(methodDuration);
        message.append("ms");
        message.append("]");

        return message.toString();
    }
}

添加注解检测运行时间

   @DebugTrace
    private void testAnnotatedMethod() {
        SystemClock.sleep(100);
    }

  @DebugTrace
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_relative_layout_test);
  }

此时运行代码 便可以看到已经打印了时间

D/TAG: MainActivity--Gintonic --> testAnnotatedMethod --> [100ms]
D/TAG: MainActivity--Gintonic --> onCreate --> [187ms]

源代码与反编译后的代码
反编译项目生成的apk后可以看到，ajc在Join Point处织入了代码，用TimeWatchAspect.aspectOf().saveJoinPoint()实现了替换。

//源代码
  @DebugTrace
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_relative_layout_test);
  }
//反编译后的代码

  protected void onCreate(Bundle paramBundle)
  {
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_0, this, this, paramBundle);
    TimeWatchAspect.aspectOf().saveJoinPoint(new MainActivity.AjcClosure1(new Object[] { this, paramBundle, localJoinPoint }).linkClosureAndJoinPoint(69648));
  }


  public class MainActivity$AjcClosure1 extends AroundClosure
{
  public MainActivity$AjcClosure1(Object[] paramArrayOfObject)
  {
    super(paramArrayOfObject);
  }

  public Object run(Object[] paramArrayOfObject)
  {
    Object[] arrayOfObject = this.state;
    MainActivity.onCreate_aroundBody0((MainActivity)arrayOfObject[0], (Bundle)arrayOfObject[1], (JoinPoint)arrayOfObject[2]);
    return null;
  }
}
非侵入式

检测View 的点击花事件


import android.util.Log;
import android.view.View;

import org.android10.gintonic.TrackPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

/**
 * @author wangwei
 * @date 2021/4/12.
 * 非侵入式  检测onClick
 * 非侵入式，就是不需要使用额外的注解来修饰切入点，不用修改切入点的代码。
 */

@Aspect
public class ViewAspect {

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


    @Around("onClickPointcut()")
    public void aroundJoinClickPoint(final ProceedingJoinPoint joinPoint) throws Throwable {
        Object target = joinPoint.getTarget();
        String className = "";
        if (target != null) {
            className = target.getClass().getName();
        }
        //获取点击事件view对象及名称，可以对不同按钮的点击事件进行统计
        Object[] args = joinPoint.getArgs();
        if (args.length >= 1 && args[0] instanceof View) {
            View view = (View) args[0];
            int id = view.getId();
            String entryName = view.getResources().getResourceEntryName(id);

          //获取点击事件对不同按钮的点击事件进行统计
            TrackPoint.onClick(className, entryName);
        }
        joinPoint.proceed();//执行原来的代码
    }


}

在Activity的所有生命周期的方法中打印log

    /**
     *
     * @param joinPoint
     * @throws Throwable
     */
    @Before("execution(* android.app.Activity.**(..))")
    public void method(JoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String className = joinPoint.getThis().getClass().getSimpleName();
        Log.e("TAG", "class:" + className + " method:" + methodSignature.getName());
    }

点击一个按钮可以看到打印日志
onClick: org.android10.viewgroupperformance.activity.MainActivity$1-btnRelativeLayout

原理及其重点

AOP的目标是把这些功能集中起来，放到一个统一的地方来控制和管理。如果说，OOP如果是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。比如我们可以设计两个Aspects，一个是管理某个软件中所有模块的日志输出的功能，另外一个是管理该软件中一些特殊函数调用的权限检查。

非侵入式监控 可以在不修监控目标的情况下监控其运行截获某类方法甚至可以修改其参数和运行轨迹

基本原理

横向的切割某一类方法和属性，我们不需要显式的修改就可以向代码中添加可执行的代码块
它在编译期将开发者编写的Aspect程序编织到目标程序(PointCut定义的位置)中，对目标程序作了重构，以达到非侵入代码监控的目的

编写Aspect声明Aspect、PointCut和Advise。
ajc编织 AspectJ编译器在编译期间对所切点所在的目标类进行了重构在编译层将AspectJ程序与目标程序进行双向关联生成新的目标字节码即将AspectJ的切点和其余辅助的信息类段插入目标方法和目标类中同时也传回了目标类以及其实例引用。这样便能够在AspectJ程序里对目标程序进行监听甚至操控。

AspectJ概念

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

一些概念详解：

  • Pointcut：告诉代码注入工具，在何处注入一段特定代码的表达式。切点分为execution方式和annotation方式。前者可以用路径表达式指定哪些类织入切面，后者可以指定被哪些注解修饰的代码织入切面。

  • Advice：如何注入到我的class文件中的代码。典型的 Advice 类型有 before、after 和 around，分别表示在目标方法执行之前、执行后和完全替代目标方法执行的代码。

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

  • Join Points，简称JPoints，是AspectJ的核心思想之一，它就像一把刀，把程序的整个执行过程切成了一段段不同的部分。例如，构造方法调用、调用方法、方法执行、异常等等，这些都是Join Points，实际上，也就是你想把新的代码插在程序的哪个地方，是插在构造方法中，还是插在某个方法调用前，或者是插在某个方法中，这个地方就是Join Points，当然，不是所有地方都能给你插的，只有能插的地方，才叫Join Points。
    ————————————————

注意 @Around 环绕通知 里面是ProceedingJoinPoint 可用proceed()调用自身方法

Weaving：织入，就是通过动态代理，在目标对象方法中执行处理内容的过程。
网络上有张图，我觉得非常传神，贴在这里供大家观详：


execution表达式

我们使用最多的就是execution表示了，下面就从execution表达式开始介绍吧。

开发中常用到的pointCut 解释：更多使用方式可參考底部链接 Pointcut语法详解

返回值为void的点击事件  参数为任意类型
@Pointcut("execution(void android.view.View.OnClickListener.onClick(..))")

androidx.appcompat.app.AppCompatActivity包下AppCompatActivity类及子类型的任何方法  参数为任意类型
@Pointcut("execution(* androidx.appcompat.app.AppCompatActivity+.*(..))")

 任何持有com.aspectj.lib.annotation.DebugTrace注解的方法
 @Pointcut("execution(@com.aspectj.lib.annotation.DebugTrace * *(..))")

定义任何一个以"set"开始的方法的执行
@Pointcut(execution(* set*(..)) )

定义AccountService 的任意方法的执行
@Pointcut(execution(* com.xyz.service.AccountService.*(..))) 

定义在service包里的任意类名的任意方法的执行
@Pointcut(execution(* com.xyz.service.*.*(..))) 

定义在service包和所有子包里的任意类的任意方法的执行
@Pointcut(execution(* com.xyz.service ..*.*(..))) 

在MainActivity 且自带有一个String 参数的方法
@Pointcut( "execution(* com.aspectj.example.activity.MainActivity.*(..)) && args(java.lang.String)) ";
   


execution(
   modifier-pattern?  修饰符部分 例如 public private...
   ret-type-pattern  返回值部分 例如 return String;
   declaring-type-pattern?  描述包名 例如 cn.evchar....
   name-pattern(param-pattern)  描述方法名，描述方法参数
   throws-pattern?  匹配抛出的异常
)
修饰符是可以省略的 ，返回值类型就是普通的函数的返回值类型。如果不限定类型的话就用*通配符表示  
说明：最靠近(..)的为方法名,靠近.∗(..))的为类名或者接口名

如：
例如定义切入点表达式 execution(* com.sample.service.impl..*.*(..))
execution()是最常用的切点函数，其语法如下所示：

 整个表达式可以分为五个部分：
 1、execution(): 表达式主体。
 2、第一个*号：表示返回类型，*号表示所有的类型。
 3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。
 4、第二个*号：表示类名，*号表示所有的类。
 5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。


通配符意思：
   ..*  ：表示包、子孙包下的所有类
   .*  ：表示包下的所有类
   *  ：匹配任何数量字符；
   ..  ：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。
   +  ：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。

 比如：
     java.*.Date：可以表示java.sql.Date，也可以表示java.util.Date
     Test*：可以表示TestBase，也可以表示TestDervied
     java..*：表示java任意子类
     java..*Model+：表示Java任意package中名字以Model结尾的子类，比如TabelModel，TreeModel等

函数的参数，参数匹配比较简单，主要是参数类型，比如：
     (int, char)：表示参数只有两个，并且第一个参数类型是int，第二个参数类型是char
     (String, ..)：表示至少有一个参数。并且第一个参数类型是String，后面参数类型不限。在参数匹配中，
     (..) 代表任意参数个数和类型
     (Object ...)：表示不定个数的参数，且类型都是Object，这里的...不是通配符，而是Java中代表不定参数的意思

Spring AOP支持的AspectJ切入点指示符如下：由下列方式来定义或者通过 &&、 ||、 !、 的方式进行组合： 如：@Around(value= "methodPointcut2() && (args(request, ..) || args(.., request))")

  • execution：用于匹配方法执行的连接点；

("execution(* com.zx.aop1.Person.eat())") 精确地匹配到Person类里的eat()方法

  • call是在调用被切入的方法前或者后, execution是在被切入的方法中。
//对于Call来说：
Call（Before）
Pointcut{
    Pointcut Method
}
Call（After）
//对于Execution来说：
Pointcut{
  execution（Before）
    Pointcut Method
  execution（After）
}

  • within：用于匹配指定类型内的方法执行；
    within 是用来指定类型的 within的粒度为类 如：!within(androidx.appcompat.app.AppCompatActivity) AppCompatActivity类里面的所有都会被拦截

  • this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；
    target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；、
    target与this总结：

1、target指代的是切点方法的所有者，而this指代的是被织入代码所属类的实例对象。
2、如果当前要代理的类没有实现某个接口就用 this；如果实现了某个接口，就使用 target
target() 与 this() 很容易混淆，target() 是指 Pointcut 选取的 Join Point 的所有者；this() 是指 Pointcut 选取的 Join Point 的调用的所有者。简单地说就是，PointcutA 选取的是 methodA，那么 target 就是 methodA() 这个方法的对象，而 this 就是 methodA 被调用时所在类的对象

  • args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；
    args(java.lang.String) 有一个参数为String的方法

  • @within：用于匹配所以持有指定注解类型内的方法；
    @within(注解类型) 匹配所有使用了CheckWithin注解的类(只能作用于类，不能是方法，也不能是接口。) @Pointcut("@within(com.zx.aop1.CheckWithin)")

       @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；

  • @args：用于匹配当前执行的方法传入的参数持有指定注解的执行；

  • @annotation：用于匹配当前执行方法持有指定注解的方法；
    匹配使用了CheckAop注解的方法(注意是方法) @Pointcut("@annotation(com.zx.aop1.CheckAop)")

AspectJ切入点支持的切入点指示符还有： call、get、set、preinitialization、staticinitialization、initialization、handler、adviceexecution、withincode、cflow、cflowbelow、if、@this、@withincode；但Spring AOP目前不支持这些指示符，使用这些指示符将抛出IllegalArgumentException异常。这些指示符Spring AOP可能会在以后进行扩展。

踩过的坑

由于AspectJ在字节码层面将功能性代码织入业务代码中，源码层面无法看到变化，且无法在功能性代码中进行断点调试。所以一旦出错，调试成本相对较高。如果项目运行结果与预期不符，首先检查编译问题，能否正常实现代码织入(可以看apk中的class文件树结构)，再检查Join Point、Pointcut和Advice是否符合AspectJ语法，Hook是否正确。

如果Android Studio中的Instant Run开启，则在编译时可能会影响代码的正常织入，所以建议关闭Instant Run。

另外，一般初级阶段会选择日志打印的方式验证AspectJ接入的可行性。如果测试机是魅族系列手机，则注意把项目中Log等级提升到D以上，或者在手机的开发者选项中选择显示所有等级的日志，否则默认情况下你看不到D及D以下等级日志的输出（惨痛的教训，浪费了两天时间排查问题）。
每次改变aspect代码需要clean项目

Execution failed for task ':app:transformClassesWithDexBuilderForDebug'.
> com.android.build.api.transform.TransformException: java.util.zip.ZipException: zip file is empty

对应版本：
aspectjx:2.0.4
androidstudio3.2.1
android tools 3.2.1
gradle4.6
导致原因：
新写的Pointcut有问题
缓存问题

解决方法：
修改用问题的Pointcut
清除app内的build文件
清除C:\Users\用户名.AndroidStudio3.2.1\system\caches中的内容

参考文章
AOP原理1
Pointcut语法详解
Pointcut 切面函数的过滤规则
深入理解Android之AOP

Android Studio 中自定义 Gradle 插件
看AspectJ在Android中的强势插入
Aspect Oriented Programming in Android
AspectJX与第三方库冲突的解决方案

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,839评论 6赞 482
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,543评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 153,116评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,371评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,384评论 5赞 374
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,111评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,416评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,053评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,558评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,007评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,117评论 1赞 334
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,756评论 4赞 324
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,324评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,315评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,539评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,578评论 2赞 355
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,877评论 2赞 345