*本篇文章已授權微信公眾號 guolin_blog （郭霖）獨家釋出 

Android的博大精深，不是一言兩語能夠說明道清的，它的魅力只有親身去接觸才能體會。就像美女一樣

我先在這裡申明一下，我這篇AOP只是學習筆記，適合入門級選手，如果閣下是大神想要參考AOP，那麼我給個我認為寫的很好的AOP連結：http://blog.csdn.net/innost/article/details/49387395，我就是參照他的部落格和官網例子學習的。

那麼我們先來說說什麼是AOP。說到AOP也許不太瞭解，那麼OOP一定是知道的。Object-Oriented Progreming.面向物件程式設計。學java基礎的時候肯定都都會學面向物件思想和三大特性。這裡就不詳細介紹了。AOP是Aspect-Oriented Progreming的縮寫，在OOP設計中有個單一職責原則，在很多時候都不會有問題，但是當很多模組都需要同一個功能的時候，這個時候還用OOP就會很麻煩。那麼AOP在Android中的應用就應運而生。

那麼先從搭環境開始吧，待會會把aspectJ的jar包放在git上，下載1.8.5.jar包之後，安裝在電腦上。直接點安裝即可。

下一步下一步就好。這裡我只介紹Android Studio的。Eclipse也是可以使用的。Studio就好配置了，在Gradle中進行配置。

貼一下我的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 24
    buildToolsVersion "24.0.2"
    defaultConfig {
        applicationId "com.example.administrator.aspectjdemo"
        minSdkVersion 19
        targetSdkVersion 24
        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(include: ['*.jar'], dir: 'libs')
    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:24.2.1'
    testCompile 'junit:junit:4.12'
    compile files('libs/aspectjrt.jar')
}
 

至於為什麼這麼配置，AspectJ是對java的擴充套件，而且是完全相容java的。但是編譯時得用Aspect專門的編譯器，這裡的配置就是使用Aspect的編譯器。這裡還在libs匯入了一個jar包。建立依賴。

好啦，所有準備工作已完成。那麼拿著梭子就是幹，別想那麼多了。上車吧！

AOP很多是拿來做使用者行為統計和效能檢測的。那我這裡寫一個手機許可權檢測的使用方法。

首先建立一個類，用來處理觸發切面的回撥。

package com.example.administrator.aspectjdemo;

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

import org.aspectj.lang.ProceedingJoinPoint;
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 Administrator on 2016/12/26.
 */
@Aspect
public class AspectJTest {
    private static final String TAG = "tag00";

    @Pointcut("execution(@com.example.administrator.aspectjdemo.AspectJAnnotation  * *(..))")
    public void executionAspectJ() {

    }

    @Around("executionAspectJ()")
    public Object aroundAspectJ(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Log.i(TAG, "aroundAspectJ(ProceedingJoinPoint joinPoint)");
        AspectJAnnotation aspectJAnnotation = methodSignature.getMethod().getAnnotation(AspectJAnnotation.class);
        String permission = aspectJAnnotation.value();
        Context  context = (Context) joinPoint.getThis();
        Object o = null;
        if (PermissionManager.getInnerInstance().checkPermission(context,permission)) {
            o = joinPoint.proceed();
            Log.i(TAG, "有許可權");
        } else {
            Log.i(TAG, "沒有許可權，不給用");
        }
        return o;
    }

}
 

這裡要使用Aspect的編譯器編譯必須給類打上標註，@Aspect。

還有這裡的Pointcut註解，就是切點，即觸發該類的條件。裡面的字串都有哪些呢。讓我們來看看，

