搞个AspectJ 玩玩

AOP这个东西也是听了由来已久了,是时候去会一会他了,首先我们先抛开那些很牛逼的既可以AOP,又可以HotFix的这些个框架,先来看一看职责专一的AspectJ是怎么玩的。

我们需要注意到如下的问题:

首先安卓的AOP的实现方式大致有如下的三种:

  • APT (annotation processing tool) 我们基本可以看到的大部分的很多插件包括但不仅限于butterKnife, Dagger2,eventBus等都是通过APT的形式进行切面编程的。之前的文章java注解就是通过这种方式去实现的
  • javassist 热修复框架和instant run就是借用的这种方式
  • AspectJ JK大神的Hugo就是使用的这个相比更方便,我们可以实行精确的定位,不需要我们再到项目中去增加标注,直接可以把我们需要变动的方法进行修改

我们就来具体的看一下AspectJ在Android studio中的使用,

  1. 区别于Spring AOP和eclipse的AspectJ插件,在Android studio至今还没有官方的一个AspectJ的规范出来,现行的AS中的AspectJ的使用都是来源于如下的这篇文章
    http://fernandocejas.com/2014/08/03/aspect-oriented-programming-in-android/
  2. 首先我们需要在我们的项目中新建一个module,作为android-library依赖。
    在我们app module的build.gradle文件中,我们需要添加如下一些东西:

    buildscript {
     repositories {
         mavenCentral()
     }
     dependencies {
         //以当前最新的1.8.10为准
         classpath 'org.aspectj:aspectjtools:1.8.10'
     }
    }
    dependencies {
     //依赖新建的aop library
     compile project(':firstaop')
     ...
    }
    //以下整个这一段就是增加的ajc的编译器(专门的aspectJ的编译器)
    final def log = project.logger
    final def variants = project.android.applicationVariants
    variants.all { variant ->
     JavaCompile javaCompile = variant.javaCompile
     javaCompile.doLast {
         String[] args = ["-showWeaveInfo",
                          "-1.8",  //兼容java版本
                          "-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;
             }
         }
     }

    在我们的Android-lib这个module的build.gradle也要做以下大同小异的变动:

    buildscript {
     repositories {
         mavenCentral()
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:2.2.2'
         classpath 'org.aspectj:aspectjtools:1.8.10'
     }
    }
    dependencies {
     compile 'org.aspectj:aspectjrt:1.8.10'
    }
    android.libraryVariants.all { variant ->
     LibraryPlugin plugin = project.plugins.getPlugin(LibraryPlugin)
     JavaCompile javaCompile = variant.javaCompile
     javaCompile.doLast {
         String[] args = ["-showWeaveInfo",
                          "-1.8",
                          "-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;
             }
         }
     }
    }

    基本和app module的一样,就是需要去dependency aspectjrt这个包,以及gradle的task中多了LibraryPlugin这个东西,至此我们的配置基本上已经完结了。

  3. 然后我们就可以在lib的module中新建aspect的相关类了,新建如下一个aspect类
    我们先定义如下的一些静态字符串,用来匹配我们想要切入的方法

    //这一段的意思是匹配所有以Util结尾的类的所有方法,以及所有的ViewGroup的子类的所有方法,这里涉及到的this和target的问题我们之后再讲
    private static final String POINTCUT_METHOD =
             "(execution(* *..*Util.*(..)) || execution(* *..ViewGroup+.*(..))) && target(Object) && this(Object)";
    //匹配所有的以Activity结尾的类的所有方法
    private static final String TEST_EXECUTION = "execution(* *..*Activity.*(..))";
    //匹配调用MainActivity中以on开头的方法所在的方法,注意此处是调用(匹配指定类的时候一定要指明完整的路径)
    private static final String TEST_CALL = "call(* org.ding.multithingsdebugdemo.MainActivity.on*(..))";
    //除开在Util结尾的类的show方法中调用了Util结尾的类的方法之外的方法
    private static final String TEST_WITHIN = "call(* *..*Util.*(..)) && !withincode(* *..*Util.show(..))";

    其中最最麻烦的就是adpectJ的语法,比较复杂,且经过实际验证有如下的一些语法的坑:

    1. 要么就只写方法名,如果需要拦截指定类的方法名,或者是指定部分类的方法名,那么一定要把包名写全。你可以选择直接写包名的形式(org.ding.Util.show(..)),也可以选择选择部分包名的形式(..Util.show(..))
    2. +紧跟在类名后面,代表所有的这个类的子类
    3. target和this,后面都跟着具体的数据class类型,可以是Object,也可以是具体的类名,且不支持通配符。
      同时,在execution时,target和this是一样;在call时,target表示这个方法的调用类,this表示这个调用这个方法所在的类。
      target可以拦截所有对象的子类,(举个例子,这两个我们一般都是与前面的匹配条件&&来使用,target(A)表示在满足前面的条件情况下,方法的调用类是A或者是A的子类。shis(A)表示在A类中又满足前面的条件。
    4. execution是方法的内部,call是调用这个方法的地方
    5. 一段匹配语段不能同时用在around,和before或者after,就是说用了around,不能用在before或者after,before和after可以连用
    6. withincode后面跟方法,within后面跟类,同样的这两个东西也是紧跟着前面的方法 && 来使用,表示在满足前面的匹配条件的同时包含后面的方法/包含后面这个类以及其子类
    7. 到目前为止,withincode和within貌似只能和call一起连用,看到eclipse官方上的asepctj的官方例子中有和execution的连用,暂时无法实现。
    8. within或者是withincode后面跟的方法名或者是类名一定要指明类,意思不是要指定类,而是要给出类的匹配,可以指定可以通配
  4. 然后我们可以去创建一些方法,来进行方法的截取了,就拿上面的一种匹配段来作为例子:

    //我们先要把这个匹配静态字符串用pointcut标注起来给这个空方法
    @Pointcut(TEST_WITHIN)
     public void testExecution() {
    
     }
    //然后我们可以把这个空方法直接放在after或者before或者around中,我们也可以直接在这些关键字后面直接写上匹配段代码
    @After("testExecution()")
     public void getActivityMethod1(JoinPoint point) throws Throwable {
         //获取截取的方法名
         Log.e("xxxxx", "MethodSignature) joinPoint.getSignature()    :    " + point.getSignature().getName());
         Log.e("xxxxxx", "taeget   :   " + point.getTarget());
         Log.e("xxxxxx", "this   :   " + point.getThis());
         Log.e("xxxxxx", "11111");
         Log.e("xxxxxx", "22222");
     }
    /**
      * 跟before和after不同的是,around方法是发生在方法的内部的,而before和after是发生在方法的外部的,所以around标注的传参可以是ProceedingJoinPoint类型,
      */
     @Around("methodAnnotated()")
     public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
         if (currentObject == null) {
             currentObject = joinPoint.getTarget();
         }
         //调用原方法的执行。
         Object result = joinPoint.proceed();
         //获取方法信息对象
         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
         String className;
         //获取当前对象,通过反射获取类别详细信息
         className = joinPoint.getThis().getClass().getName();
         String methodName = methodSignature.getName();
         return result;
     }

