Spring AOP –JDK动态代理方。Spring技术内幕(二):AOP(二)

Spring AOP –JDK动态代理方。Spring技术内幕(二):AOP(二)

俺们掌握Spring是由此JDK或者CGLib实现动态代理的,今天我们讨论一下JDK实现动态代理的法则。


一、简述

季,Spring AOP拦截器调用的兑现


Spring在解析Bean的概念之后会以Bean的定义生成一个BeanDefinition对象又鉴于BeanDefinitionHolder对象具备。在此过程被,如果Bean需要给通知切入,BeanDefinition会叫再度换成一个proxyDefinition(其实呢是一个BeanDefinition对象,只不过描述的凡一个ProxyFactoryBean)。ProxyFactoryBean是一个兑现了FactoryBean的接口,用来转于为切入的对象。Spring
AOP的兑现多是透过ProxyFactoryBean实现的。我们今天议论的根本也是以此近乎。
  以座谈ProxyFactoryBean之前,我们先行押一下一个BeanDefinition转换成为proxyDefintion的过程。

1. 规划原理

  1. 以Spring
    AOP通过JDK的Proxy方式或者CGLIB方式变代理对象的时光,相关的拦截器已经安排到代办对象吃失去了。
  2. 安装拦截器回调

  3. 通过JDK的Proxy方式变代理对象:通过InvocationHandler设置拦截器回调

  4. 透过CGLIB方式转代理对象:根据CGLIB使用要求,通过DynamicAdvisedInterceptor来成功回调。

public final BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definitionHolder, ParserContext parserContext) {
        BeanDefinitionRegistry registry = parserContext.getRegistry();

        // get the root bean name - will be the name of the generated proxy factory bean
        String existingBeanName = definitionHolder.getBeanName();
        BeanDefinition targetDefinition = definitionHolder.getBeanDefinition();
        BeanDefinitionHolder targetHolder = new BeanDefinitionHolder(targetDefinition, existingBeanName + ".TARGET");

        // delegate to subclass for interceptor definition
        BeanDefinition interceptorDefinition = createInterceptorDefinition(node);

        // generate name and register the interceptor
        String interceptorName = existingBeanName + "." + getInterceptorNameSuffix(interceptorDefinition);
        BeanDefinitionReaderUtils.registerBeanDefinition(
                new BeanDefinitionHolder(interceptorDefinition, interceptorName), registry);

        BeanDefinitionHolder result = definitionHolder;

        if (!isProxyFactoryBeanDefinition(targetDefinition)) {
            // create the proxy definition 这里创建proxyDefinition对象,并且从原来的BeanDefinition对象中复制属性
            RootBeanDefinition proxyDefinition = new RootBeanDefinition();
            // create proxy factory bean definition
            proxyDefinition.setBeanClass(ProxyFactoryBean.class);
            proxyDefinition.setScope(targetDefinition.getScope());
            proxyDefinition.setLazyInit(targetDefinition.isLazyInit());
            // set the target
            proxyDefinition.setDecoratedDefinition(targetHolder);
            proxyDefinition.getPropertyValues().add("target", targetHolder);
            // create the interceptor names list
            proxyDefinition.getPropertyValues().add("interceptorNames", new ManagedList<String>());
            // copy autowire settings from original bean definition.
            proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
            proxyDefinition.setPrimary(targetDefinition.isPrimary());
            if (targetDefinition instanceof AbstractBeanDefinition) {
                proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
            }
            // wrap it in a BeanDefinitionHolder with bean name
            result = new BeanDefinitionHolder(proxyDefinition, existingBeanName);
        }

        addInterceptorNameToList(interceptorName, result.getBeanDefinition());
        return result;
    }

2. JdkDynamicAopProxy的invoke拦截

  • 经兑现InvocationHandler接口中的invoke方法,来形成对目标对象方法调用的阻碍或者说效益增强的工作。
  • 始建ReflectiveMethodInvocation对象来形成对AOP功能实现之包裹
  • invoke方法被针对拦截器进行安排的代码:
JdkDynamicAopProxy的invoke拦截.png

二、ProxyFactoryBean的原理
俺们先行来拘禁一下ProxyFactoryBean的继续关系:

