spring（五）：AOP

时间 2019-11-30

标签 spring aop 栏目 Spring 繁體版

原文原文链接

AOP（Aspect Oriented Programming）

面向切面编程，是一种编程范式，提供从另外一个角度来考虑程序结构从而完善面向对象编程(OOP)。java

在进行OOP开发时，都是基于对组件（好比类）进行开发，而后对组件进行组合，OOP最大问题就是没法解耦组件进行开发。spring

AOP为开发者提供一种进行横切关注点（好比日志关注点横切了支付关注点）分离并织入的机制，把横切关注点分离，而后经过某种技术织入到系统中，从而无耦合的完成了咱们的功能。编程

横切关注点可能包含不少，好比非业务的：日志、事务处理、缓存、性能统计、权限控制等；还多是业务的：如某个业务组件横切于多个模块。数组

基本概念

链接点（Jointpoint）：表示须要在程序中插入横切关注点的扩展点，链接点多是类初始化、方法执行、方法调用、字段调用或处理异常等，Spring只支持方法执行链接点；“在哪里干”；
切入点（Pointcut）：选择一组相关链接点的模式，便可以认为链接点的集合，Spring默认使用AspectJ语法；“在哪里干的集合”；[ <aop:aspectj-autoproxy/> 开启spring对@Aspectj的支持]
通知（Advice）：在链接点上执行的行为；“干什么”；
引入/内部类型声明（inter-type declaration）：为已有的类添加额外新的字段或方法，Spring容许引入新的接口（必须对应一个实现）到全部被代理对象（目标对象）；“干什么（引入什么）”；
切面（Aspect）：横切关注点的模块化，好比日志组件。能够认为是通知、引入和切入点的组合，在Spring中可使用Schema和@AspectJ方式进行组织实现；“在哪干和干什么集合”；
目标对象（Target Object）：须要被织入横切关注点的对象，被代理对象；“对谁干”；
织入（Weaving）：织入是一个过程，是将切面应用到目标对象从而建立出AOP代理对象的过程，织入能够在编译期、类装载期、运行期进行。
- 编译时织入，生成完整功能的Java字节码，需特殊编译器（AspectJ）
- 类加载时织入，AspectJ、AspectWerkz
- 运行时织入，动态代理。@EnableAspectJAutoProxy。[Spring采用运行时]
AOP代理（AOP Proxy）：AOP框架使用代理模式建立的对象，从而实如今链接点处插入通知，就是经过代理来对目标对象应用切面。

What-@Aspect缓存

Where-@Pointcutapp

When-@Advice(@Before、@After、@AfterReturning、@AfterThrowing、@Around)框架

在Spring中经过代理模式实现AOP，并经过拦截器模式以环绕链接点的拦截器链织入通知（即应用切面）jvm

通知类型

前置通知（Before Advice）:在切入点选择的链接点处的方法以前执行的通知，该通知不影响正常程序执行流程（除非该通知抛出异常，该异常将中断当前方法链的执行而返回）。
后置通知（After Advice）:在切入点选择的链接点处的方法以后执行的通知，包括以下类型的后置通知：
- 后置返回通知（After returning Advice）:在切入点选择的链接点处的方法正常执行完毕时执行的通知，必须是链接点处的方法没抛出任何异常正常返回时才调用后置通知。
- 后置异常通知（After throwing Advice）: 在切入点选择的链接点处的方法抛出异常返回时执行的通知，必须是链接点处的方法抛出任何异常返回时才调用异常通知。
- 后置最终通知（After finally Advice）: 在切入点选择的链接点处的方法返回时执行的通知，无论抛没抛出异常都执行，相似于Java中的finally块。
环绕通知（Around Advices）：环绕着在切入点选择的链接点处的方法所执行的通知，环绕通知能够在方法调用以前和以后自定义任何行为，而且能够决定是否执行链接点处的方法、替换返回值、抛出异常等等。

通知顺序

Spring中能够经过在切面实现类上实现org.springframework.core.Ordered接口或使用Order注解来指定切面优先级。在多个切面中，Ordered.getValue()方法返回值（或者注解值）较小值的那个切面拥有较高优先级。ide

@Order(2)

动态代理

若是目标对象实现了接口，默认使用JDK，能够强制用CGLIB；不然，采用CGLIB。模块化

