spring-aop-ProxyFactory 源码分析

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

spring 提供的编程式aop实现,即通过 ProxyFactory类完成的。

另外AnnotationAwareAspectJAutoProxyCreator BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator 等自动aop代理创建器都是通过在其父类AbstractAutoProxyCreator中通过ProxyFactory 来实现aop逻辑的植入。所以理解ProxyFactory 的使用对理解spring aop 至关重要。

分析ProxyFactory 可以从两条线来分析:

1、代理对象的创建

2、method的调用以及拦截器(Advice)的织入。

使用方式:

[b]业务逻辑[/b]


    public class LoginServiceImpl implements LoginService {
        public boolean login(User user) {
            System.out.println(user);
            if (user == null) {
                return false;
            } else if (user.getUsername() == "xinchun.wang" && user.getPassword() == "123456") {
                return true;
            }
            return false;
        }
    }

[b]addvice增强[/b]


    public class AfterAdvice1 implements AfterReturningAdvice{

        public void afterReturning(Object returnValue, Method method,
                Object[] args, Object target) throws Throwable {
            System.out.println("AfterAdvice1.afterReturning() execute ");
        }
    }
    //
    public class AfterAdvice2 implements AfterReturningAdvice{

        public void afterReturning(Object returnValue, Method method,
                Object[] args, Object target) throws Throwable {
            System.out.println("AfterAdvice2.afterReturning() execute ");

        }
    }

    public class BeforeAdvice1 implements MethodBeforeAdvice{
        public void before(Method method, Object[] args, Object target)
                throws Throwable {
            System.out.println("BeforeAdvice1.before() execute ");
        }
    }

    public class BeforeAdvice2 implements MethodBeforeAdvice{

        public void before(Method method, Object[] args, Object target)
                throws Throwable {
            System.out.println("BeforeAdvice2.before() execute ");
        }

    }

[b]测试用例:[/b]


    @Test
        public void proxyLoginTest() {
            ProxyFactory factory = new ProxyFactory();
            factory.addAdvice(new BeforeAdvice1());
            factory.addAdvice(new BeforeAdvice2());
            factory.addAdvice(new AfterAdvice1());
            factory.addAdvice(new AfterAdvice2());
            LoginService target = new LoginServiceImpl();
            factory.setTarget(target);
            factory.setProxyTargetClass(false);
            factory.setInterfaces(new Class[]{LoginService.class});

            LoginService service = (LoginService)factory.getProxy();
            System.out.println(service.login(new User("xinchun.wang","123456")));
        }

输出:

BeforeAdvice1.before() execute

BeforeAdvice2.before() execute

User [username=admin, password=123456, open=false]

AfterAdvice2.afterReturning() execute

AfterAdvice1.afterReturning() execute

true

[b]数据结构:[/b]

ProxyConfig: 代理的基础配置属性

AdvisedSupport:提供基础的Advice的包装,Advisor 列表的维护,TargetSource 对象的维护,以及Interceptor 数据结构的解析和封装。

ProxyCreatorSupport:代理工厂的基类,主要负责代理对象的生成。

ProxyFactory:最常用的代理工厂应用,包含一些静态工厂方法,以及代理对象生成的方法。


    public class ProxyFactory extends ProxyCreatorSupport {
    //指定待实现接口和拦截器
       public ProxyFactory(Class proxyInterface, Interceptor interceptor) {
            addInterface(proxyInterface); //JDK代理需要接口
            addAdvice(interceptor);//添加增强逻辑
        }
    }

    //通过指定一个目标对象,构造ProxyFactory,可以继续通过addAdvice(interceptor);添加拦截器
    public ProxyFactory(Object target) {
            Assert.notNull(target, "Target object must not be null");
            setInterfaces(ClassUtils.getAllInterfaces(target));
            setTarget(target);
        }

    //生成代理对象,createAopProxy 在ProxyCreatorSupport 中实现
    public Object getProxy() {
            return createAopProxy().getProxy();
        }

    }

代理创建分析线

