前面我們看過javaassit是如何破解java應用，核心都是AOP相關的知識，今天我們看下Spring AOP是怎么回事！

Spring-AOP

spring 5.x版本

AOP面向切面編程，通過預編譯方式和運行期間動態(tài)代理實現(xiàn)程序功能的統(tǒng)一維護的一種技術。AOP是OOP的延續(xù)，從另一視角擴展了對面向?qū)ο缶幊痰男问健＠肁OP可以對業(yè)務邏輯的各個部分進行隔離，從而使得業(yè)務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發(fā)的效率。

Spring AOP與IOC作為整個Spring框架最為核心的兩個部分，其意義不言而喻。在Spring中，我們都是面向Bean的裝配與管理，一個Bean是一個對象，也可以是一個代理。

概念

Aspect（切面）：Aspect聲明類似于Java中的類聲明，在Aspect中會包含著一些Pointcut以及相應的 Advice。

JointPoint（連接點）：表示在程序中明確定義的點，典型的包括方法調(diào)用，對類成員的訪問以及異常處理程序塊的執(zhí)行等等，它自身還可以嵌套其它joint point。

Pointcut（切點）：按規(guī)則匹配的JointPoint，這些JointPoint或是通過邏輯關系組合起來，或是通過通配、正則表達式等方式集中起來，它定義了相應的Advice執(zhí)行的具體地方。

Advice（通知）：Advice定義了在Pointcut里面定義的程序點具體要做的操作，它通過before、after和around來區(qū)別是在每個JointPoint之前、之后還是代替執(zhí)行的代碼。

Target（目標對象）：將Advice織入到目標對象.。

Weaving（織入）：將Aspect和其他對象連接起來, 并創(chuàng)建增強（代理）對象的過程

下面從幾個方面了解Spring中如何使用AOP，你會發(fā)現(xiàn)，所有的配置都是圍繞著這些概念。Spring提供了AOP代理的上下文環(huán)境，而對目標對象的加強（Aspect、Advisor）都是由開發(fā)者自己完成。

Spring-aop.xml

1. 基于aspect配置AOP，一個Aspect包含Pointcut與Advice：

< beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd" >
    < !-- 業(yè)務類 -- >
    < bean id="queryService" class="com.sucl.blog.springaop.service.QueryService"/ >
    < !-- 定義Aspect，aop:method 的來源  -- >
    < bean id="logAspect" class="com.sucl.blog.springaop.aspect.LogAspect"/ >
    
    < !-- 基于Aspect-- >
    < aop:config >
        < aop:aspect ref="logAspect" >
            < aop:pointcut id="pointcut" expression="execution(* com.sucl.blog.springaop.service..*(..))"/ >

            < aop:before method="before" pointcut-ref="pointcut"/ >
            < aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/ >
            < aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/ >
            < aop:after method="after" pointcut-ref="pointcut"/ >
            < aop:around method="around" pointcut-ref="pointcut"/ >
        < /aop:aspect >
    < /aop:config >
< /beans >

1. 基于advice配置AOP，這種方式更方便Advice的復用

< beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd" >

    < bean id="queryService" class="com.sucl.blog.springaop.service.QueryService"/ >
    < bean id="logAdvice" class="com.sucl.blog.springaop.advice.LogAdvice"/ >

    < !-- 基于Advisor -- >
    < aop:config >
        < aop:pointcut id="pointcut" expression="execution(* com.sucl.blog.springaop.service..*(..))"/ >
        < aop:advisor advice-ref="logAdvice" pointcut-ref="pointcut"/ >
    < /aop:config >
< /beans >

@Aspect注解

基于注解@Aspect定義切面來增強目標對象，與上面的XML第一種配置對應，記得使用@EnableAspectJAutoProxy注解開啟

@Slf4j
@Aspect
public class LogAspect {

    @Pointcut("execution(* com.sucl.blog.springaop.service..*(..))")
    public void pointcut(){}

    /**
     * 方法執(zhí)行前執(zhí)行
     * @param joinPoint
     * @param arg1
     */
    @Before(value = "pointcut()")
    public void before(JoinPoint joinPoint){
        log.info(" >> > 執(zhí)行 before");
    }

    /**
     * 方法出現(xiàn)異常時執(zhí)行
     * @param joinPoint
     */
    @AfterThrowing(value = "pointcut()", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        log.info(" >> > 執(zhí)行 afterThrowing: {}", e.getMessage());
    }

    /**
     * 方法返回后執(zhí)行，異常時不執(zhí)行
     * @param joinPoint
     */
    @AfterReturning(value = "pointcut()", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result){
        log.info(" >> > 執(zhí)行 afterReturning: {}" ,result);
    }

    /**
     * 方法執(zhí)行完執(zhí)行，不管是否發(fā)生異常
     * @param joinPoint
     */
    @After(value = "pointcut()")
    public void after(JoinPoint joinPoint){
        log.info(" >> > 執(zhí)行 after");
    }

    /**
     * 在after與 around 前后執(zhí)行
     * @param pjp
     * @param jp
     */
    @Around(value = "pointcut()")
    public void around(ProceedingJoinPoint pjp){
        try {
            log.info(" >> > 執(zhí)行 around starting");
            pjp.proceed();
            log.info(" >> > 執(zhí)行 around finished");
        } catch (Throwable e) {
            log.info(" >> > 執(zhí)行 around 異常：{}", e.getMessage());
        }
    }
}

AOP代理執(zhí)行順序

spring 5.2.7之后的執(zhí)行順序：

Pointcut表達式（AspectJ）

execution：用于匹配方法執(zhí)行的連接點