3. Cglib2AopProxy的intercept拦截

  • 当对于AOP的阻拦调用,回调在DynamicAdvisedInterceptor对象吃实现,具体实现是以DynamicAdvisedInterceptor中之intercept方法中
  • 缔造CglibMethodInvocation对象来好拦截器链的调用(JdkDynamicAopProxy通过组织ReflectiveMethodInvocation对象来完成这个功能)
  • DynamicAdvisedInterceptor的intercept部分代码:
Cglib2AopProxy的intercept拦截.png

ProxyFactoryBean类图

4. 对象靶方法的调用

  • 采取JdkDynamicAopProxy的代理对象:通过AopUtils使用反射机制以AopUtils.invokejoinpointUsingReflection的方中落实
  • 采用Cglib2AopProxy的代理对象:通过CGLIB的MethodProxy对象直接到位

ProxyFactoryBean实现了FactoryBean、BeanClassLoaderAware、BeanFactoryAware接口,这里虽未多说了。ProxyCreatorSupport这个近乎则是创建代理对象的关键所在。  我们先来看望有代理对象的法门:

5. AOP拦住器链的调用

  • 区区种办法对拦截器的调用都是当ReflectiveMethodInvocation中通过proceed方法实现。在proceed方法被逐一个落实拦截器的遏止方法。每个拦截器在尽前,需要对代理方好一个相当判断(即Pointcut切点中得开展matches匹配过程)。
拦截器的运行.png

public Object getObject() throws BeansException {
        initializeAdvisorChain();
        if (isSingleton()) {
                        //单例
            return getSingletonInstance();
        }
        else {
            if (this.targetName == null) {
                logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +

                        "Enable prototype proxies by setting the 'targetName' property.");
            }
                        //非单例
            return newPrototypeInstance();
        }
    }

6. 安排通知器

  1. proceed方法吃interceptorOrInterceptionAdvice链来自interceptorsAndDynamicMethodMatchers持有的List的一个元素
  2. 比方List中之拦截器元素以JDKDynamicAopProxy中的invoke方法或者Cglib2AopProxy中DynamicAdvisedInterceptor的intercept回调中贯彻,并且我们可从中看到获取interceptors的操作以advised对象就。
  3. 这个advised是一个AdvisedSupport对象
AdvisedSupport取得拦截器.png
  • DefaultAdvisorChainFactory:生成通知器链的工厂,实现了interceptor链的得到过程
DefaultAdvisorChainFactory生成拦截器链.png

-   先设置一个List,长度为配置的通知器的个数。该配置即为XML中对ProxyFactory做的interceptNames属性的配置
-   AdvisorAdapterRegistry:实现拦截器的注册,对从ProxyFactoryBean配置中得到的同志进行适配,从而获得相应的拦截器
-   拦截器适配和注册过程完成以后,List中的拦截器会被JDK生成的AopProxy代理对象的invoke方法或者CGLIB代理对象的intercept拦截方法取得,并启动拦截器的invoke调用,最终触发通知的切面增强
  1. 在ProxyFactoryBean的getObject方法吃对advisor进行初始化
在拦截器链的初始化中获取advisor通知器.png



通过对IOC容器的一个getBean回调,得到配置好的advisor通知器
  • 盖DefaultListableBeanFactory作为IOC容器时,基类AbstractAutowireCapableBeanFactory有一个针对性Bean进行初始化的initializeBean方法。在这办法吃,判断Bean类型是否贯彻BeanFactoryAware接口
Bean类型是否实现BeanFactoryAware接口.png
  • 心想事成一个接口方法setBeanFactory,设置的this对象表示Bean所在IOC容器,一般指DefaultListableBeanFactory对象。
  • 获取这装置好之BeanFactory以后,ProxyFactoryBean就可以经过回调容器的getBean去取配置于Bean定义文件被的通知器,获取通知器就是朝IOC容器回调getBean(依赖注入)的进程。
  • 每当调用时,ProxyFactoryBean给起通知器的名,这些名字还是于interceptorNames的List中配备好的,在IOC对FactoryBean进行依赖注入时,会直接注入及FactoryBean的interceptorNames属性中。完成这个进程后,ProxyFactoryBean就拿走了安排的通知器,为完成切面增强搞好了备选。