ProxyCreatorSupport 提供的createAopProxy() 提供了aopProxy的生成


    /** 代理工厂的基类,提供了对 AopProxyFactory 的包装*/
    public class ProxyCreatorSupport extends AdvisedSupport {
      //代理工厂,默认实现 DefaultAopProxyFactory 提供了 JdkDynamicAopProxy 和 Cglib2AopProxy 的生成
        private AopProxyFactory aopProxyFactory; 
      //aop配置的监听器
        private List<AdvisedSupportListener> listeners = new LinkedList<AdvisedSupportListener>();

        /** Set to true when the first AOP proxy has been created */
        private boolean active = false;

        /**
         * 默认实现,指定DefaultAopProxyFactory 为默认aop代理生成工厂
         */
        public ProxyCreatorSupport() {
            this.aopProxyFactory = new DefaultAopProxyFactory();
        }

        /**
         * 同上自定义一个AopProxyFactory,来实现aop代理对象的生成
         */
        public ProxyCreatorSupport(AopProxyFactory aopProxyFactory) {
            Assert.notNull(aopProxyFactory, "AopProxyFactory must not be null");
            this.aopProxyFactory = aopProxyFactory;
        }
        /**
         *留给子类调用的代理生成,此次是aop代理生成的入口
         */
        protected final synchronized AopProxy createAopProxy() {
            if (!this.active) { //第一次激活的时候,调用相关的监听器
                activate();
            }
            return getAopProxyFactory().createAopProxy(this); //通过aop代理工厂 生成AopProxy
        }

    }

代理创建分析线 DefaultAopProxyFactory 的 createAopProxy 方法

[code]

/** 默认的代理工厂实现

当 optimize =true或proxyTargetClass=ture 或 no proxy interfaces 指定,使用CGLIB 来生成代理,否则jdk代理

*/

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

/** 检查CGLIB2 相关类是否存在 */

private static final boolean cglibAvailable =

ClassUtils.isPresent(“net.sf.cglib.proxy.Enhancer”, DefaultAopProxyFactory.class.getClassLoader());

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {

//optimize =true或proxyTargetClass=ture 或 no proxy interfaces 指定,使用CGLIB 来生成代理

//optimize 做优化,早期jdk的代理的生成相当慢,不过现在基本差异不大

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()) { //虽然符合以上要求,但是如果代理对象是借口,那么继续使用jdk

return new JdkDynamicAopProxy(config);

}

if (!cglibAvailable) {

throw new AopConfigException(

“Cannot proxy target class because CGLIB2 is not available. ” +

“Add CGLIB to the class path or specify proxy interfaces.”);

}

return CglibProxyFactory.createCglibProxy(config); // Cglib2 代理

}

else {

return new JdkDynamicAopProxy(config); //jdk 代理

}

}

/**

* 判断是否有接口

*/

private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {

Class[] interfaces = config.getProxiedInterfaces();

return (interfaces.length == 0 || (interfaces.length == 1 && SpringProxy.class.equals(interfaces[0])));

}

/**

* 创建Cglib2AopProxy

*/

private static class CglibProxyFactory {

public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {

return new Cglib2AopProxy(advisedSupport);

}

}

}

[/code]

代理创建分析线 举例 JdkDynamicAopProxy 的getProxy 方法


    /**
     * 基于JDK动态代理 的Aop代理实现
       通过JDK代理的方法调用 只对接口中的方法做拦截
       即使真实对象不是线程安全的,通过JdkDynamicAopProxy 产生的对象依然是线程安全的。
     */
    final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

        private static final long serialVersionUID = 5531744639992436476L;

        /** We use a static Log to avoid serialization issues */
        private static Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);

        /** aop的配置信息(增强逻辑,真是对象,切点信息) */
        private final AdvisedSupport advised;

        /** 代理接口是否有equals方法
         */
        private boolean equalsDefined;

        /** 代理借口是否有hashCode方法
         */
        private boolean hashCodeDefined;

        public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
            Assert.notNull(config, "AdvisedSupport must not be null");
            if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
                throw new AopConfigException("No advisors and no TargetSource specified");
            }
            this.advised = config;
        }

      /** 获取代理*/
        public Object getProxy() {
            return getProxy(ClassUtils.getDefaultClassLoader());
        }

    /**  至此方法结束,通过jdk生成代理对象已经完成*/
        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); //生成代理
        }

        /**
         * 检查是否定义了hashCode  equals 方法 
         */
        private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
            for (Class proxiedInterface : proxiedInterfaces) {
                Method[] methods = proxiedInterface.getDeclaredMethods();
                for (Method method : methods) {
                    if (AopUtils.isEqualsMethod(method)) {
                        this.equalsDefined = true;
                    }
                    if (AopUtils.isHashCodeMethod(method)) {
                        this.hashCodeDefined = true;
                    }
                    if (this.equalsDefined && this.hashCodeDefined) {
                        return;
                    }
                }
            }
        }

        /**
         * 这里是代理对象调用,也是jdk代理 实现的核心逻辑
         */
        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 {
                if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) { //如果代理的是equlas 方法
                    return equals(args[0]);
                }
                if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) { //如果代理的是hashCode方法
                    // The target does not implement the hashCode() method itself.
                    return hashCode();
                }
                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) { // 是否允许把当前代理放到AopContext中,这样可以保存在ThreadLocal中,在代码里使用AopContext.currentProxy() 获取当前代理
                    // Make invocation available if necessary.
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }

                // 获取目标对象以及Class类型
                target = targetSource.getTarget();
                if (target != null) {
                    targetClass = target.getClass();
                }

                // 根据Method 和 targetClass 获取对应的拦截器(Advice增强封装) 这里是获取拦截逻辑的地方。(MethodMatcher 和 ClassFilter 在此处做匹配)
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

                // 如果没有配置,或者没有匹配到任何方法,那么直接调用当前实例的方法即可
                if (chain.isEmpty()) {
                    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
                }
                else {
                    // ReflectiveMethodInvocation 类封装了 增强和实例方法的调用
                    invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                    //aop的增强的植入 精华全在于此
                    retVal = invocation.proceed();
                }

                // Massage return value if necessary.
                if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
                        !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                    retVal = proxy;
                }
                return retVal;
            }
            finally {
                if (target != null && !targetSource.isStatic()) {
                    targetSource.releaseTarget(target);
                }
                if (setProxyContext) {
                    AopContext.setCurrentProxy(oldProxy); //恢复currentProxy
                }
            }
        }

    }

