Android 面向切面编程（AOP）之 AspectJ

概念：

AOP： Aspect Oriented Programming 面向切面编程。

AOP是个概念，AspectJ 是它的一个具体实现。和Java配合使用。

AspectJ：核心是他的编译器（ajc），就做了一件事，讲 AspectJ 的代码在编译期插入到目标程序中。运行时没啥区别。ajc 会构建目标程序和AspectJ 代码的联系，在编译期将 AspectJ 代码插入被切出的 PointCut中。达到AOP的目的。

我们采用 AspectJ 的方式来实现 AOP。

术语：

1、Advice：增强
也叫 通知。增强是织入目标类连接点的一段程序代码

2、JoinPoint：连接点
程序执行的某个特点的位置，比如 类的初始化前后，方法的调用前后等等。具有边界性质的点成为连接点。

3、PointCut：切入点
连接点 相当于 数据库的记录。 切入点 相当于 查询条件。
切入点和连接点不是一一对应的，一个切入点可以匹配多个连接点

4、Aspect：切面
切面有切点和连接点组成

5、Weaving：织入
将增强添加到目标类的具体连接点的过程。AOP 像一个织布机把目标类和增强缝在了一起
根据不同实现技术，三种织入的方式

• 编译器织入，需要特殊的Java编译器
• 类装载期织入，需要特殊的类加载器
• 动态代理织入，在运行期为目标类添加增强生成子类的方式

5、Target：目标对象
增强逻辑的目标对象。

步骤：

1、首先定义一个表达式（PointCut）告诉程序我们要在哪里增加额外的操作。
通过这个表达式（PointCut），获得那些需要通知的方法（JoinPoint）。

2、我们要告诉程序这些方法（JointPoint）如何增强（Advice）

• 什么时候？执行前？执行后？返回前？
• 额外具体操作是干甚么？
  我们把这个两个步骤定义到一个地方（Aspect）。
  涉及到的被修改的对象就是目标对象（Tatget）。
  完成了上面的所有动作，总成织入（Weaving）。

代码敲起来

配置
1、在应用build.gradle中

 dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.10'
        classpath 'org.aspectj:aspectjweaver:1.8.10'
    }

2、在app build.gradle中

dependencies {
  implementation 'org.aspectj:aspectjrt:1.8.10'
}
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

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.8",
                         "-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
            }
        }
    }

配置完毕。

新建一个类，添加注解@Aspect 说明这是一个切面。
然后创建我们的切点方法。注解@PointCut

注意里面execution表达式,
.. 任意类型任意多个参数

• 包名通配符

execution(<修饰符模式>? <返回类型模式> <方法名模式>(<参数模式>) <异常模式>?)

根据需要创建以下注解方法

类型	描述
Before	前置通知, 在目标执行之前执行通知
After	后置通知, 目标执行后执行通知
Around	环绕通知, 在目标执行中执行通知, 控制目标执行时机
AfterReturning	后置返回通知, 目标返回时执行通知
AfterThrowing	异常通知, 目标抛出异常时执行通知

@Aspect
public class TestAspect {
    @Pointcut("execution(* com.ssy.qbd.MenuActivity.doSomeThing(..))")
    public void pointcut() {

    }

    @Before("pointcut()")
    public void before(JoinPoint point) {
        Log.e("Mr.S", "@Before");
    }
//注意 如果不调用joinPoint.proceed() 此方法不调用
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        return joinPoint.proceed();
    }

    @After("pointcut()")
    public void after(JoinPoint joinPoint) {
        Log.e("Mr.S", "@After");
    }

    @AfterReturning(value = "pointcut()", returning = "returnValue")
    public void afterReeturning(JoinPoint joinPoint, Object returnValue) {
        Log.e("Mr.S", "@AfterReturning" + "--" + returnValue);
    }

    @AfterThrowing(value = "pointcut()", throwing = "throwable")
    public void afterThrowing(Throwable throwable) {
        Log.e("Mr.S", "@AfterThrowing" + "--" + throwable.getMessage());
    }

我们的目标对象

 public String doSomeThing() {
        Intent intent = new Intent(MenuActivity.this, HellowActivity.class);
        startActivity(intent);
        return  "doSomeThing 执行完毕";
    }

