Springboot源码分析之代理三板斧

摘要：

在spring的版本变迁过程中，注解发生了很多的变化，然而代理的设计也发生了微妙的变化，从spring1.x的proxyfactorybean的硬编码岛spring2.x的aspectj注解，最后到了现在广为熟知的自动代理。

说明：

• proxyconfig代理的相关配置类
• advisedsupport实现了advised，封装了对advice和advisor的操作
• proxycreatorsupport该类及其子类主要是利用代理工厂帮助创建jdk或者cglib的代理对象
• proxyprocessorsupport该类及其子类才是我们目前用得做多的，利用后置处理器来进行自动代理处理

proxyfactorybean

    package com.github.dqqzj.springboot.aop;
    
    import org.springframework.aop.methodbeforeadvice;
    import org.springframework.aop.targetsource;
    import org.springframework.aop.framework.proxyfactorybean;
    import org.springframework.aop.target.singletontargetsource;
    import org.springframework.context.annotation.bean;
    import org.springframework.stereotype.component;
    
    import java.lang.reflect.method;
    
    /**
     * @author qinzhongjian
     * @date created in 2019-08-24 11:05
     * @description: todo
     * @since jdk 1.8.0_212-b10
     */
    @component
    public class mymethodbeforeadvice implements methodbeforeadvice {
        @override
        public void before(method method, object[] args, object target) throws throwable {
            if (!method.getname().equals("tostring")) {
                system.out.println(target.getclass().getname() + "#" + method.getname());
            }
        }
        /**
         * 代理的目标对象  效果同settargetsource(@nullable targetsource targetsource)
         * targetsource targetsource = new singletontargetsource(aopservice);
         * 可以从容器获取，也可以类似下面这样直接new，使用区别需要熟悉spring机制。
         * factorybean.settarget(new aopservice());
         *
         * 设置需要被代理的接口  效果同factorybean.setproxyinterfaces(new class[]{aopservice.class});
         * 若没有实现接口，那就会采用cglib去代理
         * 如果有接口不指定的话会代理所有的接口，否则代理指定的接口
         *
         *  setinterceptornames方法源代码中有这样的一句话：set the list of advice/advisor bean names. this must always be set
         *  to use this factory bean in a bean factory.
         */
        @bean
        public proxyfactorybean proxyfactorybean(aopservice aopservice) {
            proxyfactorybean factorybean = new proxyfactorybean();
            factorybean.settarget(aopservice);
            //factorybean.setinterfaces(aopservice.class);
    
            factorybean.setinterceptornames("mymethodbeforeadvice");
            //是否强制使用cglib，默认是false的
            //factorybean.setproxytargetclass(true);
            return factorybean;
        }
    
    }

源码分析：

        @override
        @nullable
        public object getobject() throws beansexception {
            //根据我们配置的interceptornames来获取对应的advisor并加入通知器执行链中
            initializeadvisorchain();
            if (issingleton()) {
                //生成singleton的代理对象,会利用defaultaopproxyfactory去生成代理
          //在内部如果你手动没有去设置需要被代理的接口，spring会代理你所有的实现接口。
                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();
            }
        }
        private synchronized void initializeadvisorchain() throws aopconfigexception, beansexception {
            if (this.advisorchaininitialized) {
                return;
            }
            if (!objectutils.isempty(this.interceptornames)) {
                // 最后一个不能是全局的suffix *，除非我们指定了targetsource之类的
                if (this.interceptornames[this.interceptornames.length - 1].endswith(global_suffix) &&
                        this.targetname == null && this.targetsource == empty_target_source) {
                    throw new aopconfigexception("target required after globals");
                }
                for (string name : this.interceptornames) {
                    // 如国拦截器的名称是以*结尾的，说明它要去全局里面都搜索出来
                    // 全局：去自己容器以及父容器中找，类型为advisor.class的，名称是以这个名称为开头的prefix的bean.
                    if (name.endswith(global_suffix)) {
                        addglobaladvisor((listablebeanfactory) this.beanfactory,
                                name.substring(0, name.length() - global_suffix.length()));
                    }
                    // 一般的情况下我们都是精确匹配
                    else {
                        object advice;
                        if (this.singleton || this.beanfactory.issingleton(name)) {
                            // 从容器里获取该bean
                            advice = this.beanfactory.getbean(name);
                        }
                        // 原型处理
                        else {
                            advice = new prototypeplaceholderadvisor(name);
                        }
                        addadvisoronchaincreation(advice, name);
                    }
                }
            }
            this.advisorchaininitialized = true;
        }
      // 将advice对象添加到通知器链中
        private void addadvisoronchaincreation(object next, string name) {
            // 这里调用namedbeantoadvisor做了一下适配：成统一的advisor 
            advisor advisor = namedbeantoadvisor(next);
            addadvisor(advisor);
        }
    //方法中首先会调用namedbeantoadvisor(next)方法，将从ioc容器获取的普通对象转换成通知器advisor对象
        private advisor namedbeantoadvisor(object next) {
            try {
                return this.advisoradapterregistry.wrap(next);
            }
        }

