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

AOP面向切面编程在Android中的使用，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中做如下配置

 1 apply plugin: 'com.android.application'
 2 import org.aspectj.bridge.IMessage
 3 import org.aspectj.bridge.MessageHandler
 4 import org.aspectj.tools.ajc.Main
 5 
 6 buildscript {
 7     repositories {
 8         mavenCentral()
 9     }
10     dependencies {
11         classpath 'org.aspectj:aspectjtools:1.8.9'
12         classpath 'org.aspectj:aspectjweaver:1.8.9'
13     }
14 }
15 repositories {
16     mavenCentral()
17 }
18 final def log = project.logger
19 final def variants = project.android.applicationVariants
20 variants.all { variant ->
21     if (!variant.buildType.isDebuggable()) {
22         log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
23         return;
24     }
25 
26     JavaCompile javaCompile = variant.javaCompile
27     javaCompile.doLast {
28         String[] args = ["-showWeaveInfo",
29                          "-1.8",
30                          "-inpath", javaCompile.destinationDir.toString(),
31                          "-aspectpath", javaCompile.classpath.asPath,
32                          "-d", javaCompile.destinationDir.toString(),
33                          "-classpath", javaCompile.classpath.asPath,
34                          "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]
35         log.debug "ajc args: " + Arrays.toString(args)
36 
37         MessageHandler handler = new MessageHandler(true);
38         new Main().run(args, handler);
39         for (IMessage message : handler.getMessages(null, true)) {
40             switch (message.getKind()) {
41                 case IMessage.ABORT:
42                 case IMessage.ERROR:
43                 case IMessage.FAIL:
44                     log.error message.message, message.thrown
45                     break;
46                 case IMessage.WARNING:
47                     log.warn message.message, message.thrown
48                     break;
49                 case IMessage.INFO:
50                     log.info message.message, message.thrown
51                     break;
52                 case IMessage.DEBUG:
53                     log.debug message.message, message.thrown
54                     break;
55             }
56         }
57     }
58 }
59 
60 android {
61     compileSdkVersion 25
62     buildToolsVersion "25.0.2"
63     defaultConfig {
64         applicationId "com.zx.aopdemo"
65         minSdkVersion 17
66         targetSdkVersion 25
67         versionCode 1
68         versionName "1.0"
69         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
70     }
71     buildTypes {
72         release {
73             minifyEnabled false
74             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
75         }
76     }
77 }
78 
79 dependencies {
80     compile fileTree(dir: 'libs', include: ['*.jar'])
81     androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
82         exclude group: 'com.android.support', module: 'support-annotations'
83     })
84     compile 'com.android.support:appcompat-v7:25.3.1'
85     compile 'com.android.support.constraint:constraint-layout:1.0.2'
86     compile 'org.aspectj:aspectjrt:1.8.9'
87     testCompile 'junit:junit:4.12'
88 }

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

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

 1 @Aspect
 2 public class CheckLoginAspectJ {
 3     private static final String TAG = "CheckLogin";
 4 
 5     /**
 6      * 找到处理的切点
 7      * * *(..)  可以处理CheckLogin这个类所有的方法
 8      */
 9     @Pointcut("execution(@com.zx.aopdemo.login.CheckLogin  * *(..))")
10     public void executionCheckLogin() {
11     }
12 
13     /**
14      * 处理切面
15      *
16      * @param joinPoint
17      * @return
18      */
19     @Around("executionCheckLogin()")
20     public Object checkLogin(ProceedingJoinPoint joinPoint) throws Throwable {
21         Log.i(TAG, "checkLogin: ");
22         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
23         CheckLogin checkLogin = signature.getMethod().getAnnotation(CheckLogin.class);
24         if (checkLogin != null) {
25             Context context = (Context) joinPoint.getThis();
26             if (MyApplication.isLogin) {
27                 Log.i(TAG, "checkLogin: 登录成功 ");
28                 return joinPoint.proceed();
29             } else {
30                 Log.i(TAG, "checkLogin: 请登录");
31                 Toast.makeText(context, "请登录", Toast.LENGTH_SHORT).show();
32                 return null;
33             }
34         }
35         return joinPoint.proceed();
36     }
37 }

这里要使用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()方法。然后会执行
如下方法

 1 /**
 2      * 处理切面
 3      *
 4      * @param joinPoint
 5      * @return
 6      */
 7     @Around("executionCheckLogin()")
 8     public Object checkLogin(ProceedingJoinPoint joinPoint) throws Throwable {
 9         Log.i(TAG, "checkLogin: ");
10         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
11         CheckLogin checkLogin = signature.getMethod().getAnnotation(CheckLogin.class);
12         if (checkLogin != null) {
13             Context context = (Context) joinPoint.getThis();
14             if (MyApplication.isLogin) {
15                 Log.i(TAG, "checkLogin: 登录成功 ");
16                 return joinPoint.proceed();
17             } else {
18                 Log.i(TAG, "checkLogin: 请登录");
19                 Toast.makeText(context, "请登录", Toast.LENGTH_SHORT).show();
20                 return null;
21             }
22         }
23         return joinPoint.proceed();
24     }

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