代理方法调用分析线

JdkDynamicAopProxy 实现InvocationHandler,其方法 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 会拦截所有通过代理调用的方法(如果对此不清楚,建议了解jdk的动态代理的实现)因此invoke就是调用的入口

基于以上分析,先看看拦截器对象的获取。 AdvisedSupport 的 getInterceptorsAndDynamicInterceptionAdvice 方法


    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {
            MethodCacheKey cacheKey = new MethodCacheKey(method);
            List<Object> cached = this.methodCache.get(cacheKey);
            if (cached == null) {
                cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                        this, method, targetClass);
                this.methodCache.put(cacheKey, cached);
            }
            return cached;
        }

从上面代码可以看出,是做了缓存,如果缓存不存在,通过 AdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice 来获取。 注意 这里把拦截器的获取委托的同时,仅仅提供了缓存功能,其他功能都进行了委托。

代理方法调用分析线 -拦截器的获取


    /** 此类的实现的唯一功能就是从Advised中,根据method 和 targetClass 实现拦截器的获取*/
    public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

        public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
                Advised config, Method method, Class targetClass) {

            List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
            //判断是否有引介增强
            boolean hasIntroductions = hasMatchingIntroductions(config, targetClass);
            //AdvisorAdapterRegistry 是对advice 的包装为MethodInterceptor 工具
            AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
            for (Advisor advisor : config.getAdvisors()) {
                if (advisor instanceof PointcutAdvisor) { //如果是PointcutAdvisor,那么要对方法和类做匹配
                    // Add it conditionally.
                    PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                    if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) { //如果类匹配
                      // registry.getInterceptors(advisor) 这句话就是对Advice ->MethodInterceptor 包装
                        MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                        MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                        if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) { //如果方法也匹配
                            if (mm.isRuntime()) { //如果是运行时判断,会考虑参数等因素
                                for (MethodInterceptor interceptor : interceptors) {
                                    interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                                }
                            }
                            else { //不是运行时,直接添加
                                interceptorList.addAll(Arrays.asList(interceptors));
                            }
                        }
                    }
                }
                else if (advisor instanceof IntroductionAdvisor) { //引介增强
                    IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                    if (config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) { //引介增强只需匹配类,即可
                        Interceptor[] interceptors = registry.getInterceptors(advisor);
                        interceptorList.addAll(Arrays.asList(interceptors));
                    }
                }
                else { //如果不是PointcutAdvisor 也不是 IntroductionAdvisor,那么直接包装,默认是匹配的
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
            return interceptorList;
        }

        /**
         * 判断targetClass 是否匹配Advised中的任意一个Advisor
         */
        private static boolean hasMatchingIntroductions(Advised config, Class targetClass) {
            for (int i = 0; i < config.getAdvisors().length; i++) {
                Advisor advisor = config.getAdvisors()[i];
                if (advisor instanceof IntroductionAdvisor) {
                    IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                    if (ia.getClassFilter().matches(targetClass)) {
                        return true;
                    }
                }
            }
            return false;
        }

    }

代理方法调用分析线 AdvisorAdapterRegistry 通过getInterceptors 对Advisor 包装,返回MethodInterceptor 的逻辑。