JDK动态代理

只能为接口建立动态代理实例，而不能针对类。

使用java.lang.reflect.Proxy动态代理实现，经过调用目标类的getClass().getInterfaces()方法获取目标对象的接口信息，并生成一个实现了代理接口的动态代理class，而后经过反射技术得到该class的构造函数，并利用构造函数生成实例，在调用具体方法前调用InvocationHandler处理。

在Proxy这个类当中首先实例化一个对象ProxyClassFactory,而后在get方法中调用了apply方法,完成对代理类的建立：

generateProxyClass经过反射收集字段和属性而后生成字节
defineClass0 jvm内部完成对上述字节的load

CGLIB动态代理

主要是对指定的类生成一个子类，覆盖其中的方法。（不能通知final方法）

利用asm开源包，采用字节码技术，为一个类建立子类，在子类中采用方法拦截（MethodInterceptor @override intercept()），拦截全部父类方法的调用，顺势织入横切逻辑。

会产生两次构造器调用，第一次是目标类的构造器调用，第二次是CGLIB生成的代理类的构造器调用。

设计分析

1 为目标对象创建AopProxy代理对象

在依赖注入时，实例化bean后都会调用getObjectForBeanInstance方法，这里就是处理FactoryBean的入口。

经过配置和调用ProxyFactoryBean来完成代理对象的建立。

配置通知器advisor、proxyFactoryBean（目标对象target、interceptorNames拦截器数组、目标对象接口数组）

// ProxyFactoryBean
    @Nullable
    public Object getObject() throws BeansException {
        // 对通知器链进行初始化
        // 通知器链封装了一系列的拦截器（须要从配置中读取）
        // 而后为代理对象的生成作准备
        this.initializeAdvisorChain();
        // 区分两种类型的Bean
        if (this.isSingleton()) {
            return this.getSingletonInstance();
        } else {
            ...
            return this.newPrototypeInstance();
        }
    }

    private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
        // 通知器链未初始化（初始化工做发生在应用第一次经过ProxyFactoryBean获取代理对象的时候）
        if (!this.advisorChainInitialized) {
            if (!ObjectUtils.isEmpty(this.interceptorNames)) {
                ...
                String[] var1 = this.interceptorNames;
                int var2 = var1.length;
                for(int var3 = 0; var3 < var2; ++var3) {
                    String name = var1[var3];
                    ...
                    if (name.endsWith("*")) {
                        ...
                    } else {
                        Object advice;
                        if (!this.singleton && !this.beanFactory.isSingleton(name)) {
                            // Prototype类型
                            advice = new ProxyFactoryBean.PrototypePlaceholderAdvisor(name);
                        } else {
                            // singleton类型：经过getBean获取通知器
                            advice = this.beanFactory.getBean(name);
                        }
                        // 将通知器加入拦截器链中
                        this.addAdvisorOnChainCreation(advice, name);
                    }
                }
            }

            this.advisorChainInitialized = true;
        }
    }

    private synchronized Object getSingletonInstance() {
        if (this.singletonInstance == null) {
            this.targetSource = this.freshTargetSource();
            if (this.autodetectInterfaces && this.getProxiedInterfaces().length == 0 && !this.isProxyTargetClass()) {
                // 判断须要代理的接口
                Class<?> targetClass = this.getTargetClass();
                ...
                // 设置代理对象调用接口
                this.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
            }

            super.setFrozen(this.freezeProxy);
            // createAopProxy：生成aop代理对象 ★调用父类的createAopProxy()
            // getProxy：<<AopProxy>>接口的两种实现--JdkDynamicAopProxy、CglibAopProxy
            this.singletonInstance = this.getProxy(this.createAopProxy());
        }

        return this.singletonInstance;
    }

    private synchronized Object newPrototypeInstance() {
        ...
        ProxyCreatorSupport copy = new ProxyCreatorSupport(this.getAopProxyFactory());
        TargetSource targetSource = this.freshTargetSource();
        copy.copyConfigurationFrom(this, targetSource, this.freshAdvisorChain());
        if (this.autodetectInterfaces && this.getProxiedInterfaces().length == 0 && !this.isProxyTargetClass()) {
            // 和上面如出一辙的套路啊。。。
            Class<?> targetClass = targetSource.getTargetClass();
            if (targetClass != null) {
                copy.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
            }
        }
        ...
        // 而后经过<<AopProxy>>接口的两种实现--JdkDynamicAopProxy、CglibAopProxy获取代理对象
        return this.getProxy(copy.createAopProxy());
    }

