Android AOP面向切面编程详解

GitHub地址（欢迎下载完整Demo）
https://github.com/zhouxu88/AOPDemo

项目需求描述

我想类似于这样的个人中心的界面，大家都不会陌生吧。那几个有箭头的地方都是可以点击进行页面跳转的，但是需要先判断用户是否登录，如果已经登录，则正常跳转，如果没有登录，则跳转到登录页面先登录，但凡是有注册，登录的APP，这样的操作，大家应该都很熟悉吧。一般情况下，我们的逻辑是这样的…

/**
     * 跳转到我的关注页面
     */
    public void toMyAttention() {
        // 判断当前用户是否登录
        if(LoginHelper.isLogin(this)) {
            // 如果登录才跳转，进入我的关注页面
            Intent intent = new Intent(this, WaitReceivingActivity.class);
            startActivity(intent);
        }else{
          //跳转到登录页面，先登录
            Intent intent = new Intent(this, LoginActivity.class);
            startActivity(intent);
        }
    }

这段代码确实没有任何问题，也完全符合我们的需求，也就是在所有需要判断登录的地方去if else做重复的逻辑操作，但是如果这样的判断有10多处，甚至几十处，我们就得重复很多次这样的体力劳动，或者有一天需求变动，我们估计要改动多处，想想都可怕。而且类似的还有网络判断，权限管理，Log日志的统一管理这样的问题。那么，我们也没有更优雅的方式来解决这一类的问题呢，答案是有的，烦请各位接着往下看。

先给出我解决了上述问题之后的代码

/**
    *  跳转到我的关注页面
    */
    @CheckLogin
    public void toMyAttention() {
         Intent intent = new Intent(this, WaitReceivingActivity.class);
         startActivity(intent);
    }

大家也看到了，代码变得简洁了，而且重复的操作越多，优势越明显，更重要的是，方便需求改变时候的修改，便于维护。在这里，我通过一个@CheckLogin注解的方式就去除了判断登录这样的操作，这是什么个情况？这就是今天为大家带来的Android AOP（面向切面编程）详解。接下来，我先为大家带来AOP的一些基础概念，再来讲解具体的实现方式。

什么是AOP

AOP是Aspect Oriented Programming的缩写，即『面向切面编程』。它和我们平时接触到的OOP都是编程的不同思想，OOP，即『面向对象编程』，它提倡的是将功能模块化，对象化，而AOP的思想，则不太一样，它提倡的是针对同一类问题的统一处理，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AspectJ

AspectJ实际上是对AOP编程思想的一个实践，AOP虽然是一种思想，但就好像OOP中的Java一样，一些先行者也开发了一套语言来支持AOP。目前用得比较火的就是AspectJ了，它是一种几乎和Java完全一样的语言，而且完全兼容Java（AspectJ应该就是一种扩展Java，但它不是像Groovy那样的拓展。）。当然，除了使用AspectJ特殊的语言外，AspectJ还支持原生的Java，只要加上对应的AspectJ注解就好。所以，使用AspectJ有两种方法：
- 完全使用AspectJ的语言。这语言一点也不难，和Java几乎一样，也能在AspectJ中调用Java的任何类库。AspectJ只是多了一些关键词罢了。
- 或者使用纯Java语言开发，然后使用AspectJ注解，简称@AspectJ。

基础概念
- Aspect 切面：切面是切入点和通知的集合。

• PointCut 切入点：切入点是指那些通过使用一些特定的表达式过滤出来的想要切入Advice的连接点。

• Advice 通知：通知是向切点中注入的代码实现方法。

• Joint Point 连接点：所有的目标方法都是连接点.

• Weaving 编织：主要是在编译期使用AJC将切面的代码注入到目标中, 并生成出代码混合过的.class的过程.

实践步骤

1、在android studio中直接配置AspectJ,这个配置很重要，如果失败，后面就无法成功，先贴出我的配置,在app的build.gradle中做如下配置

apply plugin: 'com.android.application'
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
    }
}
repositories {
    mavenCentral()
}
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;
            }
        }
    }
}