defaultadvisoradapterregistry

这个类还允许我们自定义适配器，然后注册到里面就行。

      @override
        public void registeradvisoradapter(advisoradapter adapter) {
            this.adapters.add(adapter);
        }

proxyfactorybean脱离ioc容器使用

proxyfactory

说明：这个类一般是spring自己内部使用的，我们自定义的话很难与容器进行整合，它一般都是返回的原型模式代理

aspectjproxyfactory

小结：

根据以上案例可以发现 都是首先进行advisedsupport的准备，然后交给子类proxycreatorsupport根据条件
得到jdk或者cglib的aopproxy,当代理对象被调用的时候在invoke或者intercept方法中会调用proxycreatorsupport的getinterceptorsanddynamicinterceptionadvice方法去初始化advice和各个方法之间的映射关系并缓存

同类方法代理不生效原因？

很多时候会发现代理方法和非代理方法在同一个类中调用不生效和调用顺序有关系，我们进行重构代码来分析一下原因

    public class aspectjproxyfactoryapplication {
        public static void main(string[] args) {
            aspectjproxyfactory proxyfactory = new aspectjproxyfactory(new aopservice());
            // 注意：此处得myaspect类上面的@aspect注解必不可少
            proxyfactory.addaspect(myaspect.class);
            //proxyfactory.setproxytargetclass(true);//是否需要使用cglib代理
            aopservice proxy = proxyfactory.getproxy();
            proxy.test();
        }
    }

    @aspect
    public class myaspect {
        //@pointcut("execution(* com.github..aop.*.*(..))")
        @pointcut("execution(* com.github..aop.aopservice.hello(..))")
        private void pointcut() {
        }
    
        @before("pointcut()")
        public void before() {
            system.out.println("-----------myaspect#before-----------");
        }
    }

    @service
    public class aopservice {
        public string hello() {
            system.out.println("hello, aopservice");
            return "hello, aopservice";
        }
        public string test() {
            system.out.println("test");
            return hello();
        }
    }

答案就是不会生效，究竟是什么引起的呢？其实就是我上面的小结的最后一个知识点。

这个时候chain没有我们的通知器在里面，

最终按照我们的程序执行,下面进行修改切点表达式，如果上面的例子看的咨询的话下面就可以忽略了，主要就是是否增强就是第一个入口函数能否匹配上我们的切点表达式后续的根本不会关心你是否能匹配上。

    @aspect
    public class myaspect {
        @pointcut("execution(* com.github..aop.*.*(..))")
        //@pointcut("execution(* com.github..aop.aopservice.hello(..))")
        private void pointcut() {
        }
    
        @before("pointcut()")
        public void before() {
            system.out.println("-----------myaspect#before-----------");
        }
    }

处理完后就会按照下面代码正常流程执行完

if (this.currentinterceptorindex == this.interceptorsanddynamicmethodmatchers.size() - 1) {
   return invokejoinpoint();
}

如果同一个类的方法调用都想让通知器生效怎么办？这个就必须要让通知添加到执行链中才行，根据上面所讲的内容就可以达到这个目的。