我们也可以通过标注的方式去做aspect的aop

  1. 好处是我们不用再去通过复杂的abstractProcessor继承这种apt的方式然后去截取来做处理,这种标注的方式比apt的方式略微的简单一点。
  2. 首先我们依然创建一个标注类,这个是和apt的步骤一样的:
    /**
    * 表明被注释的方法将被跟踪并且将会与Aspect程序中截获该注释的Advise关联
    */
    @Retention(RetentionPolicy.CLASS)
    @Target({ ElementType.CONSTRUCTOR, ElementType.METHOD })
    public @interface DebugTrace {}
  3. 然后需要创建一个aspect类,跟上面的基本相同,就是静态字符串不同,语法如下:
    //org.ding.DebugTrace标注的所有方法
    private static final String POINTCUT_METHOD =
             "execution(@org.ding.DebugTrace * *(..))";
    //org.ding.DebugTrace标注的所有的new方法
     private static final String POINTCUT_CONSTRUCTOR =
             "execution(@org.ding.DebugTrace * *.new(..))";

注:

  1. 不同于eclipse有专门的aspectJ插件,Android studio由于没有aspect插件,没有直接的aspect的关键字,直接导致了我们的@aspect标注的类没有检错功能,所以一旦有aspect语法问题直接会导致无法编译出该aspect相关类,所以你所有YY的好像可以做到的拦截全都会失效,意思就是一旦一个aspect标注类中由aspect文法错误会直接导致整个aspect类无法ajc编译
  2. 这个人的aspectJ系列还是不错的
    http://blog.csdn.net/zl3450341/article/details/7673938
IT文库 » 搞个AspectJ 玩玩
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址