7.2 动态AOP自定义标签

  1. public class AopNamespaceHandler extends NamespaceHandlerSupport {
  3.     /**
  4.      * Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
  5.      * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
  6.      * and '{@code scoped-proxy}' tags.
  7.      */
  8.     @Override
  9.     public void init() {
  10.         // In 2.0 XSD as well as in 2.5+ XSDs
  11.         registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
  12.         registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
  13.         registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
  15.         // Only in 2.0 XSD: moved to context namespace in 2.5+
  16.         registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
  17.     }
  19. }

在解析配置文件的时候，一旦遇到aspectj-autoproxy注解时是使用解析器 AspectJAutoProxyBeanDefinitionParser进行解析。

7.2.1 注册AspectJAnnotationAutoProxyCreator

所有解析器，是对BeanDefinitionParser接口的统一实现，入口都是从parse函数开始的。

  1.     AspectJAutoProxyBeanDefinitionParser
  2.     public BeanDefinition parse(Element element, ParserContext parserContext) {
  3.         //注册 AspectJAnnotationAutoProxyCreator 
  4.         AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
  5.         //对于注解中子类的处理
  6.         extendBeanDefinition(element, parserContext);
  7.         return null;
  8.     }
  10.     public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
  11.             ParserContext parserContext, Element sourceElement) {
  13.         BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
  14.                 parserContext.getRegistry(), parserContext.extractSource(sourceElement));
  15.         //对于proxy-target-class以及expose-proxy的属性的处理
  16.         useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
  17.         //注册并通知，便于监听器做进一步处理
  18.         registerComponentIfNecessary(beanDefinition, parserContext);
  19.     }
  21.     private static BeanDefinition registerOrEscalateApcAsRequired(
  22.             Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
  24.         Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  25.         //如果已经存在了自动代理创建器 且存在的自动代理创建器与现在的不一致，那么 需要根据优先级来判断到底需要使用哪个
  26.         if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
  27.             BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
  28.             if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
  29.                 int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
  30.                 int requiredPriority = findPriorityForClass(cls);
  31.                 if (currentPriority < requiredPriority) {
  32.                     //改变bean最重要的就是改变bean所对应的className属性
  33.                     apcDefinition.setBeanClassName(cls.getName());
  34.                 }
  35.             }
  36.             //如果已经存在自动代理创建器与将要创建的一致，那么无须再次创建。
  37.             return null;
  38.         }
  40.         RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
  41.         beanDefinition.setSource(source);
  42.         beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
  43.         beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  44.         registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
  45.         return beanDefinition;
  46.     }

2 处理proxy-target-class以及 expose-proxy 属性

  1.     private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
  2.         if (sourceElement != null) {
  3.             //对于 proxy-target-class 的处理
  4.             boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
  5.             if (proxyTargetClass) {
  6.                 AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
  7.             }
  8.             //对于 expose-proxy 的处理
  9.             boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
  10.             if (exposeProxy) {
  11.                 AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
  12.             }
  13.         }
  14.     }
  16.     public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
  17.         if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
  18.             BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
  19.             definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
  20.         }
  21.     }
  23.     public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
  24.         if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
  25.             BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
  26.             definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
  27.         }
  28.     }
  • proxy-target-class ：Spring AOP部分部分使用JDK动态代理或者CGLIB来为目标对象创建代理(建议尽量使用JDK动态代理)。如果被代理的目标对象实现了至少一个接口，则会使用JDK动态代理。所有该目标类型实现的接口都将被代理。若该目标对象没有实现任何接口，则创建一个CGLIB代理。如果需要强制使用CGLIB，需要考虑以下两个问题
    • 无法通知final方法，因为他们不能重写
    • 需要将cglib二进制发行包放在classpath下面。

与之相比，JDK本身提供了动态代理，强制使用CGLIB代理需要将proxy-target-class设置为true。
而在实际使用的过程中你会发现细节问题的差别。

  • JDK动态代理：其代理对象必须是某个接口的实现，他是通过在运行期间创建一个接口的实现类来完成对目标对象的代理。
  • CGLIB代理：其原理类似于JDK动态代理，只是它在运行期间代理对象是针对目标类扩展的子类，CGLIB是高效的代码生成包，底层是依靠ASM(开源的java字节码编辑类库)操作字节码实现的，性能比JDK强。
  • expose-proxy：有时候目标对象内部的自我调用无法实施切面中的增强。

例如Transactional注解中的问题,AopContext.currentProxy()

  1.     public void hello() {
  2.         System.out.println("hello");
  3.         TestBean self = (TestBean) AopContext.currentProxy();  // 获取当前代理
  4.         self.hi();
  5.     }
  7.     public void hi() {
  8.         System.out.println("hi");
  9.     }

7.3 创建AOP代理

AnnotationAwareAspectJAutoProxyCreator的类层次结构如下
AnnotationAwareAspectJAutoProxyCreator.png

AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口，而实现BeanPostProcessor后，当Spring加载这个Bean会在实例化前调用其postProcessAfterInitialization方法，而我们的AOP逻辑分析也由此开始。

  1.     public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
  2.         if (bean != null) {
  3.             //根据给定的bean的class和name出一个key，格式：beanClassName_beanName
  4.             Object cacheKey = getCacheKey(bean.getClass(), beanName);
  5.             if (this.earlyProxyReferences.remove(cacheKey) != bean) {
  6.                 //如果它适合被代理，则需要封装指定bean
  7.                 return wrapIfNecessary(bean, beanName, cacheKey);
  8.             }
  9.         }
  10.         return bean;
  11.     }
  12.     protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  13.         //如果已经处理过
  14.         if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
  15.             return bean;
  16.         }
  17.         //无须增强
  18.         if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
  19.             return bean;
  20.         }
  21.         //给定的bean类是否代表一个基础设施类，基础设施类不应代理，或者配置了指定bean需要自动代理
  22.         if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
  23.             this.advisedBeans.put(cacheKey, Boolean.FALSE);
  24.             return bean;
  25.         }
  27.         //如果存在增强方法则创建代理
  28.         Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  29.         if (specificInterceptors != DO_NOT_PROXY) {
  30.             this.advisedBeans.put(cacheKey, Boolean.TRUE);
  31.             //创建代理
  32.             Object proxy = createProxy(
  33.                     bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  34.             this.proxyTypes.put(cacheKey, proxy.getClass());
  35.             return proxy;
  36.         }
  38.         this.advisedBeans.put(cacheKey, Boolean.FALSE);
  39.         return bean;
  40.     }