Android使用AOP

這里不講aop的概念，網上資料很多，這里只講如何配置aop和自定義plugin。
1、使用場景
在android中，有些業務是公共的，例如：登錄判斷、獲取權限、網絡判斷等一些公用的業務邏輯，這些都可以使用aop編程。在未使用aop的時候，登錄可能會像下面那樣寫：

工具類：ASUtils
/**
 * 如果未登錄，返回true，並且跳轉到登錄頁
 *
 * @return boolean
 */
public static boolean isUnLogined() {
    if (AppContext.component().userManager().hasUser()) { // 是否已登錄
        return false;
    }
    ToastHelper.showMessage(R.string.login_required);
    IntentUtils.actionWeChatLogin(AppManager.currentActivity(), IReturnType.Mine);
    return true;
}

Activity或者Fragment調用：
private void toUserPage() {
    if (ASUtils.isUnLogined()) return;
    IntentUtils.startActivity(getActivity(), UserActivity.class);
}

而使用Aop后，編碼會變得簡潔很多，只需要在方法上添加@LoginFilter即可：

@LoginIntercept
private void toUserPage() {
    IntentUtils.startActivity(getActivity(), UserActivity.class);
}

2、配置Aspectj
在module或者app中配置Aspectj會比較麻煩，目前有人已經在github開源了支持Android的Aspectj庫(Hugo)，這里不講它的使用，具體可以去github查看使用方法。
首先，在根目錄build.gradle添加aspectj的支持：

buildscript {
    
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.0'
        classpath 'org.aspectj:aspectjtools:1.8.13'    // add
        classpath 'org.aspectj:aspectjrt:1.8.13'       // add
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

其次，在app目錄下的build.gradle添加支持

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;
            }
        }
    }
}
dependencies {
    implementation 'org.aspectj:aspectjrt:1.8.13'
}

上面log是為了方便在build project的時候查看相關日志，定位是否build failed的信息。如果需要單獨一個module來做aop的lib話，在module下build.gradle添加

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
project.android.libraryVariants.all { variant ->
    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)]

        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler)

        def log = project.logger
        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:
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}
dependencies {
    implementation 'org.aspectj:aspectjrt:1.8.13'
}

你會發現，app和module的配置都差不多，唯一的區別在於一個是applicationVariants
，一個是libraryVariants，其它都是一樣。Aspectj配置已經完成，可以Sync Now是否Success。
參數說明

參數	說明
-showWeaveInfo	輸入AJC 編譯信息
-1.8	聲明AJC 支持AspectJ 1.5 版本
-inpath	需要編譯的.class 文件目錄(包含Jar文件)
-classpath	指定哪里可以找到用戶的class 文件
-aspectpath	aspect 編譯的Jar文件或者目錄路徑
-d	編譯后輸出的目錄
-bootclasspath	編譯時修改本地的bootcloasspath

3、定義登錄aop
添加LoginFilter的注解類

package com.fomin.aop.login.aspect;

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

/**
 * Created by Fomin on 2018/8/30.
 */
@SuppressWarnings("CheckStyle")
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LoginIntercept {
    int actionDefine() default 0;
}

注解相關的AspectJ的實現類

package com.fomin.aop.login.aspect;

import android.content.Context;
import android.util.Log;

import com.fomin.aop.execption.AnnotationException;
import com.fomin.aop.execption.NoInitException;
import com.fomin.aop.login.core.ILogin;
import com.fomin.aop.login.core.LoginAssistant;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;

/**
 * Created by Fomin on 2018/8/30.
 */
@Aspect
public class LoginInterceptAspect {

    private static final String TAG = "LoginInterceptAspect";

    @Pointcut("execution(@com.fomin.aop.login.aspect.LoginIntercept private * *..*.*(..))")//這里使用private是因為方法中全部是private，也可以去除
    public void loginFilter() {
    }

    @SuppressWarnings("CheckStyle")
    @Around("loginFilter()")
    public void aroundLoginPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        ILogin login = LoginSDK.getInstance().getLogin();
        if (login == null) {
            throw new NoInitException("LoginSDK沒有初始化！");
        }

