SpringBoot中創建的AOP不生效的原因及解決

Posted on by

SpringBoot 創建AOP不生效的原因

最近在學習SpringBoot，今天學習瞭Aop的註冊方式，原理很簡單，配置也很簡單，但是我註冊瞭切面之後切面一直不生效，是為什麼呢？查瞭好久的資料終於發現瞭原因，可以看下圖我的切面註冊類並沒有問題

然後在網上偶然看到可能是主程序掃描的原因，才發現瞭原因，可以看到我的顯示方式本來是flat的，那樣的話就很難找出原因瞭

修改為hirerchical就可以很清楚的看出問題

可以看出，我的主程序和切面類並不在一個包中，那麼主程序掃描不到切面類，自然就不會註冊切面瞭，最簡單的解決方式就是在主程序中添加一個註解@ComponentScan

那麼我們就能對springboot有更深入的認識，其實他相對於ssm所有的簡化步驟關鍵在於主程序，他起到瞭一個封裝加載的步驟，不主動聲明的情況下他會掃描和自己在同一個包下面的所有類，並根據註解自動註冊，那麼以後寫項目時最好的方式就是將主程序放在主包下，然後所有的這些類都放在子包中即可

SpringBoot aop無效的情況

項目結構

在這裡插入圖片描述

package com.example.demo.inter;
public interface CustomerService {
     void doSomething1();
     void doSomething2();
}
package com.example.demo.inter;
import org.springframework.aop.framework.AopContext;
import org.springframework.stereotype.Service;
@Service
public class CustomerServiceImpl implements CustomerService {
    @Override
    public void doSomething1() {
        System.out.println("CustomerServiceImpl.doSomething1()");
        doSomething2();
        ((CustomerService) AopContext.currentProxy()).doSomething2();
    }
    @Override
    public void doSomething2() {
        System.out.println("CustomerServiceImpl.doSomething2()");
    }
}

package com.example.demo;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class CustomerServiceInterceptor {
    @Before("execution(* com.example.demo.inter..*.*(..))")
    public void doBefore() {
        System.out.println("do some important things before...");
    }
}
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@EnableAspectJAutoProxy(proxyTargetClass=true, exposeProxy=true)
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

package com.example.demo;
import com.example.demo.inter.CustomerService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class DemoApplicationTests {
    @Autowired
    CustomerService customerService;
    @Test
    public void testAOP() {
        customerService.doSomething1();
    }
    @Test
    void contextLoads() {
    }
}

運行下testAOP，為啥doSomething2()沒有切面效果，使用AopContext.currentProxy就可以瞭？

攔截器的實現原理就是動態代理，實現AOP機制。Spring 的代理實現有兩種：一是基於 JDK Dynamic Proxy 技術而實現的；二是基於 CGLIB 技術而實現的。如果目標對象實現瞭接口，在默認情況下Spring會采用JDK的動態代理實現AOP，CustomerServerImpl正是這種情況。

JDK動態代理生成的CustomerServiceImpl的代理類翻譯過來如下：

package com.example.demo;
import com.example.demo.inter.CustomerService;
public class CustomerServiceProxy implements CustomerService {
    private CustomerService customerService;
    public void setCustomerService(CustomerService customerService) {
        this.customerService = customerService;
    }
    public void doSomething1() {
        doBefore();
        customerService.doSomething1();
        // 默認，所以不會執行doBefore
        customerService.doSomething2();
        // 加入 AopContext.currentProxy的效果，完成切面效果
        this.doSomething2();
    }
    public void doSomething2() {
        doBefore();
        customerService.doSomething2();
    }
    private void doBefore() {
        System.out.println("do some important things before...");
    }
}

這樣很直觀地明白為啥要使用AopContext.currentProxy瞭。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。

推薦閱讀：