一、約定程式設計
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= "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 ...... 如果感覺小編寫得不錯，請素質三連：點贊+轉發+關注。我會努力寫出更好的作品分享給大家。
原文 https://www.cnblogs.com/ImBit/p/16100459.html