在我的例子中，我使用了execution，也就是以方法執行時為切點，觸發Aspect類。而execution裡面的字串是觸發條件，也是具體的切點。我來解釋一下引數的構成。“execution(@com.example.administrator.aspectjdemo.AspectJAnnotation  * *(..)”這個條件是所有加了AspectJAnnotation註解的方法或屬性都會是切點，範圍比較廣。

“**”表示是任意包名

“..”表示任意型別任意多個引數

“com.example.administrator.aspectjdemo.AspectJAnnotation”這是我的專案包名下需要指定類的絕對路徑

那知道了這些基本上就能定義自己想要的切點了。比如我只想在MainActivity的onCreate()方法執行時作為切點。那麼字串應該是“* com.example.administrator.aspectjdemo.MainActivity.onCreate(..)”，那麼這個切定就很明確，只有一個。不同的切點可以用與或來連線。看清楚哦，前面有個*號。因為onCreate方法時編譯時執行，所以在回撥時傳入的引數必須是父類JoinPoint。上面除了execution還有其他很多切點型別。比如call方法回撥時，get和set分別是獲取和執行時。等等，就不舉例了。

再來看看@Around,Around是指JPoint執行前或執行後備觸發，而around就替代了原JPoint。除了Around還有其他幾種方式。

這裡的說明和示例大家看看就大概明白什麼意思了，具體怎麼使用還是親自去實踐才行的。

回到我們的例子上來，建立完Aspect類之後，還需要一個註解類來做筆，哪裡需要做切點，那麼哪裡就用註解標註一下，這樣方便快捷。解決了OOP的單一原則問題。

package com.example.administrator.aspectjdemo;


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

/**
 * Created by Administrator on 2016/12/26.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AspectJAnnotation {
    String value();
}

註解其實很簡單的，裡面的型別並不多。想要了解的童鞋我下篇文章做個學習筆記，大家一起學習一下。

在哪使用呢。方法名和屬性名上都可以。

package com.example.administrator.aspectjdemo;

import android.Manifest;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

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

    @AspectJAnnotation(value = Manifest.permission.CAMERA)
    public void test(){
        Log.i("tag00","檢查許可權");
    }
}

text()方法執行時就是一個切點。在執行test時，會回撥上面的Aspect類的executionAspectJ()方法。然後會依次執行@Before,@After。至於After和Around誰先誰後，這個我不太清楚，如果兩個都寫的話會報錯。所以不知先後。有興趣的可以自己試試。那麼我們在看看aroundAspectJ(ProceedingJoinPoint joinPoint)這個方法裡的邏輯。

@Around("executionAspectJ()")
    public Object aroundAspectJ(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Log.i(TAG, "aroundAspectJ(ProceedingJoinPoint joinPoint)");
        AspectJAnnotation aspectJAnnotation = methodSignature.getMethod().getAnnotation(AspectJAnnotation.class);
        String permission = aspectJAnnotation.value();
        Context  context = (Context) joinPoint.getThis();
        Object o = null;
        if (PermissionManager.getInnerInstance().checkPermission(context,permission)) {
            o = joinPoint.proceed();
            Log.i(TAG, "有許可權");
        } else {
            Log.i(TAG, "沒有許可權，不給用");
        }
        return o;
    }

如果使用的是以方法相關為切點，那麼使用MethodSignature來接收joinPoint的Signature。如果是屬性或其他的，那麼可以使用Signature類來接收。之後可以使用Signature來獲取註解類。通過註解可以拿到需要檢測的許可權名稱。但是檢測許可權又需要上下文，那麼通過jointPoint.getThis()獲取使用該註解的Activity的上下文，至於Fragment的我還試過。有興趣的自己試試。那麼我們再來看看PermissionManager這個類。

package com.example.administrator.aspectjdemo;

import android.content.Context;
import android.content.pm.PackageManager;
import android.support.v4.content.ContextCompat;
import android.util.Log;

/**
 * Created by Administrator on 2016/12/26.
 */

public class PermissionManager {
    private static volatile PermissionManager permissionManager;

    public PermissionManager(){}

    //DCL單例模式
    public static PermissionManager getInstance(){
        if (permissionManager == null){
            synchronized (PermissionManager.class){
                if (permissionManager == null){
                    permissionManager = new PermissionManager();
                }
            }
        }
        return permissionManager;
    }

    private static class InnerInsatance{
        public static final PermissionManager instance = new PermissionManager();
    }

    //內部類單例模式
    public static PermissionManager getInnerInstance(){
        synchronized (PermissionManager.class){
            return InnerInsatance.instance;
        }
    }

    public boolean checkPermission(Context context,String permission){
        Log.i("tag00","檢查的許可權："+permission);
        if (ContextCompat.checkSelfPermission(context,permission) == PackageManager.PERMISSION_GRANTED){
            return true;
        }
//        if (permission.equals("android.permission.CAMERA")){
//            return true;
//        }
        return false;
    }
}

在這個類我試驗了一下兩種單例模式的效能差別，剛都說了AOP可以用來檢測效能嘛。不過沒在高併發的環境下其實兩種都差不多。ContextCompat.checkSelfPermission(context,permission) == PackageManager.PERMISSION_GRANTED這句程式碼是檢測許可權。Android提供的類，可以直接使用。那麼到這裡思路差不多清晰了。以後想要做使用者行為統計，或是效能檢測，亦或是許可權或者使用者許可權管理，AOP都是你的不二之選。

怎麼樣？捋一遍你學到了嗎？覺得有用頂一下，謝謝。