within：用于匹配指定類型內(nèi)的方法執(zhí)行

this：用于匹配當前AOP代理對象類型的執(zhí)行方法；注意是AOP代理對象的類型匹配，這樣就可能包括引入接口也類型匹配

target：用于匹配當前目標對象類型的執(zhí)行方法；注意是目標對象的類型匹配，這樣就不包括引入接口也類型匹配

args：用于匹配當前執(zhí)行的方法傳入的參數(shù)為指定類型的執(zhí)行方法

@within：用于匹配所以持有指定注解類型內(nèi)的方法

@target：用于匹配當前目標對象類型的執(zhí)行方法，其中目標對象持有指定的注解

@args：用于匹配當前執(zhí)行的方法傳入的參數(shù)持有指定注解的執(zhí)行

@annotation：用于匹配當前執(zhí)行方法持有指定注解的方法

bean：Spring AOP擴展的，AspectJ沒有對于指示符，用于匹配特定名稱的Bean對象的執(zhí)行方法

基于@Configuration

通過ProxyFactoryBean我們可以生成基于目標對象的代理。通過下面幾行代碼，加上自定義的切面實現(xiàn)（MethodInterceptor、Advice等接口的實現(xiàn)），就可以實現(xiàn)上面的before、after、around等通知切面。

@Configuration
public class ProxyConfiguration {

    @Bean
    public ProxyFactoryBean printServiceProxy() {
        ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
        proxyFactoryBean.setTarget(new PrintService());
        proxyFactoryBean.setProxyTargetClass(true);
        addInterceptors(proxyFactoryBean);
        return proxyFactoryBean;
    }

    /**
     * 定義方法攔截器：（支持通配符）
     * org.springframework.aop.Advisor
     * org.aopalliance.intercept.Interceptor
     *
     * MethodBeforeAdvice
     * AfterReturningAdvice
     * ThrowsAdvice
     *
     * org.aopalliance.intercept.MethodInterceptor
     * org.aopalliance.aop.Advice
     *
     * @param proxyFactoryBean
     */
    private void addInterceptors(ProxyFactoryBean proxyFactoryBean) {
        proxyFactoryBean.setInterceptorNames("logAdvice");
    }

    @Bean
    public LogAdvice logAdvice() {
        return new LogAdvice();
    }
}

@Slf4j
public class LogAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        try {
            log.info(" >> > before");
            Object result = invocation.proceed();
            log.info(" >> > afterReturning : {}", result);
            return result;
        } catch (Throwable e) {
            log.info(" >> > afterThrowing : {}", e.getMessage());
            throw e;
        } finally {
            log.info(" >> > after");
        }
    }
}

實現(xiàn)原理

這里說到的是上面第二種通過@Aspect的形式實現(xiàn)AOP功能，這種模式更適合業(yè)務模塊中對特定模塊內(nèi)的方法進行業(yè)務代理。我們需要依賴注解 EnableAspectJAutoProxy , 下面來看看具體如何實現(xiàn)？

1. 在EnableAspectJAutoProxy中可以看到@Import(AspectJAutoProxyRegistrar.class)，如果你之前看過之前的spring boot start你就知道，這里是基于ImportBeanDefinitionRegistrar在Spring容器中注冊BeanDefinition。
2. 可以看到AspectJAutoProxyRegistrar#registerBeanDefinitions第一行，AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)， 主要是注冊了BeanPostProcessor（AnnotationAwareAspectJAutoProxyCreator）。
3. 我們知道在Spring Bean生命中期中，Bean執(zhí)行初始化前后會執(zhí)行容器中的nPostProcessor，Spring AOP即通過AnnotationAwareAspectJAutoProxyCreator這個BeanPostProcessor完成Bean的代理工作。
4. 其父類AbstractAutoProxyCreator中，postProcessAfterInitialization -> wrapIfNecessary -> createProxy -> ProxyFactory -> getProxy 到這里，Bean的代理對象也就生成了， 當然省略了各種判斷以及加工過程。

代理方式

• Cglib和JDK Proxy
  Spring AOP主要是通過這兩個代理框架來實現(xiàn)代理的。一般情況下，基于接口代理時使用JDK動態(tài)代理，否則使用Cglib.
  • Java動態(tài)代理只能夠?qū)涌谶M行代理，不能對普通的類進行代理(因為所有生成的代理類的父類為Proxy，Java類繼承機制不允許多重繼承)。而CGLIB能夠代理普通類
  • Java動態(tài)代理使用Java原生的反射API進行操作，在生成類上比較高效；CGLIB使用ASM框架直接對字節(jié)碼進行操作，在類的執(zhí)行過程中比較高效
• AspectJ
  AspectJ是一個功能強大的面相切面編程框架，是對Java面向?qū)ο蟮臄U展，支持編譯時、編譯后、加載時為目標對象（不僅僅是類方法）織入代理。在Spring AOP中引入了aspectjweaver.jar，僅僅使用了其注解。

下面是網(wǎng)上Spring AOP與AspectJ的比對

結束語

Spring AOP是整個Spring框架的核心，里面涉及到的內(nèi)容不是很多，但是都比較有深度，在spring諸多模塊中，比如事務、緩存、鑒權等等方面都有使用到。由于springboot的出現(xiàn)，xml的配置形式使用 得比較少了，但是這種配置的形式更直白地體現(xiàn)了AOP需要的配置以及各個組件的依賴關系。而基于@Aspect的形式代理業(yè)務模塊中的方法更簡單直觀，而基于ProxyFactoryBean、ProxyFactory的方式，在編寫類似 cache的模塊會更加的靈活。