AOP面向切面编程在Android中的使用

GitHub地址（欢迎下载完整Demo）

https://github.com/ganchuanpu/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);
     }
}

重复的体力劳动，想想都可怕。而且类似的还有网络判断，权限管理，Log日志的统一管理这样的问题。那么，我们也没有更优雅的方式来解决这一类的问题呢，答案是有的。

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

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

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
     buildToolsVersion "25.0.2"
     defaultConfig {
         applicationId "com.zx.aopdemo"
         minSdkVersion
         targetSdkVersion
         versionCode
         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还有其他几种方式。

创建完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()获取使用该注解的的上下文对象

https://www.jianshu.com/p/f4e8760e6984