// ProxyCreatorSupport
    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            this.activate();
        }

        // createAopProxy：<<AopProxyFactory>>接口的方法
        return this.getAopProxyFactory().createAopProxy(this);
    }

// 具体实现：DefaultAopProxyFactory
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        // 若是目标对象是接口类，使用jdk
        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                ...
            } else {
                // ObjenesisCglibAopProxy extends CglibAopProxy 
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
        // new的过程都是先从AdvisedSupport对象中取得配置的目标对象进行检查
    }

// JdkDynamicAopProxy
    public Object getProxy(@Nullable ClassLoader classLoader) {
        ...
        // 首先从advised对象中获取代理对象的代理接口配置
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        // 而后调用Proxy的newProxyInstance方法获得Proxy代理对象
        // 须要三个参数：类加载器、代理接口、回调方法所在对象
        // 回调方法用的是InvokeHandler的invoke回调入口
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

// CglibAopProxy
    public Object getProxy(@Nullable ClassLoader classLoader) {
        ...
        try {
            // 从advised对象中获取配置的target对象
            Class<?> rootClass = this.advised.getTargetClass();
            ...
            Class<?> proxySuperClass = rootClass;
            int x;
            if (ClassUtils.isCglibProxyClass(rootClass)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                Class[] var5 = additionalInterfaces;
                int var6 = additionalInterfaces.length;

                for(x = 0; x < var6; ++x) {
                    Class<?> additionalInterface = var5[x];
                    this.advised.addInterface(additionalInterface);
                }
            }
            // 验证代理对象的接口设置
            this.validateClassIfNecessary(proxySuperClass, classLoader);
            // 建立并配置cglib的enhancer
            Enhancer enhancer = this.createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader && ((SmartClassLoader)classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            // 设置enhancer的代理接口、回调方法等
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new CglibAopProxy.ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
            Callback[] callbacks = this.getCallbacks(rootClass);
            Class<?>[] types = new Class[callbacks.length];

            for(x = 0; x < types.length; ++x) {
                types[x] = callbacks[x].getClass();
            }

            enhancer.setCallbackFilter(new CglibAopProxy.ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            enhancer.setCallbackTypes(types);
            // 经过enhancer生成代理对象 ★
            // 注意这里有回调
            return this.createProxyClassAndInstance(enhancer, callbacks);
        }...
    }

    // 这里是回调方法，经过设置DynamicAdvisedInterceptor拦截器完成AOP功能
    private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
        ...
        Callback aopInterceptor = new CglibAopProxy.DynamicAdvisedInterceptor(this.advised);
        ...
        return callbacks;
    }

2 启动代理对象的拦截器来完成各类横切面的织入

在第一步的过程当中，拦截器已经配置到代理对象中，它是经过回调方法起做用。

JdkDynamicAopProxy的invoke拦截

@Nullable
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        TargetSource targetSource = this.advised.targetSource;
        Object target = null;

        Boolean var8;
        try {
            if (this.equalsDefined || !AopUtils.isEqualsMethod(method)) {
                ...
                // 获得目标对象
                target = targetSource.getTarget();
                Class<?> targetClass = target != null ? target.getClass() : null;
                // 这个方法对象注册了拦截器
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                // 没有设定拦截器链，直接调用target对象的方法
                if (chain.isEmpty()) {
                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                    // 对target对象的方法调用是经过反射机制，而后使用invoke调用方法反射对象
                    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
                } else {
                    // 拦截，经过ReflectiveMethodInvocation
                    MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                    // 沿着拦截器链继续前进
                    retVal = invocation.proceed();
                }
                ...
            }
            var8 = this.equals(args[0]);
        }...
        return var8;
    }

CglibAopProxy的DynamicAdvisedInterceptor的intercept拦截

@Nullable
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            ...
            try {
                ...
                // 获得目标对象
                target = targetSource.getTarget();
                Class<?> targetClass = target != null ? target.getClass() : null;
                // 从advised取得配置好的AOP通知
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                Object retVal;
                // 若没有，则直接调用target对象的方法
                if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                    retVal = methodProxy.invoke(target, argsToUse);
                } else {
                    // 拦截，经过CglibMethodInvocation启动advice通知
                    // CglibMethodInvocation extends ReflectiveMethodInvocation
                    // 沿着拦截器链继续前进
                    retVal = (new CglibAopProxy.CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)).proceed();
                }
                retVal = CglibAopProxy.processReturnType(proxy, target, method, retVal);
                var16 = retVal;
            }...
            return var16;
        }

