引
上一篇中的分析已经可以获取到适合给定bean的所有增强，接下来就是创建代理了。
/** * 如果需要则包装该bean,例如该bean可以被代理 * Wrap the given bean if necessary, i.e. if it is eligible for being proxied. * @param bean the raw bean instance * @param beanName the name of the bean * @param cacheKey the cache key for metadata access * @return a proxy wrapping the bean, or the raw bean instance as-is */ protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { // 1、如果已经处理过或者不需要创建代理，则返回 if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { return bean; } if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } // 2、创建代理 // 2.1 根据指定的bean获取所有的适合该bean的增强 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { // 2.2 为指定bean创建代理 this.advisedBeans.put(cacheKey, Boolean.TRUE); Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } // 3、缓存 this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }
1.创建代理流程分析
/** * 为给定的bean创建代理 * Create an AOP proxy for the given bean. * @param beanClass the class of the bean * @param beanName the name of the bean * @param specificInterceptors the set of interceptors that is * specific to this bean (may be empty, but not null) * @param targetSource the TargetSource for the proxy, * already pre-configured to access the bean * @return the AOP proxy for the bean * @see #buildAdvisors */ protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) { // 1、当前beanFactory是ConfigurableListableBeanFactory类型，则尝试暴露当前bean的target class if (this.beanFactory instanceof ConfigurableListableBeanFactory) { AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); } // 2、创建ProxyFactory并配置 ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); // 是否直接代理目标类以及接口 if (!proxyFactory.isProxyTargetClass()) { // 确定给定bean是否应该用它的目标类而不是接口进行代理 if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } // 检查给定bean类上的接口，如果合适的话，将它们应用到ProxyFactory。即添加代理接口 else { evaluateProxyInterfaces(beanClass, proxyFactory); } } // 3、确定给定bean的advisors，包括特定的拦截器和公共拦截器，是否适配Advisor接口。 Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); // 设置增强 proxyFactory.addAdvisors(advisors); // 设置代理目标 proxyFactory.setTargetSource(targetSource); // 定制proxyFactory（空的模板方法，可在子类中自己定制） customizeProxyFactory(proxyFactory); // 锁定proxyFactory proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } // 4、创建代理 return proxyFactory.getProxy(getProxyClassLoader()); }
具体的流程处理，代码注释里已经写的很清楚了，接下来看第四步，创建代理的具体过程。
public Object getProxy(@Nullable ClassLoader classLoader) { return createAopProxy().getProxy(classLoader); } protected final synchronized AopProxy createAopProxy() { if (!this.active) { activate(); } return getAopProxyFactory().createAopProxy(this); }
从上面的代码可以看到，创建代理的具体工作委托给了AopProxyFactory的createAopProxy方法。
/** * 创建代理 * 1、config.isOptimize()：判断通过CGLIB创建的代理是否使用了优化策略 * 2、config.isProxyTargetClass()：是否配置了proxy-target-class为true * 3、hasNoUserSuppliedProxyInterfaces(config)：是否存在代理接口 * 4、targetClass.isInterface()-->目标类是否为接口 * 5、Proxy.isProxyClass-->如果targetClass类是代理类，则返回true，否则返回false。 * * @param config the AOP configuration in the form of an AdvisedSupport object * @return * @throws AopConfigException */ @Override public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { // 1、判断是否需要创建CGLIB动态代理 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."); } // todo 这里有疑问 即 // targetClass.isInterface() // Proxy.isProxyClass(targetClass) // 什么情况下会生效 if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { // 创建jdk动态代理 return new JdkDynamicAopProxy(config); } // 创建CGLIB动态代理 return new ObjenesisCglibAopProxy(config); } // 2、默认创建JDK动态代理 else { return new JdkDynamicAopProxy(config); } }
这里我们终于看到了判断CGLIB和JDK动态代理的判断条件，这也是面试会碰到的一个常见的问题。
我们先分析第一个if判断里的条件：
- config.isOptimize()：判断通过CGLIB创建的代理是否使用了优化策略
该条件取值于ProxyConfig类的optimize属性。此属性标记是否对代理进行优化。启动优化通常意味着在代理对象被创建后，增强的修改将不会生效，因此默认值为false。如果exposeProxy设置为true，即使optimize为true也会被忽略。 - config.isProxyTargetClass()：是否配置了proxy-target-class为true
该条件取值于ProxyConfig类的proxyTargetClass属性。此属性标记是否直接对目标类进行代理，而不是通过接口产生代理。 - hasNoUserSuppliedProxyInterfaces(config)：是否存在代理接口
满足以上三者条件的任何一个，则会考虑开启CGLIB动态代理，但是在该if条件里还有另外一层判断 targetClass.isInterface() || Proxy.isProxyClass(targetClass),即如果目标类本身就是一个接口，或者目标类是由Proxy.newProxyInstance()或Proxy.getProxyClass()生成时，则依然采用jdk动态代理。（关于这两种情况的实例，网上没有找到例子，了解的同学可以留言哈！）
到这里，代理的创建过程勉强的分析完了。。。，接下来我们看获取代理的过程。
2.获取CGLIB动态代理
public Object getProxy(@Nullable ClassLoader classLoader) { logger.info("Creating CGLIB proxy: target source is " + this.advised.getTargetSource()); try { Class<?> rootClass = this.advised.getTargetClass(); Class<?> proxySuperClass = rootClass; if (ClassUtils.isCglibProxyClass(rootClass)) { proxySuperClass = rootClass.getSuperclass(); Class<?>[] additionalInterfaces = rootClass.getInterfaces(); for (Class<?> additionalInterface : additionalInterfaces) { this.advised.addInterface(additionalInterface); } } // Validate the class, writing log messages as necessary. validateClassIfNecessary(proxySuperClass, classLoader); // 新建并配置Enhancer Enhancer enhancer = createEnhancer(); if (classLoader != null) { enhancer.setClassLoader(classLoader); if (classLoader instanceof SmartClassLoader && ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) { enhancer.setUseCache(false); } } enhancer.setSuperclass(proxySuperClass); enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised)); enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE); enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader)); Callback[] callbacks = getCallbacks(rootClass); Class<?>[] types = new Class<?>[callbacks.length]; for (int x = 0; x < types.length; x++) { types[x] = callbacks[x].getClass(); } // fixedInterceptorMap only populated at this point, after getCallbacks call above enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset)); enhancer.setCallbackTypes(types); // Generate the proxy class and create a proxy instance. // 生成代理类并创建代理实例 return createProxyClassAndInstance(enhancer, callbacks); } catch (CodeGenerationException | IllegalArgumentException ex) { throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() + ": Common causes of this problem include using a final class or a non-visible class", ex); } catch (Throwable ex) { // TargetSource.getTarget() failed throw new AopConfigException("Unexpected AOP exception", ex); } }
3.获取JDK动态代理
public Object getProxy(@Nullable ClassLoader classLoader) { logger.info("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource()); // 确定用于给定AOP配置的代理的完整接口集。 Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true); // 判断被代理接口有没有重写equals和hashCode方法 findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); // 为接口创建代理 return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); }
4.总结
代理的具体创建过程与我们之前篇幅中分析的过程大致相同，这里不详细的分析了，感兴趣的同学，可以自己跟踪调试一下代码。
另外在本篇中还有一个疑问就是判断创建代理类型里的 targetClass.isInterface() || Proxy.isProxyClass(targetClass)，这句话会在什么样的场景下生效，知道的同学请留言，万分感激。。
作者：闲来也无事
链接：https://www.jianshu.com/p/ee41c5fee6ff
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
引
上一篇中的分析已经可以获取到适合给定bean的所有增强，接下来就是创建代理了。
/** * 如果需要则包装该bean,例如该bean可以被代理 * Wrap the given bean if necessary, i.e. if it is eligible for being proxied. * @param bean the raw bean instance * @param beanName the name of the bean * @param cacheKey the cache key for metadata access * @return a proxy wrapping the bean, or the raw bean instance as-is */ protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { // 1、如果已经处理过或者不需要创建代理，则返回 if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { return bean; } if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } // 2、创建代理 // 2.1 根据指定的bean获取所有的适合该bean的增强 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { // 2.2 为指定bean创建代理 this.advisedBeans.put(cacheKey, Boolean.TRUE); Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } // 3、缓存 this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }
1.创建代理流程分析
/** * 为给定的bean创建代理 * Create an AOP proxy for the given bean. * @param beanClass the class of the bean * @param beanName the name of the bean * @param specificInterceptors the set of interceptors that is * specific to this bean (may be empty, but not null) * @param targetSource the TargetSource for the proxy, * already pre-configured to access the bean * @return the AOP proxy for the bean * @see #buildAdvisors */ protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) { // 1、当前beanFactory是ConfigurableListableBeanFactory类型，则尝试暴露当前bean的target class if (this.beanFactory instanceof ConfigurableListableBeanFactory) { AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); } // 2、创建ProxyFactory并配置 ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); // 是否直接代理目标类以及接口 if (!proxyFactory.isProxyTargetClass()) { // 确定给定bean是否应该用它的目标类而不是接口进行代理 if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } // 检查给定bean类上的接口，如果合适的话，将它们应用到ProxyFactory。即添加代理接口 else { evaluateProxyInterfaces(beanClass, proxyFactory); } } // 3、确定给定bean的advisors，包括特定的拦截器和公共拦截器，是否适配Advisor接口。 Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); // 设置增强 proxyFactory.addAdvisors(advisors); // 设置代理目标 proxyFactory.setTargetSource(targetSource); // 定制proxyFactory（空的模板方法，可在子类中自己定制） customizeProxyFactory(proxyFactory); // 锁定proxyFactory proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } // 4、创建代理 return proxyFactory.getProxy(getProxyClassLoader()); }
具体的流程处理，代码注释里已经写的很清楚了，接下来看第四步，创建代理的具体过程。
public Object getProxy(@Nullable ClassLoader classLoader) { return createAopProxy().getProxy(classLoader); } protected final synchronized AopProxy createAopProxy() { if (!this.active) { activate(); } return getAopProxyFactory().createAopProxy(this); }
从上面的代码可以看到，创建代理的具体工作委托给了AopProxyFactory的createAopProxy方法。
/** * 创建代理 * 1、config.isOptimize()：判断通过CGLIB创建的代理是否使用了优化策略 * 2、config.isProxyTargetClass()：是否配置了proxy-target-class为true * 3、hasNoUserSuppliedProxyInterfaces(config)：是否存在代理接口 * 4、targetClass.isInterface()-->目标类是否为接口 * 5、Proxy.isProxyClass-->如果targetClass类是代理类，则返回true，否则返回false。 * * @param config the AOP configuration in the form of an AdvisedSupport object * @return * @throws AopConfigException */ @Override public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { // 1、判断是否需要创建CGLIB动态代理 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."); } // todo 这里有疑问 即 // targetClass.isInterface() // Proxy.isProxyClass(targetClass) // 什么情况下会生效 if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { // 创建jdk动态代理 return new JdkDynamicAopProxy(config); } // 创建CGLIB动态代理 return new ObjenesisCglibAopProxy(config); } // 2、默认创建JDK动态代理 else { return new JdkDynamicAopProxy(config); } }
这里我们终于看到了判断CGLIB和JDK动态代理的判断条件，这也是面试会碰到的一个常见的问题。
我们先分析第一个if判断里的条件：
- config.isOptimize()：判断通过CGLIB创建的代理是否使用了优化策略
该条件取值于ProxyConfig类的optimize属性。此属性标记是否对代理进行优化。启动优化通常意味着在代理对象被创建后，增强的修改将不会生效，因此默认值为false。如果exposeProxy设置为true，即使optimize为true也会被忽略。 - config.isProxyTargetClass()：是否配置了proxy-target-class为true
该条件取值于ProxyConfig类的proxyTargetClass属性。此属性标记是否直接对目标类进行代理，而不是通过接口产生代理。 - hasNoUserSuppliedProxyInterfaces(config)：是否存在代理接口
满足以上三者条件的任何一个，则会考虑开启CGLIB动态代理，但是在该if条件里还有另外一层判断 targetClass.isInterface() || Proxy.isProxyClass(targetClass),即如果目标类本身就是一个接口，或者目标类是由Proxy.newProxyInstance()或Proxy.getProxyClass()生成时，则依然采用jdk动态代理。（关于这两种情况的实例，网上没有找到例子，了解的同学可以留言哈！）
到这里，代理的创建过程勉强的分析完了。。。，接下来我们看获取代理的过程。
2.获取CGLIB动态代理
public Object getProxy(@Nullable ClassLoader classLoader) { logger.info("Creating CGLIB proxy: target source is " + this.advised.getTargetSource()); try { Class<?> rootClass = this.advised.getTargetClass(); Class<?> proxySuperClass = rootClass; if (ClassUtils.isCglibProxyClass(rootClass)) { proxySuperClass = rootClass.getSuperclass(); Class<?>[] additionalInterfaces = rootClass.getInterfaces(); for (Class<?> additionalInterface : additionalInterfaces) { this.advised.addInterface(additionalInterface); } } // Validate the class, writing log messages as necessary. validateClassIfNecessary(proxySuperClass, classLoader); // 新建并配置Enhancer Enhancer enhancer = createEnhancer(); if (classLoader != null) { enhancer.setClassLoader(classLoader); if (classLoader instanceof SmartClassLoader && ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) { enhancer.setUseCache(false); } } enhancer.setSuperclass(proxySuperClass); enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised)); enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE); enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader)); Callback[] callbacks = getCallbacks(rootClass); Class<?>[] types = new Class<?>[callbacks.length]; for (int x = 0; x < types.length; x++) { types[x] = callbacks[x].getClass(); } // fixedInterceptorMap only populated at this point, after getCallbacks call above enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset)); enhancer.setCallbackTypes(types); // Generate the proxy class and create a proxy instance. // 生成代理类并创建代理实例 return createProxyClassAndInstance(enhancer, callbacks); } catch (CodeGenerationException | IllegalArgumentException ex) { throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() + ": Common causes of this problem include using a final class or a non-visible class", ex); } catch (Throwable ex) { // TargetSource.getTarget() failed throw new AopConfigException("Unexpected AOP exception", ex); } }
3.获取JDK动态代理
public Object getProxy(@Nullable ClassLoader classLoader) { logger.info("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource()); // 确定用于给定AOP配置的代理的完整接口集。 Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true); // 判断被代理接口有没有重写equals和hashCode方法 findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); // 为接口创建代理 return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); }
4.总结
代理的具体创建过程与我们之前篇幅中分析的过程大致相同，这里不详细的分析了，感兴趣的同学，可以自己跟踪调试一下代码。
另外在本篇中还有一个疑问就是判断创建代理类型里的 targetClass.isInterface() || Proxy.isProxyClass(targetClass)，这句话会在什么样的场景下生效，知道的同学请留言，万分感激。。
作者：闲来也无事
链接：https://www.jianshu.com/p/ee41c5fee6ff
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
引
上一篇中的分析已经可以获取到适合给定bean的所有增强，接下来就是创建代理了。
/** * 如果需要则包装该bean,例如该bean可以被代理 * Wrap the given bean if necessary, i.e. if it is eligible for being proxied. * @param bean the raw bean instance * @param beanName the name of the bean * @param cacheKey the cache key for metadata access * @return a proxy wrapping the bean, or the raw bean instance as-is */ protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { // 1、如果已经处理过或者不需要创建代理，则返回 if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { return bean; } if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } // 2、创建代理 // 2.1 根据指定的bean获取所有的适合该bean的增强 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { // 2.2 为指定bean创建代理 this.advisedBeans.put(cacheKey, Boolean.TRUE); Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } // 3、缓存 this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }
1.创建代理流程分析
/** * 为给定的bean创建代理 * Create an AOP proxy for the given bean. * @param beanClass the class of the bean * @param beanName the name of the bean * @param specificInterceptors the set of interceptors that is * specific to this bean (may be empty, but not null) * @param targetSource the TargetSource for the proxy, * already pre-configured to access the bean * @return the AOP proxy for the bean * @see #buildAdvisors */ protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) { // 1、当前beanFactory是ConfigurableListableBeanFactory类型，则尝试暴露当前bean的target class if (this.beanFactory instanceof ConfigurableListableBeanFactory) { AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); } // 2、创建ProxyFactory并配置 ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); // 是否直接代理目标类以及接口 if (!proxyFactory.isProxyTargetClass()) { // 确定给定bean是否应该用它的目标类而不是接口进行代理 if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } // 检查给定bean类上的接口，如果合适的话，将它们应用到ProxyFactory。即添加代理接口 else { evaluateProxyInterfaces(beanClass, proxyFactory); } } // 3、确定给定bean的advisors，包括特定的拦截器和公共拦截器，是否适配Advisor接口。 Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); // 设置增强 proxyFactory.addAdvisors(advisors); // 设置代理目标 proxyFactory.setTargetSource(targetSource); // 定制proxyFactory（空的模板方法，可在子类中自己定制） customizeProxyFactory(proxyFactory); // 锁定proxyFactory proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } // 4、创建代理 return proxyFactory.getProxy(getProxyClassLoader()); }
具体的流程处理，代码注释里已经写的很清楚了，接下来看第四步，创建代理的具体过程。
public Object getProxy(@Nullable ClassLoader classLoader) { return createAopProxy().getProxy(classLoader); } protected final synchronized AopProxy createAopProxy() { if (!this.active) { activate(); } return getAopProxyFactory().createAopProxy(this); }
从上面的代码可以看到，创建代理的具体工作委托给了AopProxyFactory的createAopProxy方法。
/** * 创建代理 * 1、config.isOptimize()：判断通过CGLIB创建的代理是否使用了优化策略 * 2、config.isProxyTargetClass()：是否配置了proxy-target-class为true * 3、hasNoUserSuppliedProxyInterfaces(config)：是否存在代理接口 * 4、targetClass.isInterface()-->目标类是否为接口 * 5、Proxy.isProxyClass-->如果targetClass类是代理类，则返回true，否则返回false。 * * @param config the AOP configuration in the form of an AdvisedSupport object * @return * @throws AopConfigException */ @Override public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { // 1、判断是否需要创建CGLIB动态代理 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."); } // todo 这里有疑问 即 // targetClass.isInterface() // Proxy.isProxyClass(targetClass) // 什么情况下会生效 if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { // 创建jdk动态代理 return new JdkDynamicAopProxy(config); } // 创建CGLIB动态代理 return new ObjenesisCglibAopProxy(config); } // 2、默认创建JDK动态代理 else { return new JdkDynamicAopProxy(config); } }
这里我们终于看到了判断CGLIB和JDK动态代理的判断条件，这也是面试会碰到的一个常见的问题。
我们先分析第一个if判断里的条件：
- config.isOptimize()：判断通过CGLIB创建的代理是否使用了优化策略
该条件取值于ProxyConfig类的optimize属性。此属性标记是否对代理进行优化。启动优化通常意味着在代理对象被创建后，增强的修改将不会生效，因此默认值为false。如果exposeProxy设置为true，即使optimize为true也会被忽略。 - config.isProxyTargetClass()：是否配置了proxy-target-class为true
该条件取值于ProxyConfig类的proxyTargetClass属性。此属性标记是否直接对目标类进行代理，而不是通过接口产生代理。 - hasNoUserSuppliedProxyInterfaces(config)：是否存在代理接口
满足以上三者条件的任何一个，则会考虑开启CGLIB动态代理，但是在该if条件里还有另外一层判断 targetClass.isInterface() || Proxy.isProxyClass(targetClass),即如果目标类本身就是一个接口，或者目标类是由Proxy.newProxyInstance()或Proxy.getProxyClass()生成时，则依然采用jdk动态代理。（关于这两种情况的实例，网上没有找到例子，了解的同学可以留言哈！）
到这里，代理的创建过程勉强的分析完了。。。，接下来我们看获取代理的过程。
2.获取CGLIB动态代理
public Object getProxy(@Nullable ClassLoader classLoader) { logger.info("Creating CGLIB proxy: target source is " + this.advised.getTargetSource()); try { Class<?> rootClass = this.advised.getTargetClass(); Class<?> proxySuperClass = rootClass; if (ClassUtils.isCglibProxyClass(rootClass)) { proxySuperClass = rootClass.getSuperclass(); Class<?>[] additionalInterfaces = rootClass.getInterfaces(); for (Class<?> additionalInterface : additionalInterfaces) { this.advised.addInterface(additionalInterface); } } // Validate the class, writing log messages as necessary. validateClassIfNecessary(proxySuperClass, classLoader); // 新建并配置Enhancer Enhancer enhancer = createEnhancer(); if (classLoader != null) { enhancer.setClassLoader(classLoader); if (classLoader instanceof SmartClassLoader && ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) { enhancer.setUseCache(false); } } enhancer.setSuperclass(proxySuperClass); enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised)); enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE); enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader)); Callback[] callbacks = getCallbacks(rootClass); Class<?>[] types = new Class<?>[callbacks.length]; for (int x = 0; x < types.length; x++) { types[x] = callbacks[x].getClass(); } // fixedInterceptorMap only populated at this point, after getCallbacks call above enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset)); enhancer.setCallbackTypes(types); // Generate the proxy class and create a proxy instance. // 生成代理类并创建代理实例 return createProxyClassAndInstance(enhancer, callbacks); } catch (CodeGenerationException | IllegalArgumentException ex) { throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() + ": Common causes of this problem include using a final class or a non-visible class", ex); } catch (Throwable ex) { // TargetSource.getTarget() failed throw new AopConfigException("Unexpected AOP exception", ex); } }
3.获取JDK动态代理
public Object getProxy(@Nullable ClassLoader classLoader) { logger.info("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource()); // 确定用于给定AOP配置的代理的完整接口集。 Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true); // 判断被代理接口有没有重写equals和hashCode方法 findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); // 为接口创建代理 return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); }
4.总结
代理的具体创建过程与我们之前篇幅中分析的过程大致相同，这里不详细的分析了，感兴趣的同学，可以自己跟踪调试一下代码。
另外在本篇中还有一个疑问就是判断创建代理类型里的 targetClass.isInterface() || Proxy.isProxyClass(targetClass)，这句话会在什么样的场景下生效，知道的同学请留言，万分感激。。