        Signature signature = joinPoint.getSignature();
        if (!(signature instanceof MethodSignature)) {
            throw new AnnotationException("LoginIntercept注解只能用於方法上");
        }

        MethodSignature methodSignature = (MethodSignature) signature;
        Log.d("Aspect", String.valueOf(methodSignature.getName()));
        Log.d("Aspect", String.valueOf(methodSignature.getMethod() == null));
        LoginIntercept loginIntercept = methodSignature.getMethod().getAnnotation(LoginIntercept.class);
        if (loginIntercept== null) {
            return;
        }
        Context param = LoginSDK.getInstance().getContext();
        if (login.isLogin(param)) {
            joinPoint.proceed();
        } else {
            login.login(param, loginFilter.actionDefine());
        }
    }
}

注意：在LoginFilterAspect 類中如果有用到Context，可直接使用joinPoint.getTarget()類型轉換成Context，這里是由於項目使用了databinding，部分getTarget()獲取到的值不能強轉為Context，所以這里用的MyApplication獲取的Context。
ILogin接口：

ILogin：接口
package com.huaying.aop.login.core;

import android.content.Context;

/**
 * Created by Fomin on 2018/8/29.
 */
public interface ILogin {

    /**
     * 登錄事件接收
     * @param context Context
     * @param actionDefine 登錄操作
     */
    void login(Context context, int actionDefine);

    /**
     * 判斷是否登錄
     * @param context Context
     * @return
     */
    boolean isLogin(Context context);
}

LoginSDK 類：

package com.huaying.aop.login.core;

import android.content.Context;

/**
 * Created by Fomin on 2018/8/30.
 */
public class LoginSDK {
    private static LoginSDK instance;

    private LoginSDK() {
    }

    public static LoginSDK getInstance() {
        if (instance == null) {
            synchronized (LoginSDK.class) {
                if (instance == null) {
                    instance = new LoginSDK();
                }
            }
        }
        return instance;
    }

    private ILogin login;
    private Context context;
    
    /**
     * 初始化
     *
     * @param context Context
     * @param iLogin  登錄事件
     */
    public void init(Context context, ILogin iLogin) {
        this.context = context;
        this.login = iLogin;
    }

    public ILogin getLogin() {
        return login;
    }

    public Context getContext() {
        return context;
    }
}

相關aop lib已經編寫完成，接下來就是使用，需要在application中初始化LoginSDK

public class AppContext implements IModuleConfig, IAppLife {
    private static final String TAG = AppContext.class.getSimpleName();
    public AppContext() {
    }

    @Override
    public void attachBaseContext(Context base) {
    }

    @Override
    public void injectAppLifecycle(Context context, List<IAppLife> lifeList) {
        lifeList.add(this);
    }

    @Override
    public void onCreate(BaseApplication application) {
        LoginSDK.getInstance().init(application, login);
    }


    private ILogin login = new ILogin() {
        @Override
        public void login(Context context, int actionDefine) {
            switch (actionDefine) {
                case 0:
                    ToastHelper.showMessage(R.string.login_required);
                    IntentUtils.actionWeChatLogin(AppManager.currentActivity(), IReturnType.Mine);
                    break;
                case 1:
                    ToastHelper.showMessage(R.string.login_required);
                    break;
            }
        }

        @Override
        public boolean isLogin(Context context) {
            return component().userManager().hasUser();
        }
    };
}

在具體的業務中使用注解

@LoginIntercept
private void toUserPage() {
    IntentUtils.startActivity(getActivity(), UserActivity.class);
}

大功告成，可以優雅的使用登錄攔截了，由於時間有限，像權限請求也像登錄那樣處理即可，可能會接下來的文章繼續寫權限請求Aop，還有一個需要注意點，在release包混淆中，不要把注解類混淆,不然會報NPE錯誤

# aop注解
-adaptclassstrings
-keepattributes InnerClasses, EnclosingMethod, Signature, *Annotation*
-keepnames @org.aspectj.lang.annotation.Aspect class * {
    ajc* <methods>;
}
-keepclassmembers class ** {
    @com.huaying.aop.login.aspect.LoginFilter <methods>;
}