initializeAdvisorChain()
方法是以通告链实例化。然后判断目标是不是如非常成单例而选择调用不同的办法,这里我们无非看生成单例对象的主意。

7. Advice通知之落实

  1. DefaultAdvisorChainFactory(负责转拦截器链)使用GlobalAdvisorAdapterRegistry得到AOP拦截器
  2. GlobalAdvisorAdapterRegistry的落实:单件设计模式,保证所假设变对象的唯一性
单件设计模式.png
  • 布一个静态的final变量instance,使得对象在加载类的当儿即便好成了
  • 抽象类,不克让实例化,保证instance对象的唯一性
  • 行使instance对象时,通过静态方法getInstance方法好,保证instance唯一对象的获取

  • DefaultAdvisorAdapterRegistry设置了一致系列adapter适配器,为Spring
    AOP的advice提供编织能力。

  • 以MethodBeforeAdviceAdapter为条例,把advice通知起通知器中取出,通过MethodBeforeAdviceInterceptor对象将获得的advice通知包装起来。在MethodBeforeAdviceInterceptor方法中,会先调用advice的before方法,在措施调用之前形成通知提高。

private synchronized Object getSingletonInstance() {
        if (this.singletonInstance == null) {
            this.targetSource = freshTargetSource();
                        //如果以接口的方式代理对象
            if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
                // Rely on AOP infrastructure to tell us what interfaces to proxy.
                Class<?> targetClass = getTargetClass();
                if (targetClass == null) {
                    throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
                }
                      //获取目标类实现的所有接口,并注册给父类的interfaces属性,为jdk动态代理做准备
                setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
            }
            // Initialize the shared singleton instance.
            super.setFrozen(this.freezeProxy);
                   //这里产生代理对象
            this.singletonInstance = getProxy(createAopProxy());
        }
        return this.singletonInstance;
    }

8. ProxyFactory实现AOP

方的解析重点讲解了为ProxyFactoryBean为例Spring
AOP的兑现原理,除此之外,ProxyFactory也堪实现Spring
AOP,而且原理也大多,只不过后者需要编程式地成功AOP应用之装。

ProxyFactory.png


参考资料:Spring技术内幕(第2版)
计文柯

咱们得看看,产生代理对象是由此getProxy()方法实现的,这个法我们看一下:

protected Object getProxy(AopProxy aopProxy) {
        return aopProxy.getProxy(this.proxyClassLoader);
    }

AopProxy对象的getProxy()方法有我们要之代办对象,究竟AopProxy这个看似是什么,我们接下去先押一下生是目标的方法createAopProxy():

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

createAopProxy方法:
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
                //目标对象不是接口类的实现或者没有提供代理接口
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }  
            //代理对象自身是接口
            if (targetClass.isInterface()) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

以此间我们一味看JdkDynamicAopProxy这个类似的落实,我们面前提到,真正代理对象的生成是由AopProxy的getProxy方法好的,这里我们看一下JdkDynamicAopProxy的getProxy方法,这也是本文讨论的要:

public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