android {
    compileSdkVersion 25
    buildToolsVersion "25.0.2"
    defaultConfig {
        applicationId "com.zx.aopdemo"
        minSdkVersion 17
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.3.1'
    compile 'com.android.support.constraint:constraint-layout:1.0.2'
    compile 'org.aspectj:aspectjrt:1.8.9'
    testCompile 'junit:junit:4.12'
}

为什么这么配置?因为AspectJ是对java的扩展，而且是完全兼容java的。但是编译时得用Aspect专门的编译器，这里的配置就是使用Aspect的编译器，单独加入aspectj依赖是不行的。到这里准备工作已完成，可以开始看看具体实现了。

2、创建切面AspectJ
用来处理触发切面的回调

@Aspect
public class CheckLoginAspectJ {
    private static final String TAG = "CheckLogin";

    /**
     * 找到处理的切点
     * * *(..)  可以处理CheckLogin这个类所有的方法
     */
    @Pointcut("execution(@com.zx.aopdemo.login.CheckLogin  * *(..))")
    public void executionCheckLogin() {
    }

    /**
     * 处理切面
     *
     * @param joinPoint
     * @return
     */
    @Around("executionCheckLogin()")
    public Object checkLogin(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.i(TAG, "checkLogin: ");
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        CheckLogin checkLogin = signature.getMethod().getAnnotation(CheckLogin.class);
        if (checkLogin != null) {
            Context context = (Context) joinPoint.getThis();
            if (MyApplication.isLogin) {
                Log.i(TAG, "checkLogin: 登录成功 ");
                return joinPoint.proceed();
            } else {
                Log.i(TAG, "checkLogin: 请登录");
                Toast.makeText(context, "请登录", Toast.LENGTH_SHORT).show();
                return null;
            }
        }
        return joinPoint.proceed();
    }
}

这里要使用Aspect的编译器编译必须给类打上标注，@Aspect。
还有这里的Pointcut注解，就是切点，即触发该类的条件。里面的字符串如下

在Pointcut这里，我使用了execution，也就是以方法执行时为切点，触发Aspect类。而execution里面的字符串是触发条件，也是具体的切点。我来解释一下参数的构成。“execution(@com.zx.aopdemo.login.CheckLogin * *(..))”这个条件是所有加了CheckLogin注解的方法或属性都会是切点，范围比较广。

• **：表示是任意包名
• ..：表示任意类型任意多个参数

“com.zx.aopdemo.login.CheckLogin”这是我的项目包名下需要指定类的绝对路径。再来看看@Around,Around是指JPoint执行前或执行后被触发，除了Around还有其他几种方式。

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

创建完Aspect类之后，还需要一个注解类，它的作用是：哪里需要做切点，那么哪里就用注解标注一下，这样方便快捷。

3、创建注解类

package com.zx.aopdemo.login;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD) //可以注解在方法 上
@Retention(RetentionPolicy.RUNTIME) //运行时（执行时）存在
public @interface CheckLogin {
}

4、Activity使用登录的注解

public class LoginActivity extends AppCompatActivity implements View.OnClickListener, RadioGroup.OnCheckedChangeListener {

    private RadioGroup radioGroup;

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

       test();
    }

    @CheckLogin
   public void test(){  
        Log.i("tag","判断是否登录");  
    }  

test()方法执行时就是一个切点。在执行test()时，会回调上面的CheckLoginAspectJ类的executionCheckLogin()方法。然后会执行
如下方法

 /**
     * 处理切面
     *
     * @param joinPoint
     * @return
     */
    @Around("executionCheckLogin()")
    public Object checkLogin(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.i(TAG, "checkLogin: ");
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        CheckLogin checkLogin = signature.getMethod().getAnnotation(CheckLogin.class);
        if (checkLogin != null) {
            Context context = (Context) joinPoint.getThis();
            if (MyApplication.isLogin) {
                Log.i(TAG, "checkLogin: 登录成功 ");
                return joinPoint.proceed();
            } else {
                Log.i(TAG, "checkLogin: 请登录");
                Toast.makeText(context, "请登录", Toast.LENGTH_SHORT).show();
                return null;
            }
        }
        return joinPoint.proceed();
    }

如果使用的是以方法相关为切点，那么使用MethodSignature来接收joinPoint的Signature。如果是属性或其他的，那么可以使用Signature类来接收。之后可以使用Signature来获取注解类。，那么通过jointPoint.getThis()获取使用该注解的的上下文对象

参考如下文章，感谢作者：
aspect-oriented-programming-in-android

翻译 Android中的AOP编程

Android 开发中使用 AOP

深入理解Android之AOP

Android基于AOP的非侵入式监控之——AspectJ实战

扫描下面二维码或者公众号搜索Android老鸟开发经验谈，即可关注【公众号】，持续推出优秀文章