背景
首先請思考一下以下程式碼執行的結果：
- LogAop.java
//宣告一個AOP攔截service包下的所有方法
@Aspect
public class LogAop {
@Around("execution(* com.demo.service.*.*(..))")
public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
try {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
Method method = methodSignature.getMethod();
Object ret = joinPoint.proceed();
//執行完目標方法之後列印
System.out.println("after execute method:"+method.getName());
return ret;
} catch (Throwable throwable) {
throw throwable;
}
}
}- UserService.java
@Service
public class UserService{
public User save(User user){
//省略程式碼
}
public void sendEmail(User user){
//省略程式碼
}
//註冊
public void register(User user){
//儲存使用者
this.save(user);
//傳送郵件給使用者
this.sendEmail(user);
}
}- UserServiceTest.java
@SpringBootTest
public class UserServiceTest{
@Autowired
private UserService userService;
@Test
public void save(){
userService.save(new User());
}
@Test
public void sendEmail(){
userService.sendEmail(new User());
}
@Test
public void register(){
UserService.register(new User());
}
}在執行save方法後，控制檯輸出為：
after execute method:save在執行sendEmail方法後，控制檯輸出為：
after execute method:sendEmail請問在執行register()方法後會列印出什麼內容？
反直覺
這個時候可能很多人都會和我之前想的一樣，在register方法裡呼叫了save和sendEmail，那 AOP 會處理save和sendEmail，輸出：
after execute method:save
after execute method:sendEmail
after execute method:register然而事實並不是這樣的，而是輸出：
after execute method:register在這種認知的情況下，很可能就會寫出有bug的程式碼，例如：
@Service
public class UserService{
//使用者下單一個商品
public void order(User user,String orderId){
Order order = findOrder(orderId);
pay(user,order);
}
@Transactional
public void pay(User user,Order order){
//扣款
user.setMoney(user.getMoney()-order.getPrice());
save(user);
//...其它處理
}
}當使用者下單時呼叫的order方法，在該方法裡面呼叫了@Transactional註解修飾的pay方法，這個時候pay方法的事務管理已經不生效了，在發生異常時就會出現問題。
理解 AOP
我們知道 Spring AOP 預設是基於動態代理來實現的，那麼先化繁為簡，只要搞懂最基本的動態代理自然就明白之前的原因了，這裡直接以 JDK 動態代理為例來演示一下上面的情況。
由於 JDK 動態代理一定需要介面類，所以首先宣告一個IUserService介面
- IUserService.java
public interface IUserService{
User save(User user);
void sendEmail(User user);
User register(User user);
}編寫實現類
- UserService.java
public class UserService implements IUserService{
@Override
public User save(User user){
//省略程式碼
}
@Override
public void sendEmail(User user){
//省略程式碼
}
//註冊
@Override
public void register(User user){
//儲存使用者
this.save(user);
//傳送郵件給使用者
this.sendEmail(user);
}
}編寫日誌處理動態代理實現
- ServiceLogProxy.java
public static class ServiceLogProxy {
public static Object getProxy(Class<?> clazz, Object target) {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{clazz}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object ret = method.invoke(target, args);
System.out.println("after execute method:" + method.getName());
return ret;
}
});
}
}執行程式碼
- Main.java
public class Main{
public static void main(String[] args) {
//獲取代理類
IUserService userService = (IUserService) ServiceLogProxy.getProxy(IUserService.class, new UserService());
userService.save(new User());
userService.sendEmail(new User());
userService.register(new User());
}
}結果如下：
after execute method:save
after execute method:sendEmail
after execute method:register可以發現和之前 Spring AOP 的情況一樣，register方法中呼叫的save和sendEmail方法同樣的沒有被動態代理攔截到，這是為什麼呢，接下來就看看下動態代理的底層實現。
動態代理原理
其實動態代理就是在執行期間動態的生成了一個class在 jvm 中，然後通過這個class的例項呼叫真正的實現類的方法，虛擬碼如下：
public class $Proxy0 implements IUserService{
//這個類就是之前動態代理裡的new InvocationHandler(){}物件
private InvocationHandler h;
//從介面中拿到的register Method
private Method registerMethod;
@Override
public void register(User user){
//執行前面ServiceLogProxy編寫好的invoke方法，實現代理功能
h.invoke(this,registerMethod,new Object[]{user})
}
}回到剛剛的main方法，那個userService變數的例項型別其實就是動態生成的類，可以把它的 class 列印出來看看：
IUserService userService = (IUserService) ServiceLogProxy.getProxy(IUserService.class, new UserService());
System.out.println(userService.getClass());輸出結果為：
xxx.xxx.$Proxy0在瞭解這個原理之後，再接著解答之前的疑問，可以看到通過代理類的例項執行的方法才會進入到攔截處理中，而在InvocationHandler#invoke()方法中，是這樣執行目標方法的：
//注意這個target是new UserService()例項物件
Object ret = method.invoke(target, args);
System.out.println("after execute method:" + method.getName());在register方法中呼叫this.save和this.sendEmail方法時，this是指向本身new UserService()例項，所以本質上就是：
User user = new User();
UserService userService = new UserService();
userService.save(user);
userService.sendEmail(user);不是動態代理生成的類去執行目標方法，那必然不會進行動態代理的攔截處理中，明白這個之後原理之後，就可以改造下之前的方法，讓方法內呼叫本類方法也能使動態代理生效，就是用動態代理生成的類去呼叫方法就好了，改造如下：
- UserService.java
public class UserService implements IUserService{
//註冊
@Override
public void register(User user){
//獲取到代理類
IUserService self = (IUserService) ServiceLogProxy.getProxy(IUserService.class, this);
//通過代理類儲存使用者
self.save(user);
//通過代理類傳送郵件給使用者
self.sendEmail(user);
}
}執行main方法，結果如下：
after execute method:save
after execute method:sendEmail
after execute method:save
after execute method:sendEmail
after execute method:register可以看到已經達到預期效果了。
Spring AOP 中方法呼叫本類方法的解決方案
同樣的，只要使用代理類來執行目標方法就行，而不是用this引用，修改後如下：
@Service
public class UserService{
//拿到代理類
@Autowired
private UserService self;
//註冊
public void register(User user){
//通過代理類儲存使用者
self.save(user);
//通過代理類傳送郵件給使用者
self.sendEmail(user);
}
}好了，問題到此就解決了，但是需要注意的是Spring官方是不提倡這樣的做法的，官方提倡的是使用一個新的類來解決此類問題，例如建立一個UserRegisterService類：
@Service
public class UserRegisterService{
@Autowired
private UserService userService;
//註冊
public void register(User user){
//通過代理類儲存使用者
userService.save(user);
//通過代理類傳送郵件給使用者
userService.sendEmail(user);
}
}