俺们看可以充分懂得的张,代理对象的变通直接行使了jdk动态代理:Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);比方代理逻辑是经过兑现了InvocationHandler接口的invoke方法实现之。而这里运用的贯彻了InvocationHandler接口的近乎就是JdkDynamicAopProxy自身。JdkDynamicAopProxy自身实现了InvocationHandler接口,完成了Spring
AOP拦截器链拦截等一样多元逻辑,我们看一下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方法
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            //没有重写hashCode方法
            if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
          //代理的类是Advised,这里直接执行,不做任何代理
            if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // Service invocations on ProxyConfig with the proxy config...
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;

            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            // May be null. Get as late as possible to minimize the time we "own" the target,
            // in case it comes from a pool.
            //获得代理对象
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }

            // Get the interception chain for this method.
            //获得已经定义的拦截器链
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // Check whether we have any advice. If we don't, we can fallback on direct
            // reflective invocation of the target, and avoid creating a MethodInvocation.
            if (chain.isEmpty()) {
                // We can skip creating a MethodInvocation: just invoke the target directly
                // Note that the final invoker must be an InvokerInterceptor so we know it does
                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                //拦截器链是空的,直接执行需要代理的方法
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
            }
            else {
                // We need to create a method invocation...
                //这里是调用拦截器链的地方,先创建一个MethodInvocation对象,然后调用该对象的proceed方法完成拦截器链调用
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // Proceed to the joinpoint through the interceptor chain.
                retVal = invocation.proceed();
            }

            // Massage return value if necessary.
            Class<?> returnType = method.getReturnType();
            //这里处理返回值,判断返回值和方法需要的返回是否一致
            if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                // Special case: it returned "this" and the return type of the method
                // is type-compatible. Note that we can't help if the target sets
                // a reference to itself in another returned object.
                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()) {
                // Must have come from TargetSource.
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

阻止器链的调用

起上面的代码和注释中我们得以看到spring实现aop的严重性流程,具体什么调用拦截器链,我们来拘禁一下MethodInvocation的proceed方法

public Object proceed() throws Throwable {
        //  We start with an index of -1 and increment early.
        //   currentInterceptorIndex是从-1开始的,所以拦截器链调用结束的时候index是 this.interceptorsAndDynamicMethodMatchers.size() - 1
        //  调用链结束后执行目标方法
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }
        //  获得当前处理到的拦截器
        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        //  这里判断是否是InterceptorAndDynamicMethodMatcher,如果是,这要判断是否匹配methodMatcher,不匹配则此拦截器不生效
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

proceed()方法是一个递归方法,我们可以根据代码的注释知道大致逻辑,InterceptorAndDynamicMethodMatcher的代码如下,我们好看看,InterceptorAndDynamicMethodMatcher
持有一个MethodInterceptor 对象和一个MethodMatcher
对象,在阻止器链调用过程被,如果拦截器是InterceptorAndDynamicMethodMatcher
,则会事先冲MethodMatcher 判断是否匹配,匹配MethodInterceptor 才会收效。

class InterceptorAndDynamicMethodMatcher {

    final MethodInterceptor interceptor;

    final MethodMatcher methodMatcher;

    public InterceptorAndDynamicMethodMatcher(MethodInterceptor interceptor, MethodMatcher methodMatcher) {
        this.interceptor = interceptor;
        this.methodMatcher = methodMatcher;
    }

}

关于MethodInterceptor 是什么,MethodInterceptor
的逻辑是何等的,我们可扣押一下MethodInterceptor
的一个子类AfterReturningAdviceInterceptor的落实:

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {    private final AfterReturningAdvice advice;    /**     * Create a new AfterReturningAdviceInterceptor for the given advice.     * @param advice the AfterReturningAdvice to wrap     */    public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {        Assert.notNull(advice, "Advice must not be null");        this.advice = advice;    }    @Override    public Object invoke(MethodInvocation mi) throws Throwable {        Object retVal = mi.proceed();        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());        return retVal;    }}

AfterReturningAdviceInterceptor的意是当给摄的法门返回结果之后补充加我们要之处理逻辑,其促成方式我们可见见,先调用MethodInvocation
的proceed,也即是优先连续处理拦截器链,等调用完成后行我们得之逻辑:this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
顶这边,spring使用jdk动态代理实现aop的解析多结束,其中拦截器链的调用比较为难理解而且于重要,需要之同窗可以基本上省就无异片。
于程序员这漫漫路上碰到瓶颈的恋人可以入过多:654675708 大家并来提升发展
但要备注好信息 注!
有Java高级大牛直播讲解知识点,分享文化,有五非常专题都是各位导师多年工作更的梳理和总结,带在大家无微不至、科学地建协调之艺体系以及技能认知
品同:工程化技术-提升效率 才能够出重多之辰来构思

号二:源码分析-成为一个内功深厚的程序员

等级三:高性能 分布式 高可用-进入互联网企业不再是您的难题

路四:性能调优-我不愿只开一个程序员 我还有更胜之落成

号五:项目实战-理论及时实施互相结合 你距离梦想的相距仅套而而沾从脚尖

admin

网站地图xml地图