综上，都是从advised取得拦截器链的。

拦截都是经过ReflectiveMethodInvocation的proceed方法实现的。

如何将拦截器链配置进advised的？

拦截器是ReflectiveMethodInvocation类中一个名为interceptorsAndDynamicMethodMatchers的List中的元素。

this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

advised的getInterceptorsAndDynamicInterceptionAdvice是由advisorChainFactory实现的，它的具体类型是DefaultAdvisorChainFactory。

DefaultAdvisorChainFactory经过AdvisorAdapterRegistry来适配ProxyFactoryBean中获得的通知器，注册拦截器。

在ProxyFactoryBean的getObject方法中对advisor进行初始化时，从配置中获取了通知器。（经过实现BeanFactoryAware接口，设置回调方法委托给IoC容器）

proceed方法

@Nullable
    public Object proceed() throws Throwable {
        // 若是已经到拦截器链的末尾，直接调用目标对象的方法
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return this.invokeJoinpoint();
        } else {
            // 不然，获得下一个拦截器
            Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
            // 经过拦截器进行matches判断是否适用于横切加强的场合
            if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
                InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
                Class<?> targetClass = this.targetClass != null ? this.targetClass : this.method.getDeclaringClass();
                // 若是是，从拦截器获得通知器，并启动invoke方法
                // 不然，迭代调用proceed方法
                return dm.methodMatcher.matches(this.method, targetClass, this.arguments) ? dm.interceptor.invoke(this) : this.proceed();
            } else {
                return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);
            }
        }
    }

advice通知是如何实现的？

DefaultAdvisorChainFactory经过AdvisorAdapterRegistry来适配ProxyFactoryBean中获得的通知器，注册拦截器。

// DefaultAdvisorChainFactory   
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, @Nullable Class<?> targetClass) {
        // GlobalAdvisorAdapterRegistry是一个单例，做用是适配器
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        Advisor[] advisors = config.getAdvisors();
        ...

        for(int var11 = 0; var11 < var10; ++var11) {
            Advisor advisor = var9[var11];
            if (advisor instanceof PointcutAdvisor) {
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor)advisor;
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    ...
                    if (match) {
                        MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                        ...
                    }
                }
            } else if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor)advisor;
                if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            } else {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }

        return interceptorList;
    }

MethodInterceptor[] interceptors = registry.getInterceptors(advisor);封装着advice织入实现的入口。

// DefaultAdvisorAdapterRegistry
    public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
        List<MethodInterceptor> interceptors = new ArrayList(3);
        Advice advice = advisor.getAdvice();
        if (advice instanceof MethodInterceptor) {
            interceptors.add((MethodInterceptor)advice);
        }
        // 对通知进行适配
        Iterator var4 = this.adapters.iterator();
        while(var4.hasNext()) {
            AdvisorAdapter adapter = (AdvisorAdapter)var4.next();
            // 若是适配器支持某种通知，则从对应的适配器中获取该类通知器的拦截器
            if (adapter.supportsAdvice(advice)) {
                interceptors.add(adapter.getInterceptor(advisor));
            }
        }
        ...
    }

咱们知道，proceed处理拦截器的时候是经过dm.interceptor.invoke(this)拦截器的回调方法。下面举一个例子。

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
    MethodBeforeAdviceAdapter() {
    }

    public boolean supportsAdvice(Advice advice) {
        return advice instanceof MethodBeforeAdvice;
    }

    public MethodInterceptor getInterceptor(Advisor advisor) {
        MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice();
        return new MethodBeforeAdviceInterceptor(advice);
    }
}

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {
    private final MethodBeforeAdvice advice;

    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    // 先触发advice的before，而后才是proceed调用！
    // 由于这是method before!若是是其余的拦截器，顺序、具体实现又不同了
    public Object invoke(MethodInvocation mi) throws Throwable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        return mi.proceed();
    }
}