Spring一套全通3—AOP程式設計
阿新 • • 發佈：2021-11-08
百知教育 — Spring系列課程 — AOP程式設計
第一章、靜態代理設計模式
1. 為什麼需要代理設計模式
1.1 問題
-
在JavaEE分層開發開發中，那個層次對於我們來講最重要
DAO ---> Service --> Controller JavaEE分層開發中，最為重要的是Service層 -
Service層中包含了哪些程式碼？
Service層中 = 核心功能(幾十行 上百程式碼) + 額外功能(附加功能) 1. 核心功能 業務運算 DAO呼叫 2. 額外功能 1. 不屬於業務 2. 可有可無 3. 程式碼量很小 事務、日誌、效能... -
額外功能書寫在Service層中好不好？
Service層的呼叫者的角度（Controller):需要在Service層書寫額外功能。 軟體設計者：Service層不需要額外功能 -
現實生活中的解決方式
2. 代理設計模式
1.1 概念
通過代理類，為原始類（目標）增加額外的功能
好處：利於原始類(目標)的維護
1.2名詞解釋
1. 目標類 原始類 指的是 業務類 (核心功能 --> 業務運算 DAO呼叫) 2. 目標方法，原始方法 目標類(原始類)中的方法 就是目標方法(原始方法) 3. 額外功能 (附加功能) 日誌，事務，效能
1.3 代理開發的核心要素
代理類 = 目標類(原始類) + 額外功能 + 原始類(目標類)實現相同的介面 房東 ---> public interface UserService{ m1 m2 } UserServiceImpl implements UserService{ m1 ---> 業務運算 DAO呼叫 m2 } UserServiceProxy implements UserService m1 m2
1.4 編碼
靜態代理：為每一個原始類，手工編寫一個代理類 (.java .class)
1.5 靜態代理存在的問題
1. 靜態類檔案數量過多，不利於專案管理
UserServiceImpl UserServiceProxy
OrderServiceImpl OrderServiceProxy
2. 額外功能維護性差
代理類中 額外功能修改複雜(麻煩)
第二章、Spring的動態代理開發
1. Spring動態代理的概念
概念：通過代理類為原始類(目標類)增加額外功能
好處：利於原始類(目標類)的維護
2. 搭建開發環境
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.1.14.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.8.8</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.3</version>
</dependency>
3. Spring動態代理的開發步驟
-
建立原始物件(目標物件)
public class UserServiceImpl implements UserService { @Override public void register(User user) { System.out.println("UserServiceImpl.register 業務運算 + DAO "); } @Override public boolean login(String name, String password) { System.out.println("UserServiceImpl.login"); return true; } }<bean id="userService" class="com.baizhiedu.proxy.UserServiceImpl"/> -
額外功能
MethodBeforeAdvice介面額外的功能書寫在介面的實現中，執行在原始方法執行之前執行額外功能。public class Before implements MethodBeforeAdvice { /* 作用：需要把執行在原始方法執行之前執行的額外功能，書寫在before方法中 */ @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println("-----method before advice log------"); } }<bean id="before" class="com.baizhiedu.dynamic.Before"/> -
定義切入點
切入點：額外功能加入的位置 目的：由程式設計師根據自己的需要，決定額外功能加入給那個原始方法 register login 簡單的測試：所有方法都做為切入點，都加入額外的功能。<aop:config> <aop:pointcut id="pc" expression="execution(* *(..))"/> </aop:config> -
組裝 (2 3整合)
表達的含義：所有的方法 都加入 before的額外功能 <aop:advisor advice-ref="before" pointcut-ref="pc"/> -
呼叫
目的：獲得Spring工廠建立的動態代理物件，並進行呼叫 ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml"); 注意： 1. Spring的工廠通過原始物件的id值獲得的是代理物件 2. 獲得代理物件後，可以通過宣告介面型別，進行物件的儲存 UserService userService=(UserService)ctx.getBean("userService"); userService.login("") userService.register()
4. 動態代理細節分析
-
Spring建立的動態代理類在哪裡？
Spring框架在執行時，通過動態位元組碼技術，在JVM建立的，執行在JVM內部，等程式結束後，會和JVM一起消失 什麼叫動態位元組碼技術:通過第三個動態位元組碼框架，在JVM中建立對應類的位元組碼，進而建立物件，當虛擬機器結束，動態位元組碼跟著消失。 結論：動態代理不需要定義類檔案，都是JVM執行過程中動態建立的，所以不會造成靜態代理，類檔案數量過多，影響專案管理的問題。-
動態代理程式設計簡化代理的開發
在額外功能不改變的前提下，建立其他目標類（原始類）的代理物件時，只需要指定原始(目標)物件即可。 -
動態代理額外功能的維護性大大增強
-
第三章、Spring動態代理詳解
1. 額外功能的詳解
-
MethodBeforeAdvice分析
1. MethodBeforeAdvice介面作用：額外功能執行在原始方法執行之前，進行額外功能操作。 public class Before1 implements MethodBeforeAdvice { /* 作用：需要把執行在原始方法執行之前執行的額外功能，書寫在before方法中 Method: 額外功能所增加給的那個原始方法 login方法 register方法 showOrder方法 Object[]: 額外功能所增加給的那個原始方法的引數。String name,String password User Object: 額外功能所增加給的那個原始物件 UserServiceImpl OrderServiceImpl */ @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println("-----new method before advice log------"); } } 2. before方法的3個引數在實戰中，該如何使用。 before方法的引數，在實戰中，會根據需要進行使用，不一定都會用到，也有可能都不用。 Servlet{ service(HttpRequest request,HttpResponse response){ request.getParameter("name") --> response.getWriter() ---> } } -
MethodInterceptor(方法攔截器)
methodinterceptor介面：額外功能可以根據需要執行在原始方法執行 前、後、前後。public class Arround implements MethodInterceptor { /* invoke方法的作用:額外功能書寫在invoke 額外功能 原始方法之前 原始方法之後 原始方法執行之前 之後 確定：原始方法怎麼執行 引數：MethodInvocation （Method):額外功能所增加給的那個原始方法 login register invocation.proceed() ---> login執行 register執行 返回值：Object: 原始方法的返回值 Date convert(String name) */ @Override public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println("-----額外功能 log----"); Object ret = invocation.proceed(); return ret; } }額外功能執行在原始方法執行之後
@Override public Object invoke(MethodInvocation invocation) throws Throwable { Object ret = invocation.proceed(); System.out.println("-----額外功能執行在原始方法執行之後----"); return ret; }額外功能執行在原始方法執行之前，之後
什麼樣的額外功能 執行在原始方法執行之前，之後都要新增？ 事務 @Override public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println("-----額外功能執行在原始方法執行之前----"); Object ret = invocation.proceed(); System.out.println("-----額外功能執行在原始方法執行之後----"); return ret; }額外功能執行在原始方法丟擲異常的時候
@Override public Object invoke(MethodInvocation invocation) throws Throwable { Object ret = null; try { ret = invocation.proceed(); } catch (Throwable throwable) { System.out.println("-----原始方法丟擲異常 執行的額外功能 ---- "); throwable.printStackTrace(); } return ret; }MethodInterceptor影響原始方法的返回值
原始方法的返回值，直接作為invoke方法的返回值返回，MethodInterceptor不會影響原始方法的返回值 MethodInterceptor影響原始方法的返回值 Invoke方法的返回值，不要直接返回原始方法的執行結果即可。 @Override public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println("------log-----"); Object ret = invocation.proceed(); return false; }
2. 切入點詳解
切入點決定額外功能加入位置(方法)
<aop:pointcut id="pc" expression="execution(* *(..))"/>
exection(* *(..)) ---> 匹配了所有方法 a b c
1. execution() 切入點函式
2. * *(..) 切入點表示式
2.1 切入點表示式
-
方法切入點表示式
* *(..) --> 所有方法 * ---> 修飾符 返回值 * ---> 方法名 ()---> 引數表 ..---> 對於引數沒有要求 (引數有沒有，引數有幾個都行，引數是什麼型別的都行)-
定義login方法作為切入點
* login(..) # 定義register作為切入點 * register(..) -
定義login方法且login方法有兩個字串型別的引數 作為切入點
* login(String,String) #注意：非java.lang包中的型別，必須要寫全限定名 * register(com.baizhiedu.proxy.User) # ..可以和具體的引數型別連用 * login(String,..) --> login(String),login(String,String),login(String,com.baizhiedu.proxy.User) -
精準方法切入點限定
修飾符 返回值 包.類.方法(引數) * com.baizhiedu.proxy.UserServiceImpl.login(..) * com.baizhiedu.proxy.UserServiceImpl.login(String,String)
-
-
類切入點
指定特定類作為切入點(額外功能加入的位置)，自然這個類中的所有方法，都會加上對應的額外功能-
語法1
#類中的所有方法加入了額外功能 * com.baizhiedu.proxy.UserServiceImpl.*(..) -
語法2
#忽略包 1. 類只存在一級包 com.UserServiceImpl * *.UserServiceImpl.*(..) 2. 類存在多級包 com.baizhiedu.proxy.UserServiceImpl * *..UserServiceImpl.*(..)
-
-
包切入點表示式 實戰
指定包作為額外功能加入的位置，自然包中的所有類及其方法都會加入額外的功能-
語法1
#切入點包中的所有類，必須在proxy中，不能在proxy包的子包中 * com.baizhiedu.proxy.*.*(..) -
語法2
#切入點當前包及其子包都生效 * com.baizhiedu.proxy..*.*(..)
-
2.2 切入點函式
切入點函式：用於執行切入點表示式
-
execution
最為重要的切入點函式，功能最全。 執行 方法切入點表示式 類切入點表示式 包切入點表示式 弊端：execution執行切入點表示式 ，書寫麻煩 execution(* com.baizhiedu.proxy..*.*(..)) 注意：其他的切入點函式 簡化是execution書寫複雜度，功能上完全一致 -
args
作用：主要用於函式(方法) 引數的匹配 切入點：方法引數必須得是2個字串型別的引數 execution(* *(String,String)) args(String,String) -
within
作用：主要用於進行類、包切入點表示式的匹配 切入點：UserServiceImpl這個類 execution(* *..UserServiceImpl.*(..)) within(*..UserServiceImpl) execution(* com.baizhiedu.proxy..*.*(..)) within(com.baizhiedu.proxy..*)
4.@annotation
作用：為具有特殊註解的方法加入額外功能
<aop:pointcut id="" expression="@annotation(com.baizhiedu.Log)"/>
-
切入點函式的邏輯運算
指的是 整合多個切入點函式一起配合工作，進而完成更為複雜的需求-
and與操作
案例：login 同時 引數 2個字串 1. execution(* login(String,String)) 2. execution(* login(..)) and args(String,String) 注意：與操作不同用於同種型別的切入點函式 案例：register方法 和 login方法作為切入點 execution(* login(..)) or execution(* register(..)) -
or或操作
案例：register方法 和 login方法作為切入點 execution(* login(..)) or execution(* register(..))
-
第四章、AOP程式設計
1. AOP概念
AOP (Aspect Oriented Programing) 面向切面程式設計 = Spring動態代理開發
以切面為基本單位的程式開發，通過切面間的彼此協同，相互呼叫，完成程式的構建
切面 = 切入點 + 額外功能
OOP (Object Oritened Programing) 面向物件程式設計 Java
以物件為基本單位的程式開發，通過物件間的彼此協同，相互呼叫，完成程式的構建
POP (Producer Oriented Programing) 面向過程(方法、函式)程式設計 C
以過程為基本單位的程式開發，通過過程間的彼此協同，相互呼叫，完成程式的構建
AOP的概念：
本質就是Spring得動態代理開發，通過代理類為原始類增加額外功能。
好處：利於原始類的維護
注意：AOP程式設計不可能取代OOP，OOP程式設計有意補充。
2. AOP程式設計的開發步驟
1. 原始物件
2. 額外功能 (MethodInterceptor)
3. 切入點
4. 組裝切面 (額外功能+切入點)
3. 切面的名詞解釋
切面 = 切入點 + 額外功能
幾何學
面 = 點 + 相同的性質
第五章、AOP的底層實現原理
1. 核心問題
1. AOP如何建立動態代理類(動態位元組碼技術)
2. Spring工廠如何加工建立代理物件
通過原始物件的id值，獲得的是代理物件
2. 動態代理類的建立
2.1 JDK的動態代理
- Proxy.newProxyInstance方法引數詳解
-
編碼
public class TestJDKProxy { /* 1. 借用類載入器 TestJDKProxy UserServiceImpl 2. JDK8.x前 final UserService userService = new UserServiceImpl(); */ public static void main(String[] args) { //1 建立原始物件 UserService userService = new UserServiceImpl(); //2 JDK建立動態代理 /* */ InvocationHandler handler = new InvocationHandler(){ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("------proxy log --------"); //原始方法執行 Object ret = method.invoke(userService, args); return ret; } }; UserService userServiceProxy = (UserService)Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(),userService.getClass().getInterfaces(),handler); userServiceProxy.login("suns", "123456"); userServiceProxy.register(new User()); } }
2.2 CGlib的動態代理
CGlib建立動態代理的原理：父子繼承關係建立代理物件，原始類作為父類，代理類作為子類，這樣既可以保證2者方法一致，同時在代理類中提供新的實現(額外功能+原始方法)
-
CGlib編碼
package com.baizhiedu.cglib; import com.baizhiedu.proxy.User; import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class TestCglib { public static void main(String[] args) { //1 建立原始物件 UserService userService = new UserService(); /* 2 通過cglib方式建立動態代理物件 Proxy.newProxyInstance(classloader,interface,invocationhandler) Enhancer.setClassLoader() Enhancer.setSuperClass() Enhancer.setCallback(); ---> MethodInterceptor(cglib) Enhancer.create() ---> 代理 */ Enhancer enhancer = new Enhancer(); enhancer.setClassLoader(TestCglib.class.getClassLoader()); enhancer.setSuperclass(userService.getClass()); MethodInterceptor interceptor = new MethodInterceptor() { //等同於 InvocationHandler --- invoke @Override public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("---cglib log----"); Object ret = method.invoke(userService, args); return ret; } }; enhancer.setCallback(interceptor); UserService userServiceProxy = (UserService) enhancer.create(); userServiceProxy.login("suns", "123345"); userServiceProxy.register(new User()); } } -
總結
1. JDK動態代理 Proxy.newProxyInstance() 通過介面建立代理的實現類 2. Cglib動態代理 Enhancer 通過繼承父類建立的代理類
3. Spring工廠如何加工原始物件
-
思路分析
-
編碼
public class ProxyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override /* Proxy.newProxyInstance(); */ public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { InvocationHandler handler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("----- new Log-----"); Object ret = method.invoke(bean, args); return ret; } }; return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(),bean.getClass().getInterfaces(),handler); } }<bean id="userService" class="com.baizhiedu.factory.UserServiceImpl"/> <!--1. 實現BeanPostProcessor 進行加工 2. 配置檔案中對BeanPostProcessor進行配置 --> <bean id="proxyBeanPostProcessor" class="com.baizhiedu.factory.ProxyBeanPostProcessor"/>
第六章、基於註解的AOP程式設計
1. 基於註解的AOP程式設計的開發步驟
-
原始物件
-
額外功能
-
切入點
-
組裝切面
# 通過切面類 定義了 額外功能 @Around 定義了 切入點 @Around("execution(* login(..))") @Aspect 切面類 package com.baizhiedu.aspect; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; /* 1. 額外功能 public class MyArround implements MethodInterceptor{ public Object invoke(MethodInvocation invocation){ Object ret = invocation.proceed(); return ret; } } 2. 切入點 <aop:config <aop:pointcut id="" expression="execution(* login(..))"/> */ @Aspect public class MyAspect { @Around("execution(* login(..))") public Object arround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect log ------"); Object ret = joinPoint.proceed(); return ret; } }<bean id="userService" class="com.baizhiedu.aspect.UserServiceImpl"/> <!-- 切面 1. 額外功能 2. 切入點 3. 組裝切面 --> <bean id="arround" class="com.baizhiedu.aspect.MyAspect"/> <!--告知Spring基於註解進行AOP程式設計--> <aop:aspectj-autoproxy />
2. 細節
-
切入點複用
切入點複用：在切面類中定義一個函式 上面@Pointcut註解 通過這種方式，定義切入點表示式，後續更加有利於切入點複用。 @Aspect public class MyAspect { @Pointcut("execution(* login(..))") public void myPointcut(){} @Around(value="myPointcut()") public Object arround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect log ------"); Object ret = joinPoint.proceed(); return ret; } @Around(value="myPointcut()") public Object arround1(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect tx ------"); Object ret = joinPoint.proceed(); return ret; } } -
動態代理的建立方式
AOP底層實現 2種代理建立方式
1. JDK 通過實現介面 做新的實現類方式 建立代理物件
2. Cglib通過繼承父類 做新的子類 建立代理物件
預設情況 AOP程式設計 底層應用JDK動態代理建立方式
如果切換Cglib
1. 基於註解AOP開發
<aop:aspectj-autoproxy proxy-target-class="true" />
2. 傳統的AOP開發
<aop:config proxy-target-class="true">
</aop>
第七章、AOP開發中的一個坑
坑：在同一個業務類中，進行業務方法間的相互呼叫，只有最外層的方法,才是加入了額外功能(內部的方法，通過普通的方式呼叫，都呼叫的是原始方法)。如果想讓內層的方法也呼叫代理物件的方法，就要AppicationContextAware獲得工廠，進而獲得代理物件。
public class UserServiceImpl implements UserService, ApplicationContextAware {
private ApplicationContext ctx;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.ctx = applicationContext;
}
@Log
@Override
public void register(User user) {
System.out.println("UserServiceImpl.register 業務運算 + DAO ");
//throw new RuntimeException("測試異常");
//呼叫的是原始物件的login方法 ---> 核心功能
/*
設計目的：代理物件的login方法 ---> 額外功能+核心功能
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
UserService userService = (UserService) ctx.getBean("userService");
userService.login();
Spring工廠重量級資源 一個應用中 應該只建立一個工廠
*/
UserService userService = (UserService) ctx.getBean("userService");
userService.login("suns", "123456");
}
@Override
public boolean login(String name, String password) {
System.out.println("UserServiceImpl.login");
return true;
}
}