一、約定編程
Spring AOP是一種約定流程的編程，咱們可以先通過動態代理模式的實作來理解Spring AOP的概念，
代理的邏輯很簡單，例如，當你需要采訪一名兒童時，首先需要經過他父母的同意，在一些問題上父母也許會替他回答，而對于另一些問題，也許父母覺得不太適合這個小孩會拒絕掉，顯然這時父母就是這名兒童的代理（proxy）了，通過代理可以增強或者控制對兒童這個真實物件（target）的訪問，
1. 首先實作攔截器介面Interceptor（自己定義的介面）
下面代碼均使用spring boot 2.6.2
package com.springboot.chapter4.intercept; import java.lang.reflect.InvocationTargetException; import com.springboot.chapter4.invoke.Invocation; public class MyInterceptor implements Interceptor { @Override public boolean before() { System.out.println("before ......"); return true; } @Override public boolean useAround() { return true; } @Override public void after() { System.out.println("after ......"); } @Override public Object around(Invocation invocation) throws InvocationTargetException, IllegalAccessException { System.out.println("around before ......"); Object obj = invocation.proceed(); System.out.println("around after ......"); return obj; } @Override public void afterReturning() { System.out.println("afterReturning......"); } @Override public void afterThrowing() { System.out.println("afterThrowing......"); } }
2 創建代理物件
在Java的JDK中，提供了類Proxy的靜態方法——newProxyInstance，給予我們來生成一個代理物件（proxy）：
public static Object newProxyInstance(ClassLoader classLoader, Class<?>[] interfaces,
InvocationHandler invocationHandler) throws IllegalArgumentException
它有3個引數：
?classLoader——類加載器；（被代理的類）
?interfaces——系結的介面，也就是把代理物件系結到哪些介面下，可以是多個；（被代理的類實作的介面串列）
?invocationHandler ——系結代理物件邏輯實作，
這里的invocationHandler是一個介面InvocationHandler物件，它定義了一個invoke方法，這個方法就是實作代理物件的約定流程
package com.springboot.chapter4.proxy;
package com.springboot.chapter4.proxy;
/**** imports ****/
public class ProxyBean implements InvocationHandler {
private Object target = null;//代理物件
private Interceptor interceptor = null;//攔截器
public ProxyBean (Object target,Interceptor interceptor){
this.target=target;
this.interceptor=interceptor;
}
/**
* 處理代理物件方法邏輯
* @param proxy 代理物件
* @param method 當前方法
* @param args 運行引數
* @return 方法呼叫結果
* @throws Throwable 例外
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
// 例外標識
boolean exceptionFlag = false;
Invocation invocation = new Invocation(target, method, args);
Object retObj = null;
try {
if (this.interceptor.before()) {
retObj = this.interceptor.around(invocation);
} else {
retObj = method.invoke(target, args);
}
} catch (Exception ex) {
// 產生例外
exceptionFlag = true;
}
this.interceptor.after();
if (exceptionFlag) {
this.interceptor.afterThrowing();
} else {
this.interceptor.afterReturning();
return retObj;
}
return null;
}
}
從上面例子可以看到：代理物件proxyBean定義了織入流程即invoke方法，將攔截器MyInterceptor包裝到目標物件tagert的method上，
3. 測驗效果
/** * 系結代理物件 * @param target 被代理物件 * @param interceptor 攔截器 * @return 代理物件 */ public static Object getProxyObject(Object target, Interceptor interceptor) { ProxyBean proxyBean = new ProxyBean(target,interceptor);//proxyBean定義了織入流程即invoke方法 // 生成代理物件 Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(), target.getClass().getInterfaces(), proxyBean);//proxyBean實作target物件的介面串列，實作方式為呼叫代理物件的方法時通過invoke（invoke可呼叫target物件的方法）呼叫target物件對應的方法， // 回傳代理物件 return proxy; }
private static void testProxy() { IHelloService helloService = new HelloServiceImpl();//被代理物件 // 按約定獲取proxy IHelloService proxy = (IHelloService) getProxyObject( helloService, new MyInterceptor()); proxy.sayHello("zhangsan"); System.out.println("\n###############name is null!!#############\n"); proxy.sayHello(null); }
二、Spring AOP概念和術語
Spring AOP是一種基于方法的AOP，它只能應用于方法上，在Spring中可以使用多種方式配置AOP，因為Spring Boot采用注解方式，所以這里只介紹使用@AspectJ注解的方式，AOP可以減少大量重復的作業，最為典型的應用場景就是資料庫事務的管控，比如資料庫的打開和關閉以及事務的提交和回滾都有流程默認給你實作，換句話說，你都不需要完成它們，你需要完成的任務是撰寫SQL這一步而已，然后織入流程中，
@Autowired private UserDao = null; ...... @Transactional public int inserUser(User user) { return userDao.insertUser(user); }
這里可以看到僅僅使用了一個注解@Transactional，表明該方法需要事務運行，沒有任何資料庫打開和關閉的代碼，也沒有事務回滾和提交的代碼，卻實作了資料庫資源的打開和關閉、事務的回滾和提交，
1.AOP術語：
?連接點（join point）：對應的是具體被攔截的物件，因為Spring只能支持方法，所以被攔截的物件往往就是指特定的方法，例如，我們前面提到的HelloServiceImpl的sayHello方法就是一個連接點，AOP將通過動態代理技術把它織入對應的流程中，
?切點（point cut）：有時候，我們的切面不單單應用于單個方法，也可能是多個類的不同方法，這時，可以通過正則式和指示器的規則去定義，從而適配連接點，切點就是提供這樣一個功能的概念，
?通知（advice）：就是按照約定的流程下的方法，分為前置通知（beforeadvice）、后置通知（after advice）、環繞通知（around advice）、事后回傳通知（afterReturning advice）和例外通知（afterThrowing advice），它會根據約定織入流程中，需要弄明白它們在流程中的順序和運行的條件，
?目標物件（target）：即被代理物件，例如，約定編程中的HelloServiceImpl實體就是一個目標物件，它被代理了，
?引入（introduction）：是指引入新的類和其方法，增強現有Bean的功能，
?織入（weaving）：它是一個通過動態代理技術，為原有服務物件生成代理物件，然后將與切點定義匹配的連接點攔截，并按約定將各類通知織入約定流程的程序，
?切面（aspect）：是一個可以定義切點、各類通知和引入的內容，Spring AOP將通過它的資訊來增強Bean的功能或者將對應的方法織入流程，
2.具體實作
2.1.添加maven依賴
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>
2.2. 定義切面
首先Spring是以@Aspect作為切面宣告的，當以@Aspect作為注解時，Spring就會知道這是一個切面，然后我們就可以通過各類注解（@Before、@After、@AfterReturning和@AfterThrowing）來定義各類的通知了，
package com.springboot.chapter4.aspect; /**** imports ****/
@Component //注入到Spring IOC @Aspect //定義切面 public class MyAspect { //引入 @DeclareParents(value= "https://www.cnblogs.com/ImBit/p/co.springboot.chapter4.aspect.service.impl.UserServiceImpl",defaultImpl=UserValidatorImpl.class) public UserValidator userValidator; //定義切點 @Pointcut("execution(* com.springboot.chapter4.aspect.service.impl.UserServiceImpl.printUser(..))") public void pointCut() { }
//無參模式 @Before("pointCut()") public void before() { System.out.println("before ......"); } //獲取引數模式 //方式1：切點處加入對應的正則式 //方式2：對于非環繞通知還可以使用一個連接點（JoinPoint）型別的引數，通過它也可以獲取引數 //正則式pointCut() && args(user)中，pointCut()表示啟用原來定義切點的規則，并且約定將連接點（目標物件方法）名稱為user的引數傳遞進來，這里要注意，JoinPoint型別的引數對于非環繞通知而言，Spring AOP會自動地把它傳遞到通知中；對于環繞通知而言，可以使用ProceedingJoinPoint型別的引數， @Before("pointCut() && args(user)") public void beforeParam(JoinPoint point, User user) { Object[] args = point.getArgs(); System.out.println("before ......"); } //環繞通知 //注意：用環繞通知注解測驗的時候總是不按順序執行，估計是Spring版本之間的差異留下的問題，這是在使用時需要注意的，所以在沒有必要的時候，應盡量不要使用環繞通知，它很強大，但是也很危險， @Around("pointCut()") public void around(ProceedingJoinPoint jp) throws Throwable { System.out.println("around before......"); jp.proceed();//回呼目標物件的原有方法 System.out.println("around after......"); } @After("pointCut()") public void after() { System.out.println("after ......"); } @AfterReturning("pointCut()") public void afterReturning() { System.out.println("afterReturning ......"); } @AfterThrowing("pointCut()") public void afterThrowing() { System.out.println("afterThrowing ......"); } }
上述例子用到的基礎類如下
View Code
2.3 定義切點
execution(* com.springboot.chapter4.aspect.service.impl.UserServiceImpl.printUser(..))
?execution表示在執行的時候，攔截里面的正則匹配的方法；
?* 表示任意回傳型別的方法；
?com.springboot.chapter4.aspect.service.impl.UserServiceImpl 指定目標物件的全限定名稱；
?printUser指定目標物件的方法；
?(..)表示任意引數進行匹配，
2.4 使用@DeclareParents 定義引入
@DeclareParents，它的作用是在不侵入原有業務的前提上對原有的服務進行增強，它有兩個必須配置的屬性value和defaultImpl，
?value：指向你要增強功能的目標物件，這里是要增強UserServiceImpl物件，因此可以看到配置為com.springboot.chapter4.aspect.service.impl.UserServiceImpl+，
?defaultImpl：引入增強功能的類，這里配置為UserValidatorImpl，用來提供校驗用戶是否為空的功能，
2.5 使用切面的指示器
切面中可以使用的指示器如下，比如上述例子中arg()獲取切點的引數值
3.測驗效果
package com.springboot.chapter4.aspect.controller; /**** imports ****/ // 定義控制器 @Controller // 定義類請求路徑 @RequestMapping("/user") public class UserController { // 注入用戶服務 @Autowired private UserService userService = null; // 定義請求 @RequestMapping("/print") // 轉換為JSON @ResponseBody public User printUser(Long id, String userName, String note) { User user = new User(); user.setId(id); user.setUsername(userName); user.setNote(note); userService.printUser(user);// 若user=null，則執行afterthrowing方法 //測驗引入 UserValidator userValidator = (UserValidator)userService; if (userValidator.validate(user)) { userService.printUser(user); } return user;// 加入斷點 } }
3.1未引入效果
before ......
id =1 username =user_name_1 note =2323
after ......
afterReturning ......
3.2引入效果
引入新的介面：UserValidator
around before......
before ......
id =1 username =user_name_1 note =2323
around after......
after ......
afterReturning ......
3.4 引入原理
這里的newProxyInstance的第二個引數為一個物件陣列，也就是說這里生產代理物件時，Spring會把UserService和UserValidator兩個介面傳遞進去，讓代理物件下掛到這兩個介面下，這樣這個代理物件就能夠相互轉換并且使用它們的方法了，
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
proxyBean);
3.5 織入方式
上面我們都是采用介面（如UserService）+實作類（如UserServiceImpl）的模式，這是Spring推薦的方式，本書也遵循這樣的方式，但是對于是否擁有介面則不是Spring AOP的強制要求，對于動態代理的也有多種實作方式，我們之前談到的JDK只是其中的一種，業界比較流行的還有CGLIB、Javassist、ASM等，Spring采用了JDK和CGLIB，對于JDK而言，它是要求被代理的目標物件必須擁有介面，而對于CGLIB則不做要求，因此在默認的情況下，Spring會按照這樣的一條規則處理，即當你需要使用AOP的類擁有介面時，它會以JDK動態代理運行，否則以CGLIB運行，
不使用介面例子
...... // 定義控制器 @Controller // 定義類請求路徑 @RequestMapping("/user") public class UserController { // 使用非介面注入 @Autowired private UserServiceImpl userService = null; // 定義請求 @RequestMapping("/print") // 回傳JSON @ResponseBody public User printUser(Long id, String userName, String note) { User user = new User(); user.setId(id); user.setUsername(userName); user.setNote(note); userService.printUser(user); return user;// 加入斷點測驗 } ...... }
此時Spring已經使用了CGLIB為我們生成代理物件，從而將切面的內容織入對應的流程中，當使用介面時，用JDK為我們生成代理物件，
4. 多個切面
Spring提供了一個注解@Order和一個介面Ordered，我們可以使用它們的任意一個指定切面的順序，
...... @Aspect @Order(1) public class MyAspect1 { ...... } //或者 ...... @Aspect public class MyAspect1 implements Ordered { // 指定順序 @Override public int getOrder() { return 1; } .... }
效果如下
MyAspect1 before ......
MyAspect2 before ......
MyAspect3 before ......
測驗多個切面順序
MyAspect3 after ......
MyAspect3 afterReturning ......
MyAspect2 after ......
MyAspect2 afterReturning ......
MyAspect1 after ......
MyAspect1 afterReturning ......
核心技術(http://www.localyc.com)
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/458079.html
標籤：設計模式
下一篇：行為型：二. 模板方法模式