本文主要內容
什麼是Aop？
Spring AOP中重要的一些概念詳解
Spring AOP 硬編碼實現
什麼是AOP？
先看一下傳統程序的流程，比如銀行系統會有一個取款流程
我們可以把方框裏的流程合爲一個，另外系統還會有一個查詢餘額流程，我們先把這兩個流程放到一起：
有沒有發現，這個兩者有一個相同的驗證流程，我們先把它們圈起來再說下一步：
上面只是2個操作，如果有更多的操作，驗證用戶的功能是不是需要寫很多次？
有沒有想過可以把這個驗證用戶的代碼是提取出來，不放到主流程裏去呢，這就是AOP的作用了，有了AOP，你寫代碼時不要把這個驗證用戶步驟寫進去，即完全不考慮驗證用戶，你寫完之後，在另我一個地方，寫好驗證用戶的代碼，然後告訴Spring你要把這段代碼加到哪幾個地方，Spring就會幫你加過去，而不要你自己Copy過去，如果你有多個控制流呢，這個寫代碼的方法可以大大減少你的時間。
再舉一個通用的例子，經常在debug的時候要打log吧，你也可以寫好主要代碼之後，把打log的代碼寫到另一個單獨的地方，然後命令AOP把你的代碼加過去，注意AOP不會把代碼加到源文件裏，但是它會正確的影響最終的機器代碼。
現在大概明白了AOP了嗎，我們來理一下頭緒，上面那個方框像不像個平面，你可以把它當塊板子，這塊板子插入一些控制流程，這塊板子就可以當成是AOP中的一個切面。所以AOP的本質是在一系列縱向的控制流程中，把那些相同的子流程提取成一個橫向的面，這句話應該好理解吧，我們把縱向流程畫成一條直線，然把相同的部分以綠色突出，如下圖左，而AOP相當於把相同的地方連一條橫線，如下圖右，這個圖沒畫好，大家明白意思就行。
這個驗證用戶這個子流程就成了一個條線，也可以理解成一個切面，這裏的切面只插了兩三個流程，如果其它流程也需要這個子流程，也可以插到其它地方去。
通熟易懂的理解爲：在程序中具有公共特性的某些類/某些方法上進行攔截, 在方法執行的前面/後面/執行結果返回後增加執行一些方法。
先來考慮幾個問題
aop中用什麼來表示這些公共的功能？
aop中如何知道這些公共的功能用到哪些類的那些方法中去？
aop中需要將這些公共的功能用在目標方法的什麼地方，前面？後面？還是其他什麼地方？
aop底層是用什麼實現的？
spring中有些概念，不是太好理解，帶着這些問題，理解起來會容易很多，概念理解了，後面的路會容易很多，下面我們先來理解概念。
Spring中AOP一些概念
目標對象(target)
目標對象指將要被增強的對象，即包含主業務邏輯的類對象。
連接點(JoinPoint)
程序執行過程中明確的點，如方法的調用或特定的異常被拋出。
連接點由兩個信息確定：
方法(表示程序執行點，即在哪個目標方法)
相對點(表示方位，即目標方法的什麼位置，比如調用前，後等)
簡單來說，連接點就是被攔截到的程序執行點，因爲Spring只支持方法類型的連接點，所以在Spring中連接點就是被攔截到的方法。
代理對象(Proxy)
AOP中會通過代理的方式，對目標對象生成一個代理對象，代理對象中會加入需要增強功能，通過代理對象來間接的方式目標對象，起到增強目標對象的效果。
通知(Advice)
需要在目標對象中增強的功能，如上面說的：業務方法前驗證用戶的功能、方法執行之後打印方法的執行日誌。
通知中有2個重要的信息：方法的什麼地方，執行什麼操作，這2個信息通過通知來指定。
方法的什麼地方？之前、之後、包裹目標方法、方法拋出異常後等。
如：
在方法執行之前驗證用戶是否有效。
在方法執行之後，打印方法的執行耗時。
在方法拋出異常後，記錄異常信息發送到mq。
切入點(Pointcut )
用來指定需要將通知使用到哪些地方，比如需要用在哪些類的哪些方法上，切入點就是做這個配置的。
切面（Aspect）
通知（Advice）和切入點（Pointcut）的組合。切面來定義在哪些地方（Pointcut）執行什麼操作（Advice）。
顧問（Advisor)
Advisor 其實它就是 Pointcut 與 Advice 的組合，Advice 是要增強的邏輯，而增強的邏輯要在什麼地方執行是通過Pointcut來指定的，所以 Advice 必需與 Pointcut 組合在一起，這就誕生了 Advisor 這個類，spring Aop中提供了一個Advisor接口將Pointcut 與 Advice 的組合起來。
Advisor有好幾個稱呼：顧問、通知器。
其中這4個：連接點(JoinPoint)、通知(advise)、切入點(pointcut)、顧問（advisor)，在spring中都定義了接口和類來表示這些對象，下面我們一個個來看一下。
連接點（JoinPoint）
JoinPoint接口
package org.aopalliance.intercept;
public interface Joinpoint {
/**
* 轉到攔截器鏈中的下一個攔截器
*/
Object proceed() throws Throwable;
/**
* 返回保存當前連接點靜態部分【的對象】，這裏一般指被代理的目標對象
*/
Object getThis();
/**
* 返回此靜態連接點 一般就爲當前的Method(至少目前的唯一實現是MethodInvocation,所以連接點得靜態部分肯定就是本方法)
*/
AccessibleObject getStaticPart();
}
幾個重要的子接口和實現類，如下：
Invocation接口
package org.aopalliance.intercept;
/**
* 此接口表示程序中的調用
* 調用是一個連接點，可以被攔截器攔截。
*/
public interface Invocation extends Joinpoint {
/**
* 將參數作爲數組對象獲取。可以更改此數組中的元素值以更改參數。
* 通常用來獲取調用目標方法的參數
*/
Object[] getArguments();
}
MethodInvocation接口
package org.aopalliance.intercept;
import java.lang.reflect.Method;
/**
* 方法調用的描述，在方法調用時提供給攔截器。
* 方法調用是一個連接點，可以被方法攔截器攔截。
*/
public interface MethodInvocation extends Invocation {
/**
* 返回正在被調用得方法~~~ 返回的是當前Method對象。
* 此時，效果同父類的AccessibleObject getStaticPart() 這個方法
*/
Method getMethod();
}
通知(Advice)
通知中用來實現被增強的邏輯，通知中有2個關注點，再強調一下：方法的什麼地方，執行什麼操作。
Advice接口
通知的頂層接口，這個接口內部沒有定義任何方法。
package org.aopalliance.aop;
public interface Advice {
}
Advice 4個子接口
MethodBeforeAdvice接口
方法執行前通知，需要在目標方法執行前執行一些邏輯的，可以通過這個實現。
通俗點說：需要在目標方法執行之前增強一些邏輯，可以通過這個接口來實現。before方法：在調用給定方法之前回調。
package org.springframework.aop;
public interface MethodBeforeAdvice extends BeforeAdvice {
/**
* 調用目標方法之前會先調用這個before方法
* method：需要執行的目標方法
* args：目標方法的參數
* target：目標對象
*/
void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}
如同
public Object invoke(){
調用MethodBeforeAdvice#before方法
return 調用目標方法;
}
AfterReturningAdvice接口
方法執行後通知，需要在目標方法執行之後執行增強一些邏輯的，可以通過這個實現。
不過需要注意一點：目標方法正常執行後，纔會回調這個接口，當目標方法有異常，那麼這通知會被跳過。
package org.springframework.aop;
public interface AfterReturningAdvice extends AfterAdvice {
/**
* 目標方法執行之後會回調這個方法
* method：需要執行的目標方法
* args：目標方法的參數
* target：目標對象
*/
void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
}
如同
public Object invoke(){
Object retVal = 調用目標方法;
調用AfterReturningAdvice#afterReturning方法
return retVal;
}
ThrowsAdvice接口
package org.springframework.aop;
public interface ThrowsAdvice extends AfterAdvice {
}
此接口上沒有任何方法，因爲方法由反射調用，實現類必須實現以下形式的方法，前3個參數是可選的，最後一個參數爲需要匹配的異常的類型。
void afterThrowing([Method, args, target], ThrowableSubclass);
有效方法的一些例子如下：
public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)
MethodInterceptor接口
方法攔截器，這個接口最強大，可以實現上面3種類型的通知，上面3種通知最終都通過適配模式將其轉換爲MethodInterceptor方式去執行。
package org.aopalliance.intercept;
@FunctionalInterface
public interface MethodInterceptor extends Interceptor {
/**
* 攔截目標方法的執行，可以在這個方法內部實現需要增強的邏輯，以及主動調用目標方法
*/
Object invoke(MethodInvocation invocation) throws Throwable;
}
使用方式如：
public class TracingInterceptor implements MethodInterceptor {
Object invoke(MethodInvocation i) throws Throwable {
System.out.println("method "+i.getMethod()+" is called on "+ i.getThis()+" with args "+i.getArguments());
Object ret=i.proceed();//轉到攔截器鏈中的下一個攔截器
System.out.println("method "+i.getMethod()+" returns "+ret);
return ret;
}
}
攔截器鏈
一個目標方法中可以添加很多Advice，這些Advice最終都會被轉換爲MethodInterceptor類型的方法攔截器，最終會有多個MethodInterceptor，這些MethodInterceptor會組成一個方法調用鏈。
Aop內部會給目標對象創建一個代理，代理對象中會放入這些MethodInterceptor會組成一個方法調用鏈，當調用代理對象的方法的時候，會按順序執行這些方法調用鏈，一個個執行，最後會通過反射再去調用目標方法，進而對目標方法進行增強。
切入點(PointCut)
通知（Advice）用來指定需要增強的邏輯，但是哪些類的哪些方法中需要使用這些通知呢？這個就是通過切入點來配置的，切入點在spring中對應了一個接口
PointCut接口
package org.springframework.aop;
public interface Pointcut {
/**
* 類過濾器, 可以知道哪些類需要攔截
*/
ClassFilter getClassFilter();
/**
* 方法匹配器, 可以知道哪些方法需要攔截
*/
MethodMatcher getMethodMatcher();
/**
* 匹配所有對象的 Pointcut，內部的2個過濾器默認都會返回true
*/
Pointcut TRUE = TruePointcut.INSTANCE;
}
ClassFilter接口
比較簡單，用來過濾類的
@FunctionalInterface
public interface ClassFilter {
/**
* 用來判斷目標類型是否匹配
*/
boolean matches(Class<?> clazz);
}
MethodMatcher接口
用來過濾方法的。
public interface MethodMatcher {
/**
* 執行靜態檢查給定方法是否匹配
* @param method 目標方法
* @param targetClass 目標對象類型
*/
boolean matches(Method method, Class<?> targetClass);
/**
* 是否是動態匹配，即是否每次執行目標方法的時候都去驗證一下
*/
boolean isRuntime();
/**
* 動態匹配驗證的方法，比第一個matches方法多了一個參數args，這個參數是調用目標方法傳入的參數
*/
boolean matches(Method method, Class<?> targetClass, Object... args);
/**
* 匹配所有方法，這個內部的2個matches方法任何時候都返回true
*/
MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
}
我估計大家看MethodMatcher還是有點暈的，爲什麼需要2個maches方法？什麼是動態匹配？
比如下面一個類
public class UserService{
public void work(String userName){
System.out.print(userName+",開始工作了!");
}
}
work方法表示當前用戶的工作方法，內部可以實現一些工作的邏輯。
我們希望通過aop對這個類進行增強，調用這個方法的時候，當傳入的用戶名是路人的粉絲的的時候，需要先進行問候，其他用戶的時候，無需問候，將這個問題的代碼可以放在MethodBeforeAdvice中實現，這種情況就是當參數滿足一定的條件了，纔會使用這個通知，不滿足的時候，通知無效，此時就可以使用上面的動態匹配來實現，MethodMatcher類中3個參數的matches方法可以用來對目標方法的參數做校驗。
來看一下MethodMatcher過濾的整個過程
1.調用matches(Method method, Class<?> targetClass)方法，驗證方法是否匹配
2.isRuntime方法是否爲true，如果爲false，則以第一步的結果爲準，否則繼續向下
3.調用matches(Method method, Class<?> targetClass, Object... args)方法繼續驗證，這個方法多了一個參數，可以對目標方法傳入的參數進行校驗。
通過上面的過程，大家可以看出來，如果isRuntime爲false的時候，只需要對方法名稱進行校驗，當目標方法調用多次的時候，實際上第一步的驗證結果是一樣的，所以如果isRuntime爲false的情況，可以將驗證結果放在緩存中，提升效率，而spring內部就是這麼做的，isRuntime爲false的時候，需要每次都進行校驗，效率會低一些，不過對性能的影響基本上可以忽略。
顧問(Advisor)
通知定義了需要做什麼，切入點定義了在哪些類的哪些方法中執行通知，那麼需要將他們2個組合起來纔有效啊。
顧問（Advisor）就是做這個事情的。
Advisor接口
package org.springframework.aop;
import org.aopalliance.aop.Advice;
/**
* 包含AOP通知（在joinpoint處執行的操作）和確定通知適用性的過濾器（如切入點[PointCut]）的基本接口。
* 這個接口不是供Spring用戶使用的，而是爲了支持不同類型的建議的通用性。
*/
public interface Advisor {
/**
* 返回引用的通知
*/
Advice getAdvice();
}
上面這個接口通常不會直接使用，這個接口有2個子接口，通常我們會和這2個子接口來打交道，下面看一下這2個子接口。
PointcutAdvisor接口
通過名字就能看出來，這個和Pointcut有關，內部有個方法用來獲取Pointcut，AOP使用到的大部分Advisor都屬於這種類型的。
在目標方法中實現各種增強功能基本上都是通過PointcutAdvisor來實現的。
package org.springframework.aop;
/**
* 切入點類型的Advisor
*/
public interface PointcutAdvisor extends Advisor {
/**
* 獲取顧問中使用的切入點
*/
Pointcut getPointcut();
}
IntroductionAdvisor接口
這個接口，估計大家比較陌生，幹什麼的呢？
一個Java類，沒有實現A接口，在不修改Java類的情況下，使其具備A接口的功能。可以通過IntroductionAdvisor給目標類引入更多接口的功能，這個功能是不是非常牛逼。
案例
上面都是一些概念，看起來比較枯燥乏味，下面來個使用硬編碼的方式來用一下上面提到的一些類或者接口，加深理解。
來個類
package com.javacode2018.aop.demo3;
public class UserService {
public void work(String userName) {
System.out.println(userName + ",正在和路人甲java一起學Spring Aop，歡迎大家一起來！");
}
}
下面通過aop來實現一些需求，對work方法進行增強。
案例1
需求：在work方法執行之前，打印一句：你好：userName
下面直接上代碼，註釋比較詳細，就不細說了。
@Test
public void test1() {
//定義目標對象
UserService target = new UserService();
//創建pointcut，用來攔截UserService中的work方法
Pointcut pointcut = new Pointcut() {
@Override
public ClassFilter getClassFilter() {
//判斷是否是UserService類型的
return clazz -> UserService.class.isAssignableFrom(clazz);
}
@Override
public MethodMatcher getMethodMatcher() {
return new MethodMatcher() {
@Override
public boolean matches(Method method, Class<?> targetClass) {
//判斷方法名稱是否是work
return "work".equals(method.getName());
}
@Override
public boolean isRuntime() {
return false;
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object... args) {
return false;
}
};
}
};
//創建通知，此處需要在方法之前執行操作，所以需要用到MethodBeforeAdvice類型的通知
MethodBeforeAdvice advice = (method, args, target1) -> System.out.println("你好:" + args[0]);
//創建Advisor，將pointcut和advice組裝起來
DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
//通過spring提供的代理創建工廠來創建代理
ProxyFactory proxyFactory = new ProxyFactory();
//爲工廠指定目標對象
proxyFactory.setTarget(target);
//調用addAdvisor方法，爲目標添加增強的功能，即添加Advisor，可以爲目標添加很多個Advisor
proxyFactory.addAdvisor(advisor);
//通過工廠提供的方法來生成代理對象
UserService userServiceProxy = (UserService) proxyFactory.getProxy();
//調用代理的work方法
userServiceProxy.work("路人");
}
運行輸出
你好:路人
路人,正在和路人甲java一起學Spring Aop，歡迎大家一起來！
上面是採用硬編碼的方式來感受一下aop的用法，大家看了上面代碼之後，估計會有疑問：我暈，這麼複雜？？？
如果大家有使用過spring中的aop經驗，可能只需要幾行代碼就實現了上面的功能，的確，spring中把整個功能簡化了很多，不過我們得去了解他的內部是如何實現的，然後才能走的更遠。
案例2
需求：統計一下work方法的耗時，將耗時輸出
@Test
public void test2() {
//定義目標對象
UserService target = new UserService();
//創建pointcut，用來攔截UserService中的work方法
Pointcut pointcut = new Pointcut() {
@Override
public ClassFilter getClassFilter() {
//判斷是否是UserService類型的
return clazz -> UserService.class.isAssignableFrom(clazz);
}
@Override
public MethodMatcher getMethodMatcher() {
return new MethodMatcher() {
@Override
public boolean matches(Method method, Class<?> targetClass) {
//判斷方法名稱是否是work
return "work".equals(method.getName());
}
@Override
public boolean isRuntime() {
return false;
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object... args) {
return false;
}
};
}
};
//創建通知，需要攔截方法的執行，所以需要用到MethodInterceptor類型的通知
MethodInterceptor advice = new MethodInterceptor() {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("準備調用:" + invocation.getMethod());
long starTime = System.nanoTime();
Object result = invocation.proceed();
long endTime = System.nanoTime();
System.out.println(invocation.getMethod() + "，調用結束！");
System.out.println("耗時(納秒):" + (endTime - starTime));
return result;
}
};
//創建Advisor，將pointcut和advice組裝起來
DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
//通過spring提供的代理創建工廠來創建代理
ProxyFactory proxyFactory = new ProxyFactory();
//爲工廠指定目標對象
proxyFactory.setTarget(target);
//調用addAdvisor方法，爲目標添加增強的功能，即添加Advisor，可以爲目標添加很多個Advisor
proxyFactory.addAdvisor(advisor);
//通過工廠提供的方法來生成代理對象
UserService userServiceProxy = (UserService) proxyFactory.getProxy();
//調用代理的work方法
userServiceProxy.work("路人");
}
運行輸出
準備調用:public void com.javacode2018.aop.demo3.UserService.work(java.lang.String)
路人,正在和路人甲java一起學Spring Aop，歡迎大家一起來！
public void com.javacode2018.aop.demo3.UserService.work(java.lang.String)，調用結束！
耗時(納秒):9526200
案例3
需求：userName中包含“粉絲”關鍵字，輸出一句：感謝您一路的支持
此處需要用到 MethodMatcher 中的動態匹配了，通過參數來進行判斷。
重點在於Pointcut中的getMethodMatcher方法，返回的MethodMatcher，@1必須返回true，此時纔會進入到@2中對參數進行校驗。
代碼如下：
@Test
public void test2() {
//定義目標對象
UserService target = new UserService();
//創建pointcut，用來攔截UserService中的work方法
Pointcut pointcut = new Pointcut() {
@Override
public ClassFilter getClassFilter() {
//判斷是否是UserService類型的
return clazz -> UserService.class.isAssignableFrom(clazz);
}
@Override
public MethodMatcher getMethodMatcher() {
return new MethodMatcher() {
@Override
public boolean matches(Method method, Class<?> targetClass) {
//判斷方法名稱是否是work
return "work".equals(method.getName());
}
@Override
public boolean isRuntime() {
return true; // @1：注意這個地方要返回true
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object... args) {
// @2：isRuntime爲true的時候，會執行這個方法
if (Objects.nonNull(args) && args.length == 1) {
String userName = (String) args[0];
return userName.contains("粉絲");
}
return false;
}
};
}
};
//創建通知，此處需要在方法之前執行操作，所以需要用到MethodBeforeAdvice類型的通知
MethodBeforeAdvice advice = (method, args, target1) -> System.out.println("感謝您一路的支持!");
//創建Advisor，將pointcut和advice組裝起來
DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
//通過spring提供的代理創建工廠來創建代理
ProxyFactory proxyFactory = new ProxyFactory();
//爲工廠指定目標對象
proxyFactory.setTarget(target);
//調用addAdvisor方法，爲目標添加增強的功能，即添加Advisor，可以爲目標添加很多個Advisor
proxyFactory.addAdvisor(advisor);
//通過工廠提供的方法來生成代理對象
UserService userServiceProxy = (UserService) proxyFactory.getProxy();
//調用代理的work方法
userServiceProxy.work("粉絲：A");
}
運行輸出
感謝您一路的支持!
粉絲：A,正在和路人甲java一起學Spring Aop，歡迎大家一起來！
本文案例代碼入口
com.javacode2018.aop.demo3.Test3
上面的一些案例中都用到了ProxyFactory這個類，內部將各種對象進行組裝，然後創建代理對象，ProxyFactory這塊關聯的的東西挺多的，下一篇文章將詳說這塊的東西，是非常重要的內容。
課後問題
對上面案例進行改造，實現下面需求：
work方法執行之後，打印一句：再見：userName
在work方法中拋出一個異常，然後通過aop中的ThrowsAdvice類型的通知來攔截這個異常信息，然後將異常錯誤信息打印出來
歡迎大家留言。
總結
這篇文章中主要介紹了一些概念性的東西，不是太好理解，建議大家多看幾遍，有關的類和接口大家也去看看源碼，理解起來也會容易一些，也歡迎大家留言一起交流這塊的東西。
案例源碼
https://gitee.com/javacode2018/spring-series
路人甲java所有案例代碼以後都會放到這個上面，大家watch一下，可以持續關注動態。
Spring系列
Spring系列第21篇：註解實現依賴注入（@Autowired、@Resource、@Primary、@Qulifier）
Spring系列第29篇：BeanFactory擴展（BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor）
更多好文章
世界上最好的關係是相互成就，點贊轉發 感恩開心????
路人甲java
▲長按圖片識別二維碼關注
路人甲Java：工作10年的前阿里P7，所有文章以系列的方式呈現，帶領大家成爲java高手，目前已出：java高併發系列、mysql高手系列、Maven高手系列、mybatis系列、spring系列，正在連載springcloud系列，歡迎關注！