aop 概念詳解
本文主要內容
-
什麼是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介面
packageorg.aopalliance.intercept;
publicinterfaceJoinpoint{
/**
*轉到攔截器鏈中的下一個攔截器
*/
Objectproceed()throwsThrowable;
/**
*返回儲存當前連線點靜態部分【的物件】，這裡一般指被代理的目標物件
*/
ObjectgetThis();
/**
*返回此靜態連線點一般就為當前的Method(至少目前的唯一實現是MethodInvocation,所以連線點得靜態部分肯定就是本方法)
*/
AccessibleObjectgetStaticPart();
}
幾個重要的子介面和實現類，如下：
Invocation介面
packageorg.aopalliance.intercept;
/**
*此介面表示程式中的呼叫
*呼叫是一個連線點，可以被攔截器攔截。
*/
publicinterfaceInvocationextendsJoinpoint{
/**
*將引數作為陣列物件獲取。可以更改此陣列中的元素值以更改引數。
*通常用來獲取呼叫目標方法的引數
*/
Object[]getArguments();
}
MethodInvocation介面
packageorg.aopalliance.intercept;
importjava.lang.reflect.Method;
/**
*方法呼叫的描述，在方法呼叫時提供給攔截器。
*方法呼叫是一個連線點，可以被方法攔截器攔截。
*/
publicinterfaceMethodInvocationextendsInvocation{
/**
*返回正在被呼叫得方法~~~返回的是當前Method物件。
*此時，效果同父類的AccessibleObjectgetStaticPart()這個方法
*/
MethodgetMethod();
}
通知(Advice)
通知中用來實現被增強的邏輯，通知中有2個關注點，再強調一下：方法的什麼地方，執行什麼操作。
Advice介面
通知的頂層介面，這個介面內部沒有定義任何方法。
packageorg.aopalliance.aop;
publicinterfaceAdvice{
}
Advice 4個子介面
MethodBeforeAdvice介面
方法執行前通知，需要在目標方法執行前執行一些邏輯的，可以通過這個實現。
通俗點說：需要在目標方法執行之前增強一些邏輯，可以通過這個介面來實現。before方法：在呼叫給定方法之前回調。
packageorg.springframework.aop;
publicinterfaceMethodBeforeAdviceextendsBeforeAdvice{
/**
*呼叫目標方法之前會先呼叫這個before方法
* method：需要執行的目標方法
* args：目標方法的引數
* target：目標物件
*/
voidbefore(Methodmethod,Object[]args,@NullableObjecttarget)throwsThrowable;
}
如同
publicObjectinvoke(){
呼叫MethodBeforeAdvice#before方法
return呼叫目標方法;
}
AfterReturningAdvice介面
方法執行後通知，需要在目標方法執行之後執行增強一些邏輯的，可以通過這個實現。
不過需要注意一點：目標方法正常執行後，才會回撥這個介面，當目標方法有異常，那麼這通知會被跳過。
packageorg.springframework.aop;
publicinterfaceAfterReturningAdviceextendsAfterAdvice{
/**
*目標方法執行之後會回撥這個方法
* method：需要執行的目標方法
* args：目標方法的引數
* target：目標物件
*/
voidafterReturning(@NullableObjectreturnValue,Methodmethod,Object[]args,@NullableObjecttarget)throwsThrowable;
}
如同
publicObjectinvoke(){
ObjectretVal=呼叫目標方法;
呼叫AfterReturningAdvice#afterReturning方法
returnretVal;
}
ThrowsAdvice介面
packageorg.springframework.aop;
publicinterfaceThrowsAdviceextendsAfterAdvice{
}
此介面上沒有任何方法，因為方法由反射呼叫，實現類必須實現以下形式的方法，前3個引數是可選的，最後一個引數為需要匹配的異常的型別。
voidafterThrowing([Method,args,target],ThrowableSubclass);
有效方法的一些例子如下：
publicvoidafterThrowing(Exceptionex)
publicvoidafterThrowing(RemoteException)
publicvoidafterThrowing(Methodmethod,Object[]args,Objecttarget,Exceptionex)
publicvoidafterThrowing(Methodmethod,Object[]args,Objecttarget,ServletExceptionex)
MethodInterceptor介面
方法攔截器，這個介面最強大，可以實現上面3種類型的通知，上面3種通知最終都通過適配模式將其轉換為MethodInterceptor方式去執行。
packageorg.aopalliance.intercept;
@FunctionalInterface
publicinterfaceMethodInterceptorextendsInterceptor{
/**
*攔截目標方法的執行，可以在這個方法內部實現需要增強的邏輯，以及主動呼叫目標方法
*/
Objectinvoke(MethodInvocationinvocation)throwsThrowable;
}
使用方式如：
publicclassTracingInterceptorimplementsMethodInterceptor{
Objectinvoke(MethodInvocationi)throwsThrowable{
System.out.println("method"+i.getMethod()+"iscalledon"+i.getThis()+"withargs"+i.getArguments());
Objectret=i.proceed();//轉到攔截器鏈中的下一個攔截器
System.out.println("method"+i.getMethod()+"returns"+ret);
returnret;
}
}
攔截器鏈
一個目標方法中可以新增很多Advice，這些Advice最終都會被轉換為MethodInterceptor型別的方法攔截器，最終會有多個MethodInterceptor，這些MethodInterceptor會組成一個方法呼叫鏈。
Aop內部會給目標物件建立一個代理，代理物件中會放入這些MethodInterceptor會組成一個方法呼叫鏈，當呼叫代理物件的方法的時候，會按順序執行這些方法呼叫鏈，一個個執行，最後會通過反射再去呼叫目標方法，進而對目標方法進行增強。
切入點(PointCut)
通知（Advice）用來指定需要增強的邏輯，但是哪些類的哪些方法中需要使用這些通知呢？這個就是通過切入點來配置的，切入點在spring中對應了一個介面
PointCut介面
packageorg.springframework.aop;
publicinterfacePointcut{
/**
*類過濾器,可以知道哪些類需要攔截
*/
ClassFiltergetClassFilter();
/**
*方法匹配器,可以知道哪些方法需要攔截
*/
MethodMatchergetMethodMatcher();
/**
*匹配所有物件的Pointcut，內部的2個過濾器預設都會返回true
*/
PointcutTRUE=TruePointcut.INSTANCE;
}
ClassFilter介面
比較簡單，用來過濾類的
@FunctionalInterface
publicinterfaceClassFilter{
/**
*用來判斷目標型別是否匹配
*/
booleanmatches(Class<?>clazz);
}
MethodMatcher介面
用來過濾方法的。
publicinterfaceMethodMatcher{
/**
*執行靜態檢查給定方法是否匹配
*@parammethod目標方法
*@paramtargetClass目標物件型別
*/
booleanmatches(Methodmethod,Class<?>targetClass);
/**
*是否是動態匹配，即是否每次執行目標方法的時候都去驗證一下
*/
booleanisRuntime();
/**
*動態匹配驗證的方法，比第一個matches方法多了一個引數args，這個引數是呼叫目標方法傳入的引數
*/
booleanmatches(Methodmethod,Class<?>targetClass,Object...args);
/**
*匹配所有方法，這個內部的2個matches方法任何時候都返回true
*/
MethodMatcherTRUE=TrueMethodMatcher.INSTANCE;
}
我估計大家看MethodMatcher還是有點暈的，為什麼需要2個maches方法？什麼是動態匹配？
比如下面一個類
publicclassUserService{
publicvoidwork(StringuserName){
System.out.print(userName+",開始工作了!");
}
}
work方法表示當前使用者的工作方法，內部可以實現一些工作的邏輯。
我們希望通過aop對這個類進行增強，呼叫這個方法的時候，當傳入的使用者名稱是路人的粉絲的的時候，需要先進行問候，其他使用者的時候，無需問候，將這個問題的程式碼可以放在MethodBeforeAdvice中實現，這種情況就是當引數滿足一定的條件了，才會使用這個通知，不滿足的時候，通知無效，此時就可以使用上面的動態匹配來實現，MethodMatcher類中3個引數的matches方法可以用來對目標方法的引數做校驗。
來看一下MethodMatcher過濾的整個過程
1.呼叫matches(Methodmethod,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介面
packageorg.springframework.aop;
importorg.aopalliance.aop.Advice;
/**
*包含AOP通知（在joinpoint處執行的操作）和確定通知適用性的過濾器（如切入點[PointCut]）的基本介面。
*這個介面不是供Spring使用者使用的，而是為了支援不同型別的建議的通用性。
*/
publicinterfaceAdvisor{
/**
*返回引用的通知
*/
AdvicegetAdvice();
}
上面這個介面通常不會直接使用，這個介面有2個子介面，通常我們會和這2個子介面來打交道，下面看一下這2個子介面。
PointcutAdvisor介面
通過名字就能看出來，這個和Pointcut有關，內部有個方法用來獲取Pointcut，AOP使用到的大部分Advisor都屬於這種型別的。
在目標方法中實現各種增強功能基本上都是通過PointcutAdvisor來實現的。
packageorg.springframework.aop;
/**
*切入點型別的Advisor
*/
publicinterfacePointcutAdvisorextendsAdvisor{
/**
*獲取顧問中使用的切入點
*/
PointcutgetPointcut();
}
IntroductionAdvisor介面
這個介面，估計大家比較陌生，幹什麼的呢？
一個Java類，沒有實現A介面，在不修改Java類的情況下，使其具備A介面的功能。可以通過IntroductionAdvisor給目標類引入更多介面的功能，這個功能是不是非常牛逼。
案例
上面都是一些概念，看起來比較枯燥乏味，下面來個使用硬編碼的方式來用一下上面提到的一些類或者介面，加深理解。
來個類
packagecom.javacode2018.aop.demo3;
publicclassUserService{
publicvoidwork(StringuserName){
System.out.println(userName+",正在和路人甲java一起學Spring Aop，歡迎大家一起來！");
}
}
下面通過aop來實現一些需求，對work方法進行增強。
案例1
需求：在work方法執行之前，列印一句：你好：userName
下面直接上程式碼，註釋比較詳細，就不細說了。
@Test
publicvoidtest1(){
//定義目標物件
UserServicetarget=newUserService();
//建立pointcut，用來攔截UserService中的work方法
Pointcutpointcut=newPointcut(){
@Override
publicClassFiltergetClassFilter(){
//判斷是否是UserService型別的
returnclazz->UserService.class.isAssignableFrom(clazz);
}
@Override
publicMethodMatchergetMethodMatcher(){
returnnewMethodMatcher(){
@Override
publicbooleanmatches(Methodmethod,Class<?>targetClass){
//判斷方法名稱是否是work
return"work".equals(method.getName());
}
@Override
publicbooleanisRuntime(){
returnfalse;
}
@Override
publicbooleanmatches(Methodmethod,Class<?>targetClass,Object...args){
returnfalse;
}
};
}
};
//建立通知，此處需要在方法之前執行操作，所以需要用到MethodBeforeAdvice型別的通知
MethodBeforeAdviceadvice=(method,args,target1)->System.out.println("你好:"+args[0]);
//建立Advisor，將pointcut和advice組裝起來
DefaultPointcutAdvisoradvisor=newDefaultPointcutAdvisor(pointcut,advice);
//通過spring提供的代理建立工廠來建立代理
ProxyFactoryproxyFactory=newProxyFactory();
//為工廠指定目標物件
proxyFactory.setTarget(target);
//呼叫addAdvisor方法，為目標新增增強的功能，即新增Advisor，可以為目標新增很多個Advisor
proxyFactory.addAdvisor(advisor);
//通過工廠提供的方法來生成代理物件
UserServiceuserServiceProxy=(UserService)proxyFactory.getProxy();
//呼叫代理的work方法
userServiceProxy.work("路人");
}
執行輸出
你好:路人
路人,正在和路人甲java一起學Spring Aop，歡迎大家一起來！
上面是採用硬編碼的方式來感受一下aop的用法，大家看了上面程式碼之後，估計會有疑問：我暈，這麼複雜？？？
如果大家有使用過spring中的aop經驗，可能只需要幾行程式碼就實現了上面的功能，的確，spring中把整個功能簡化了很多，不過我們得去了解他的內部是如何實現的，然後才能走的更遠。
案例2
需求：統計一下work方法的耗時，將耗時輸出
@Test
publicvoidtest2(){
//定義目標物件
UserServicetarget=newUserService();
//建立pointcut，用來攔截UserService中的work方法
Pointcutpointcut=newPointcut(){
@Override
publicClassFiltergetClassFilter(){
//判斷是否是UserService型別的
returnclazz->UserService.class.isAssignableFrom(clazz);
}
@Override
publicMethodMatchergetMethodMatcher(){
returnnewMethodMatcher(){
@Override
publicbooleanmatches(Methodmethod,Class<?>targetClass){
//判斷方法名稱是否是work
return"work".equals(method.getName());
}
@Override
publicbooleanisRuntime(){
returnfalse;
}
@Override
publicbooleanmatches(Methodmethod,Class<?>targetClass,Object...args){
returnfalse;
}
};
}
};
//建立通知，需要攔截方法的執行，所以需要用到MethodInterceptor型別的通知
MethodInterceptoradvice=newMethodInterceptor(){
@Override
publicObjectinvoke(MethodInvocationinvocation)throwsThrowable{
System.out.println("準備呼叫:"+invocation.getMethod());
longstarTime=System.nanoTime();
Objectresult=invocation.proceed();
longendTime=System.nanoTime();
System.out.println(invocation.getMethod()+"，呼叫結束！");
System.out.println("耗時(納秒):"+(endTime-starTime));
returnresult;
}
};
//建立Advisor，將pointcut和advice組裝起來
DefaultPointcutAdvisoradvisor=newDefaultPointcutAdvisor(pointcut,advice);
//通過spring提供的代理建立工廠來建立代理
ProxyFactoryproxyFactory=newProxyFactory();
//為工廠指定目標物件
proxyFactory.setTarget(target);
//呼叫addAdvisor方法，為目標新增增強的功能，即新增Advisor，可以為目標新增很多個Advisor
proxyFactory.addAdvisor(advisor);
//通過工廠提供的方法來生成代理物件
UserServiceuserServiceProxy=(UserService)proxyFactory.getProxy();
//呼叫代理的work方法
userServiceProxy.work("路人");
}
執行輸出
準備呼叫:publicvoidcom.javacode2018.aop.demo3.UserService.work(java.lang.String)
路人,正在和路人甲java一起學Spring Aop，歡迎大家一起來！
publicvoidcom.javacode2018.aop.demo3.UserService.work(java.lang.String)，呼叫結束！
耗時(納秒):9526200
案例3
需求：userName中包含“粉絲”關鍵字，輸出一句：感謝您一路的支援
此處需要用到 MethodMatcher 中的動態匹配了，通過引數來進行判斷。
重點在於Pointcut中的getMethodMatcher方法，返回的MethodMatcher，@1必須返回true，此時才會進入到@2中對引數進行校驗。
程式碼如下：
@Test
publicvoidtest2(){
//定義目標物件
UserServicetarget=newUserService();
//建立pointcut，用來攔截UserService中的work方法
Pointcutpointcut=newPointcut(){
@Override
publicClassFiltergetClassFilter(){
//判斷是否是UserService型別的
returnclazz->UserService.class.isAssignableFrom(clazz);
}
@Override
publicMethodMatchergetMethodMatcher(){
returnnewMethodMatcher(){
@Override
publicbooleanmatches(Methodmethod,Class<?>targetClass){
//判斷方法名稱是否是work
return"work".equals(method.getName());
}
@Override
publicbooleanisRuntime(){
returntrue;//@1：注意這個地方要返回true
}
@Override
publicbooleanmatches(Methodmethod,Class<?>targetClass,Object...args){
//@2：isRuntime為true的時候，會執行這個方法
if(Objects.nonNull(args)&&args.length==1){
StringuserName=(String)args[0];
returnuserName.contains("粉絲");
}
returnfalse;
}
};
}
};
//建立通知，此處需要在方法之前執行操作，所以需要用到MethodBeforeAdvice型別的通知
MethodBeforeAdviceadvice=(method,args,target1)->System.out.println("感謝您一路的支援!");
//建立Advisor，將pointcut和advice組裝起來
DefaultPointcutAdvisoradvisor=newDefaultPointcutAdvisor(pointcut,advice);
//通過spring提供的代理建立工廠來建立代理
ProxyFactoryproxyFactory=newProxyFactory();
//為工廠指定目標物件
proxyFactory.setTarget(target);
//呼叫addAdvisor方法，為目標新增增強的功能，即新增Advisor，可以為目標新增很多個Advisor
proxyFactory.addAdvisor(advisor);
//通過工廠提供的方法來生成代理物件
UserServiceuserServiceProxy=(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一下，可以持續關注動態。
參考：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648934876&idx=1&sn=7794b50e658e0ec3e0aff6cf5ed4aa2e&chksm=886211e2bf1598f4e0e636170a4b36a5a5edd8811c8b7c30d61135cb114b0ce506a6fa84df0b&token=690771459&lang=zh_CN&scene=21#wechat_redirect