搞个AspectJ 玩玩

作者: super_shanks | 来源:发表于2017-02-28 12:02 被阅读135次

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

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

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

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

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

区别于Spring AOP和eclipse的AspectJ插件，在Android studio至今还没有官方的一个AspectJ的规范出来，现行的AS中的AspectJ的使用都是来源于如下的这篇文章
http://fernandocejas.com/2014/08/03/aspect-oriented-programming-in-android/
首先我们需要在我们的项目中新建一个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

搞个AspectJ 玩玩

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

AOP测试

SpringFramework

Java学习笔记

技术干货

程序员