DefaultAdvisorAdapterRegistry 类这个接口的默认实现


    /** 对advice 的包装为MethodInterceptor 功能*/
    public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
        private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);
        /**
         * 构造方法中默认注册最常用的三个Advice的适配器
         */
        public DefaultAdvisorAdapterRegistry() {
            registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
            registerAdvisorAdapter(new AfterReturningAdviceAdapter());
            registerAdvisorAdapter(new ThrowsAdviceAdapter());
        }

      //把advice 包装成Advisor
        public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
            if (adviceObject instanceof Advisor) {
                return (Advisor) adviceObject;
            }
            if (!(adviceObject instanceof Advice)) { //如果不是advice ,直接抛出异常
                throw new UnknownAdviceTypeException(adviceObject);
            }
            Advice advice = (Advice) adviceObject;
            if (advice instanceof MethodInterceptor) { //如果环绕拦截器,那么通过DefaultPointcutAdvisor包装
                return new DefaultPointcutAdvisor(advice);
            }
            for (AdvisorAdapter adapter : this.adapters) { //通过构造方法中的适配器来判断是否支持
                // Check that it is supported.
                if (adapter.supportsAdvice(advice)) {
                    return new DefaultPointcutAdvisor(advice);
                }
            }
            throw new UnknownAdviceTypeException(advice);
        }

      //把advisor 包装为MethodInterceptor 列表,因为advisor 的Advice可能实现了MethodBeforeAdvice 同时也实现了 AfterReturningAdvice
        public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
            List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
            Advice advice = advisor.getAdvice();
            if (advice instanceof MethodInterceptor) {
                interceptors.add((MethodInterceptor) advice);
            }
            for (AdvisorAdapter adapter : this.adapters) {
                if (adapter.supportsAdvice(advice)) {
                    interceptors.add(adapter.getInterceptor(advisor));
                }
            }
            if (interceptors.isEmpty()) {
                throw new UnknownAdviceTypeException(advisor.getAdvice());
            }
            return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
        }

        public void registerAdvisorAdapter(AdvisorAdapter adapter) { //预留了扩展适配器的方法
            this.adapters.add(adapter);
        }
    }

代理方法调用分析线 ReflectiveMethodInvocation.proceed() 方法的调用,这里拦截增强逻辑植入的地方。


    public Object proceed() throws Throwable {
            //  我们从第一个currentInterceptorIndex = -1开始,如果currentInterceptorIndex 那么拦截器已经调用完,这时候调用真实的业务方法
            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 {
                // 如果是静态的,那么已经在构造ReflectiveMethodInvocation时,过滤了,都是匹配的拦截器,那么直接调用
                return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
            }
        }

      //实现思路很简单,就是method 在 target上进行反射调用
      protected Object invokeJoinpoint() throws Throwable {
            return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
        }

至此,调用分析已经完毕,但是似乎没有看到增强具体的逻辑,其实不然,这些拦截器是对advice封装,让我们看下这些对advice’的拦截器适配的实现。 这些逻辑的封装是在AdvisorAdapter 中的各个实现。


    class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
        public boolean supportsAdvice(Advice advice) {
            return (advice instanceof MethodBeforeAdvice);
        }
        public MethodInterceptor getInterceptor(Advisor advisor) {
            MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
            return new MethodBeforeAdviceInterceptor(advice); //如果是MethodBeforeAdvice,那么使用MethodBeforeAdviceInterceptor 进行适配
        }

    }

    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 {
            this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() ); //前置增强的调用,然后继续向下调用
            return mi.proceed();
        }

    }

    class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {
        public boolean supportsAdvice(Advice advice) {
            return (advice instanceof AfterReturningAdvice);
        }
        public MethodInterceptor getInterceptor(Advisor advisor) {
            AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
            return new AfterReturningAdviceInterceptor(advice);
        }

    }

    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 {
            Object retVal = mi.proceed();//先让其他方法调用完,然后才调用自己的后置增强
            this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
            return retVal;
        }
    }

至此分析完毕,一个简单的spring aop实现ProxyFactory 大致轮廓就是如此!

另外:如果你能清楚的理解下面的输出顺序,并且在随意更改advice添加顺序的情况下,你都能清楚预测出输出顺序,ok,你明白了AfterReturningAdviceInterceptor和MethodBeforeAdviceInterceptor 的invoke方法执行流程啦~

BeforeAdvice1.before() execute

BeforeAdvice2.before() execute

User [username=admin, password=123456, open=false]

AfterAdvice2.afterReturning() execute

AfterAdvice1.afterReturning() execute


来源:http://ddrv.cn

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » spring-aop-ProxyFactory 源码分析

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