文章對應的項目地址aop-tech，運行一下sample，結合代碼和文章，你會收獲更多。
熟悉程序開發的都知道OOP（Object Oriented Programming ，面向對象編程），把功能封裝在一個類中，使用的時候創建該類的對象，調用對象的方法或者使用其屬性即可，OOP具有可重用性、靈活性和擴展性。
盡管OOP具有很多好處，但是如果在軟件開發領域只使用OOP，在某些情況下也會使程序變得復雜且難以維護。例如，我們需要統計程序中點擊事件的執行情況，如果我們要自己找遍代碼中的點擊事件，這個工程量就太大了，而且維護起來也不方便。這個時候，使用AOP的方式就會使問題變得簡單。
AOP（Aspect Oriented Programming，面向切面編程），把某一類問題集中在一個地方進行處理，比如處理程序中的點擊事件、打印日志等。
關于OOP和AOP，我覺得鄧凡平老師在深入理解Android之AOP中說的挺對的：
OOP和AOP都是方法論，表示的是我們從什么角度來看待問題。OOP的精髓是把功能或問題模塊化，每個模塊處理自己的家務事。但在現實世界中，并不是所有功能都能完美得劃分到模塊中。AOP的目標是把這些功能集中起來，放到一個統一的地方來控制和管理。
那么在Android中有哪些使用到了AOP這種思想呢？
在Application中有個ActivityLifecycleCallbacks接口，這個接口提供了Activity生命周期相關的方法回調。當開發者調用了Application的public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) 方法之后，就可以在ActivityLifecycleCallbacks的實現類中統一處理這些生命周期方法。這其實就是AOP思想的一種體現。
另外，我們今天的主角——AspectJ， 它是AOP編程思想的一個很火的實踐。
AspectJ 介紹
AspectJ是一個面向切面編程的框架，它擴展了Java語言。AspectJ定義了AOP語法，它有一個專門的編譯器用來生成遵守Java字節編碼規范的Class文件。AspectJ還支持原生的Java，只需要加上AspectJ提供的注解即可。在Android開發中，一般就用它提供的注解和一些簡單的語法就可以實現絕大部分功能上的需求了。
Join Points介紹 **
Join Points，簡稱JPoints，是AspectJ中最關鍵的一個概念，表示的是程序運行時的一些執行點**。理論上說，一個程序中很多地方都可以被看做是JPoint，但是AspectJ中，只有幾種執行點被認為是JPoints，如構造方法調用、方法調用、方法執行、異常等等。JPoints實際上就是表示想把AspectJ的代碼插入到程序哪個地方，是插入在方法中，還是插入在方法調用前后。需要說明的是：在AspectJ中，方法調用（call）和方法執行（execution）是不一樣的，這個后面再做介紹。
Pointcuts介紹
一個程序會有很多的JPoints，即使是同一個函數，還分為call類型和execution類型的JPoint，但是并不是所有的JPoint都是我們需要關心的。比如我們可能只需要關心點擊事件方法，那么如何從眾多的JPoints中選擇我們感興趣的JPoint呢？這個時候可以用Pointcut：
@Around("execution(* android.view.View.OnClickListener.onClick(..))")
public void onClickMethodAround(ProceedingJoinPoint joinPoint) {}
上述代碼的意思就是在OnClickListener.onClick()方法執行前后執行代碼塊中的邏輯。
所以在這里，我們可以簡單的理解Pointcut的作用就是過濾JPoint。
Advice介紹
Advice簡單來說就是表示AspectJ的hook點，在AspectJ中常用的是before、after、around等。before表示在JPoint執行之前，需要干的事情。after表示的是在JPoint執行之后，around表示的是在JPoint執行前后。
Aspect介紹
前面我們講了AspectJ中使用過程中需要用到了一個概念，對于問題的處理需要統一放到一個地方去處理，這個地方就是Aspect，意為“切面”。在Java開發中主要是使用@Aspect注解來表示一個切面。
Android 中使用Gradle集成 AspectJ
在Android中集成AspectJ，主要思想就是hook Apk打包過程，使用AspectJ提供的工具來編譯.class文件。這一點，JakeWharton 在其項目JakeWharton/hugo 中演示了如何在Gradle中添加AspectJ，這為后來的人指了一條光明的道路。
一般來說，自己手動接入AspectJ的話，按照下面的指示即可。
在項目根目錄build.gradle下引入aspectjtools插件：
buildscript {
dependencies {
..
classpath 'org.aspectj:aspectjtools:1.8.10'
classpath 'org.aspectj:aspectjweaver:1.8.8'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
在運行app的module目錄下的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;
}
}
}
}
AspectJ在運行時也需要相關的Library支持，所以還需要在項目的dependencies中添加依賴：
dependencies {
...
compile 'org.aspectj:aspectjrt:1.8.10'
}
目前還有一些在Android中集成AspectJ的比較火的框架，如 HujiangTechnology / gradle_plugin_android_aspectjx。該框架支持kotlin，我對這個框架深入研究了一番，也按照它的思想寫了一個簡單的gradle plugin ，收獲頗多，我自己的項目地址是 aop-tech，項目中演示了如何通過AOP的方式解決統一處理登錄、綁定手機號、統計方法耗時、打印點擊事件日志等的邏輯，有興趣的可以去看看，歡迎交流。
AspectJ 命令常用參數介紹
1 -inpath: .class文件路徑，可以是在jar文件中也可以是在文件目錄中，路徑應該包含那些AspectJ相關的文件，只有這些文件才會被AspectJ處理。輸出文件會包含這些.class 。該路徑就是一個單一參數，多個路徑的話用分隔符隔開。
2 -classpath: 指定去哪找用戶使用到的.class文件，路徑可以是zip文件也可以是文件目錄，該路徑就是一個單一參數，多個路徑的話用分隔符隔開。
3 -aspectPath: 需要被處理的切面路徑，存在于jar文件或者文件目錄中。在Andorid中使用的話一般指的是被@Aspect注解標示的class文件路徑。需要注意的是編譯版本需要與Java編譯版本一致。classpath指定的路徑應該包含所有的aspectpath指定的.class文件。不過默認情況下，inPath和aspectPath中的路徑不一定非要放置在classPath中，因為編譯器會自動處理把它們加入。路徑格式與classpath和inpath樣，都需要用分隔符隔開。
4 **-bootClasspath: ** 重載跟VM相關的bootClasspath，例如在Android中使用android-27的源碼進行編譯。路徑格式與之前一樣。
5 -d: 指定由AspectJ處理后的.class文件存放目錄，如果不指定的話會放置在當前的工作目錄中。
6 -outjar: 指定被AspectJ處理后的jar包存放的文件目錄，
更多詳情請查看官網 http://www.eclipse.org/aspectj/doc/released/devguide/ajc-ref.html
Sample—處理點擊事件
例如，我們需要處理項目中的所有控件的點擊事件，打印控件的名稱，可以使用AspectJ來簡單方便的處理。在之前已經在gradle中引入的AspectJ的基礎上，我們新建一個Java文件，如下：
@Aspect
public class ClickAspect {
private static final String TAG = "ClickAspect";
// 第一個*所在的位置表示的是返回值，*表示的是任意的返回值，
// onClick()中的 .. 所在位置是方法參數的位置，.. 表示的是任意類型、任意個數的參數
// * 表示的是通配
@Pointcut("execution(* android.view.View.OnClickListener.onClick(..))")
public void clickMethod() {}
@Around("clickMethod()")
public void onClickMethodAround(ProceedingJoinPoint joinPoint) throws Throwable {
Object[] args = joinPoint.getArgs();
View view = null;
for (Object arg : args) {
if (arg instanceof View) {
view = (View) arg;
}
}
//獲取View 的 string id
String resEntryName = null;
String resName = null;
if (view != null) {
// resEntryName: btn_activity_2 resName: com.sososeen09.aop_tech:id/btn_activity_2
resEntryName = view.getContext().getResources().getResourceEntryName(view.getId());
resName = view.getContext().getResources().getResourceName(view.getId());
}
joinPoint.proceed();
Log.d(TAG, "after onclick: " + "resEntryName: " + resEntryName + " resName: " + resName);
}
}
運行項目，點擊一個控件（設置了點擊事件）之后，可以看到日志輸出：
./com.sososeen09.aop_tech D/ClickAspect: after onclick: resEntryName: btn_activity_3 resName: com.sososeen09.aop_tech:id/btn_activity_3
切入點的語法
以上面的例子來講解：
- @Around：是advice，也就是具體的插入點。@Around該方法的邏輯會包含切入點前后，如果用到該注解，記得自己需要控制切入點的執行邏輯，調用
joinPoint.proceed()。如果使用@Before注解，表示的是在切入點之前執行，@After表示在切入點之后執行，此時不需要調用joinPoint.proceed()。 - execution：處理JPoint的類型，例如call、execution。對于
execution(* android.view.View.OnClickListener.onClick(..))，第一個*所處的位置表示的是返回值，*是通配符，表示的是任意類型。android.view.View.OnClickListener.onClick(..)表示的執行OnClickListener的onClick()方法。onClick(..)中的..表示任意類型、任意個數的參數。 - onClickMethodAround：表示的實際切入代碼。這個方法名可以自己隨意定義。
在上面的例子中實際上我是自定義了一個PointCut，名字是clickMethod()。這個名稱隨意，只要在advice中指定好該名稱就可以了。
@Pointcut("execution(* android.view.View.OnClickListener.onClick(..))")
public void clickMethod() {}
如果不想自定義，可以直接這樣：
@Around("execution(* android.view.View.OnClickListener.onClick(..))")
public void onClickMethodAround(ProceedingJoinPoint joinPoint) throws Throwable {
...
}
call和execution
我們之前講的切入點語法都是execution，那么如果使用call有什么區別呢？
我們再使用一個例子，創建一個切面用來打印方法的執行時間，并且只處理帶有注解的參數。
TimeSpend 注冊如下，value表示的是方法的功能
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface TimeSpend {
String value() default "";
}
使用execution打印方法執行時間的切面如下：
@Aspect
public class MethodSpendTimeAspect {
private static final String TAG = "MethodSpendTimeAspect";
@Pointcut("execution(@com.sososeen09.aop_tech.aspect.TimeSpend * *(..))")
public void methodTime() {}
@Around("methodTime()")
public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String className = methodSignature.getDeclaringType().getSimpleName();
String methodName = methodSignature.getName();
String funName = methodSignature.getMethod().getAnnotation(TimeSpend.class).value();
//統計時間
long begin = System.currentTimeMillis();
Object result = joinPoint.proceed();
long duration = System.currentTimeMillis() - begin;
Log.e(TAG, String.format("功能：%s,%s類的%s方法執行了，用時%d ms", funName, className, methodName, duration));
return result;
}
}
原始Java文件如下：
public class LoginActivity extends AppCompatActivity {
...
@TimeSpend("登錄")
private void attemptLogin() {
StatusHolder.sHasLogin = true;
Toast.makeText(this, "登錄成功", Toast.LENGTH_SHORT).show();
finish();
}
}
編譯之后的.class文件：
public class LoginActivity extends AppCompatActivity {
protected void onCreate(Bundle savedInstanceState) {
...
super.onCreate(savedInstanceState);
mEmailSignInButton.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
LoginActivity.this.attemptLogin();
}
});
}
@TimeSpend("登錄")
private void attemptLogin() {
JoinPoint var1 = Factory.makeJP(ajc$tjp_0, this, this);
attemptLogin_aroundBody1$advice(this, var1, MethodSpendTimeAspect.aspectOf(), (ProceedingJoinPoint)var1);
}
static {
ajc$preClinit();
}
}
如果把execution該為call，在看一下編譯后的 .class 文件 :
public class LoginActivity extends AppCompatActivity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
...
mEmailSignInButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
LoginActivity.access$000(com.sososeen09.aop_tech.LoginActivity.this);
}
});
}
@TimeSpend("登錄")
private void attemptLogin() {
StatusHolder.sHasLogin = true;
Toast.makeText(this, "登錄成功", 0).show();
this.finish();
}
static {
ajc$preClinit();
}
static void access$000(LoginActivity x0) {
JoinPoint makeJP = Factory.makeJP(ajc$tjp_0, null, x0);
attemptLogin_aroundBody1$advice(x0, makeJP, MethodSpendTimeAspect.aspectOf(), (ProceedingJoinPoint) makeJP);
}
}
看到區別了吧，execution表示JPoint是執行方法的地方，AspectJ會對被執行方法做處理。而call表示JPoint是調用方法的地方，AspectJ會對調用處做處理。
總結
本文介紹了AOP的一些概念性的知識，簡單介紹了AspectJ在Android開發中的基本使用方式。限于篇幅和水平，難以對AspectJ做一個全面的介紹，建議對AOP和AspectJ有興趣的讀者可以閱讀下面的相關項目和文章，也歡迎交流。
