Spring AOP原理解析

朴灿烈づ我的快乐病毒、 2022-03-15 15:50 244阅读 0赞

#  #

## 一.经典的基于代理的AOP ##

首先，我们来看看基于经典的AOP是如何实现的。

先写一个接口叫Sleepable，所有具有睡觉能力的东西都可以实现该接口。

package com.ghs.aop;
    
    public interface Sleepable {
        public void sleep();
    }

然后写一个Human类，他实现了这个接口。

package com.ghs.aop;
    
    public class Human implements Sleepable {
        @Override
        public void sleep() {
            System.out.println("正在睡觉！");
        }
    }

不过睡觉前后要做些辅助工作，最基本的是脱穿衣服，但是这些动作与纯粹的睡觉这一“业务逻辑”是不相干的，如果把  
这些代码全部加入到sleep方法中，是不是有违单一职责呢？，这时候我们就需要AOP了。  
编写一个SleepHelper类，它里面包含了睡觉的辅助工作,用AOP术语来说它就应该是通知了。

package com.ghs.aop;
    
    import java.lang.reflect.Method;
    
    import org.springframework.aop.AfterReturningAdvice;
    import org.springframework.aop.MethodBeforeAdvice;
    
    public class SleepHelper implements MethodBeforeAdvice,AfterReturningAdvice{
    
        @Override
        public void before(Method arg0, Object[] arg1, Object arg2)
                throws Throwable {
            System.out.println("睡觉前要脱衣服！");
        }
    
        @Override
        public void afterReturning(Object arg0, Method arg1, Object[] arg2,
                Object arg3) throws Throwable {
            System.out.println("起床后要穿衣服！");
        }
    }

配置切点、通知、Human对象的代理。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:tx="http://www.springframework.org/schema/tx" 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-3.0.xsd
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"
        default-autowire="byName">
    
        
        <bean id="sleepHelper" class="com.ghs.aop.SleepHelper">
        </bean>
    
        
        
        <bean id="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
            <property name="pattern" value=".*sleep"></property>
        </bean>
    
        
        <bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
            <property name="advice" ref="sleepHelper"></property>
            <property name="pointcut" ref="sleepPointcut"></property>
        </bean>
    
        
        <bean id="humanProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <property name="target" ref="human"></property>
            <property name="interceptorNames" value="sleepHelperAdvisor"></property>
            <property name="proxyInterfaces" value="com.ghs.aop.Sleepable"></property>
        </bean>
    
        <bean id="human" class="com.ghs.aop.Human">
        </bean>
    </beans>

类之间的依赖关系，可以看下面的简图。  
![这里写图片描述][70]

## 二.基于代理的AOP实现原理 ##

AOP的实现主要包括下面两大部分：

1.  创建代理
2.  代理执行

Spring动态代理的整体架构，可以查看博文：  
[https://blog.csdn.net/u011983531/article/details/79649279][https_blog.csdn.net_u011983531_article_details_79649279]

ProxyFactoryBean创建代理主要经历了下面几个步骤：

1.  实例化Advisor链
2.  调用代理工厂创建代理

我们主要讲解代理执行的过程：  
查看JdkDynamicAopProxy的invoke(…)方法。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;
    
        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;
        try {
            //equals()、hashcode()等方法不进行代理
            //代码省略……
    
            Object retVal;
    
            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }
            //获取拦截器链
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
            if (chain.isEmpty()) {
                //没有拦截器，直接执行目标方法
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
            }
            else {
                //创建可执行对象
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                //执行
                retVal = invocation.proceed();
            }
            Class<?> returnType = method.getReturnType();
            if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                retVal = proxy;
            } else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException("Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

主要逻辑就3步：

1.  创建拦截器（通知）链
2.  创建可执行对象
3.  执行可执行对象

我们首先看看拦截器（通知）链是如何创建的。  
![这里写图片描述][70 1]  
获取拦截器链其实就是将Advisor链中的所有advice取出来，构造MethodInterceptor对象。如果Advisor.getAdvice()返回的是MethodInterceptor对象，直接加入链中，如果Advisor.getAdvice()返回的Advice对象，通过[适配器][Link 1]模型构造MethodInterceptor对象，加入链中。

拦截器链创建好后，构造ReflectiveMethodInvocation对象。  
最后就是执行ReflectiveMethodInvocation对象。

//递归调用process方法
    public Object proceed() throws Throwable {
        //递归出口：所有的拦截器都已经执行完毕后，执行目标方法
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }
    
        Object interceptorOrInterceptionAdvice =
        this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                return proceed();
            }
        }
        else {
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

要理解执行逻辑，其实只要弄清楚拦截器链是如何实现链式调用的就行了。Spring在这里使用了递归调用，如何递归的，我们看看几个常见的通知就行了。

//前置通知
    public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
        private MethodBeforeAdvice advice;
    
        public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
            Assert.notNull(advice, "Advice must not be null");
            this.advice = advice;
        }
    
        public Object invoke(MethodInvocation mi) throws Throwable {
            //执行通知的before方法
            this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
            //递归执行MethodInvocation对象的process()方法
            return mi.proceed();
        }
    }
    
    //后置通知
    public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {
    
        private final AfterReturningAdvice advice;
    
        public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
            Assert.notNull(advice, "Advice must not be null");
            this.advice = advice;
        }
    
        public Object invoke(MethodInvocation mi) throws Throwable {
            //递归执行MethodInvocation的proceed()方法
            Object retVal = mi.proceed();
            //执行后置通知的afterReturning()方法
            this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
            return retVal;
        }
    
    }

[70]: /images/20220315/b8cf833b2ca64d748a532693122f418b.png
[https_blog.csdn.net_u011983531_article_details_79649279]: https://blog.csdn.net/u011983531/article/details/79649279
[70 1]: /images/20220315/baa883f0e54e4f048e3d2117dce74549.png
[Link 1]: https://www.baidu.com/s?wd=%E9%80%82%E9%85%8D%E5%99%A8&tn=24004469_oem_dg&rsv_dl=gh_pl_sl_csd