执行结果

2018-12-21 11:08:43.898 24567-24567/com.ssy.qbd E/Mr.S: @Before
2018-12-21 11:08:43.908 24567-24567/com.ssy.qbd E/Mr.S: @Around
2018-12-21 11:08:43.908 24567-24567/com.ssy.qbd E/Mr.S: @After
2018-12-21 11:08:43.908 24567-24567/com.ssy.qbd E/Mr.S: @AfterReturning--doSomeThing 执行完毕

实践完毕，那么这个面向切面编程，到底是用在什么情况呢？这几个方法的实际运用又是如何呢？我如何控制多个方法呢？不能一个方法一个切面吧？

相信大家会有很多疑问。

那我们就根据实际情况来，灵活运用我们的 AOP。

举例一：

某日，
老大说：S啊，咱们的产品要升级了，要增加权限控制了，对于没有登录的用户，严格控制，比如评论必须登录，不能匿名了，点赞也要先登录 、看新闻也要先登录 。。。
我：WTF？我挨个给你加吗？

  if (isLogin()) {
            Intent intent = new Intent(MenuActivity.this, HellowActivity.class);
            }

哇 好烦啊~~有没有简单的，优美的，偷懒的做法呢？

老大说：你试试 AOP。用过你就知道什么是偷懒，什么优美了。
我：好 我试试。

先写个注解,标注一下

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckLogin {
}

然后就是在我们的方法上添加注解

    @CheckLogin
    public String doSomeThing() {

        Intent intent = new Intent(MenuActivity.this, HellowActivity.class);
        startActivity(intent);


        return "doSomeThing 执行完毕";
    }

最后在around 方法里进行我们的操作

  @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        CheckLogin checkLogin = signature.getMethod().getAnnotation(CheckLogin.class);
        if (checkLogin != null) {
            if (isLogin()) {
                Log.e("Mr.S", "@Around" + "--" + "登录成功");
                return joinPoint.proceed();
            } else {
                Log.e("Mr.S", "@Around" + "--" + "请登录");
                Login((Context) joinPoint.getThis());
                return null;
            }


        }
        return joinPoint.proceed();
    }

执行结果：

• 未登录

2018-12-21 15:20:30.199 29343-29343/com.ssy.qbd E/Mr.S: @Before
2018-12-21 15:20:30.200 29343-29343/com.ssy.qbd E/Mr.S: @Around--请登录
2018-12-21 15:20:30.200 29343-29343/com.ssy.qbd E/Mr.S: Login--登录页面
2018-12-21 15:20:30.200 29343-29343/com.ssy.qbd E/Mr.S: @After
2018-12-21 15:20:30.200 29343-29343/com.ssy.qbd E/Mr.S: @AfterReturning--null

• 已登录

2018-12-21 15:21:55.669 29463-29463/com.ssy.qbd E/Mr.S: @Before
2018-12-21 15:21:55.671 29463-29463/com.ssy.qbd E/Mr.S: @Around--登录成功
2018-12-21 15:21:55.691 29463-29463/com.ssy.qbd E/Mr.S: @After
2018-12-21 15:21:55.691 29463-29463/com.ssy.qbd E/Mr.S: @AfterReturning--doSomeThing 执行完毕

我们会发现，我们可以对这个方法进行任意的操作，执行前后加逻辑，也可以屏蔽这个方法，换成咱们的新方法。但是在我们的原方法那里是不用改变的，我们可以更改逻辑，增加或者减少我们的功能。只要一个注解@CheckLogin，真实太方便了。

这个例子其实还不算太变态，如果是让我们把所有的操作都加上日志怎么办？我们是不是要在自己的代码里，各种更改，这个侵入性太强了，稍有不注意 bug 就铺天盖地。所以面向切面编程的方式。我们会更加轻松的。

只要是涉及统一处理的地方，AOP基本都是一个利器。程序员追求的就是一个懒。能省事当然要省事了。

当然 AspectJ 的真正实力远比我们展现的要强大得多，认识他，运用它，你就会喜欢上它。

参考：
https://www.jianshu.com/p/aa1112dbebc7
https://www.cnblogs.com/weizhxa/p/8567942.html