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

时间 2019-11-30

原文原文链接

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

https://github.com/ganchuanpu/AOPDemoandroid

项目需求描述git

我想相似于这样的我的中心的界面，你们都不会陌生吧。那几个有箭头的地方都是能够点击进行页面跳转的，可是须要先判断用户是否登陆，若是已经登陆，则正常跳转，若是没有登陆，则跳转到登陆页面先登陆，但凡有注册，登陆的APP，这样的操做，你们应该都很熟悉吧。通常状况下，咱们的逻辑是这样的…github

/**
  * 跳转到个人关注页面
*/
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。app

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

PointCut 切入点：切入点是指那些经过使用一些特定的表达式过滤出来的想要切入Advice的链接点。ide
Advice 通知：通知是向切点中注入的代码实现方法。gradle
Joint Point 链接点：全部的目标方法都是链接点.
Weaving 编织：主要是在编译期使用AJC将切面的代码注入到目标中, 并生成出代码混合过的.class的过程.

实践步骤

一、在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依赖是不行的。到这里准备工做已完成，能够开始看看具体实现了。

二、建立切面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类以后，还须要一个注解类，它的做用是：哪里须要作切点，那么哪里就用注解标注一下，这样方便快捷。

三、建立注解类

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 {
}

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

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