详解Spring框架的AOP功能,附源码
Spring的两大核心功能是IOC和AOP。当我们使用Spring的AOP功能时是很方便的。只需要进行下面的配置即可。
Copy@Component @Aspect public class MyAspect { //PointCut匹配的方法必须是Spring中bean的方法 //Pointcut可以有下列方式来定义或者通过&& || 和!的方式进行组合. //下面定义的这些切入点就可以通过&& ||组合 private static Logger logger = LoggerFactory.getLogger(MyAspect.class); //*:代表方法的返回值可以是任何类型 //整个表达式匹配controller包下面任何的的echo方法,方法入参乐意是任意 @Pointcut("execution(* com.csx.demo.spring.boot.controller.*.echo(..))") public void pointCut1(){} @Before("pointCut1()") public void befor(){ logger.info("前置通知vvvv..."); logger.info("我要做些事情..."); } }
然后再开启注解
Copy//自动选择合适的AOP代理 //传统xml这样配置:<aop:aspectj-autoproxy/> //exposeProxy = true属性设置成true,意思是将动态生成的代理类expose到AopContext的ThreadLocal线程 //可以通过AopContext.currentProxy();获取到生成的动态代理类。 //proxyTargetClass属性设置动态代理使用JDK动态代理还是使用CGlib代理,设置成true是使用CGlib代理,false的话是使用JDK动态代理 //注意:如果使用Spring Boot的话,下面的配置可以不需要。AopAutoConfiguration这个自动配置类中已经自动开启了AOP //默认使用CGLIB动态代理,Spring Boot配置的优先级高于下面的配置 @Configuration @EnableAspectJAutoProxy(exposeProxy = true,proxyTargetClass = false) public class AopConfig { }
通上面的配置,当我们调用controller包下面的任何类的echo方法时就会触发前置通知。其实这个说法不是很准确。因为我们调用的类已经不是我们自己写的类了。而是Spring框架通过动态代理生成的类。
稍微了解一点Spring AOP的同学都会知道Spring的AOP是通过动态代理实现的。那Spring是怎么生成动态代理类,并将Advice织入代理类的呢?整个流程是怎样的呢?下面就分析下Spring生成动态代理类的过程。
需要说明下的是,本博客旨在梳理整个AOP动态代理的过程,细节方面需要大家自己去看。
@EnableAspectJAutoProxy干了些啥
如果让你从头开始研究下AOP的原理,你是不是一头雾水,根本不知道从何入手。但其实看Spring的代码有个小技巧:如果你要研究一个功能,可以从开启这个功能的Enable注解开始看。Spring的很多功能都是通过Enable注解开启的,所以这些注解肯定和这些功能相关。
那么这边我们可以从@EnableAspectJAutoProxy这个注解开始着手,看下这个注解做了些什么操作。
Copy@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(AspectJAutoProxyRegistrar.class) public @interface EnableAspectJAutoProxy { //设置为true的话就一直使用cglib动态代理 //设置为false的话,对于接口使用jdk动态代理,对于类使用cglib代理 boolean proxyTargetClass() default false; boolean exposeProxy() default false; }
看到上面的@Impoer注解,我们很自然就会想到去看AspectJAutoProxyRegistrar这个类。
Copy//AspectJAutoProxyRegistrar源代码 class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar { /** * 主要作用也就是注册AnnotationAwareAspectJAutoProxyCreator */ @Override public void registerBeanDefinitions( AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //注册AnnotationAwareAspectJAutoProxyCreator的BeanDefinition AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class); if (enableAspectJAutoProxy != null) { //给上面注册的BeanDefinition中添加两个属相proxyTargetClass和exposeProxy if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) { AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry); } if (enableAspectJAutoProxy.getBoolean("exposeProxy")) { AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry); } } } }
我们可以看到上面的类中也没干什么特别的事情,就注册了一个BeanDefinition。如果我们点进去看下
AnnotationAwareAspectJAutoProxyCreator这个类的源代码会发现这个类竟然实现了
InstantiationAwareBeanPostProcessor这个接口。熟悉Spring尿性的朋友会敏锐的感觉到Spring可能是在
postProcessBeforeInstantiation或者
postProcessAfterInstantiation这些方法中对Bean进行动态代理的。
“大胆假设,小心求证”,让我们带着这个猜想去看看
AnnotationAwareAspectJAutoProxyCreator到底干了些什么?
AnnotationAwareAspectJAutoProxyCreator生成动态代理类
Copy@Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) { Object cacheKey = getCacheKey(beanClass, beanName); if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) { if (this.advisedBeans.containsKey(cacheKey)) { return null; } if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return null; } } // 一般不指定CustomTargetSource,所以不会进入这段代码,所以关键代码在 // postProcessAfterInitialization中 // Create proxy here if we have a custom TargetSource. // Suppresses unnecessary default instantiation of the target bean: // The TargetSource will handle target instances in a custom fashion. TargetSource targetSource = getCustomTargetSource(beanClass, beanName); if (targetSource != null) { if (StringUtils.hasLength(beanName)) { this.targetSourcedBeans.add(beanName); } Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource); Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } return null; }
下面是创建动态代理类的关键代码。
Copy@Override public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (this.earlyProxyReferences.remove(cacheKey) != bean) { //这边是创建代码类的关键代码 return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; }
Copyprotected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { 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; } // Create proxy if we have advice. //获取当前Bean配置的advice,这步是关键 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { this.advisedBeans.put(cacheKey, Boolean.TRUE); //创建代理 Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }
层层dedug进去我们能看到下面这段代码,我们口中常说的JDK动态代理和Cglib动态代理就是在这边生成的。
Copypublic class DefaultAopProxyFactory implements AopProxyFactory, Serializable { @Override 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() || Proxy.isProxyClass(targetClass)) { //生成JDK动态代理 return new JdkDynamicAopProxy(config); } //生成Cglib动态代理 return new ObjenesisCglibAopProxy(config); } else { return new JdkDynamicAopProxy(config); } } /** * Determine whether the supplied {@link AdvisedSupport} has only the * {@link org.springframework.aop.SpringProxy} interface specified * (or no proxy interfaces specified at all). */ private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) { Class<?>[] ifcs = config.getProxiedInterfaces(); return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]))); }
到此,我们已经简单分析了Spring动态代理类的生成流程。
PS:关于
InstantiationAwareBeanPostProcessor接口和BeanPostProcessor接口大家可以自行了解下,这两个接口是Spring中非常重要的接口。看懂了这两个接口,Spring很多“神秘”的功能你就能理解了。
简单总结
通过上面分析,其实我们发现如果不去看AOP动态代理类生成的细节的话,整个Spring AOP的流程还是挺简单的:
- @EnableAspectJAutoProxy注解通过AopConfigUtils这个工具类注册AnnotationAwareAspectJAutoProxyCreator这个类,这个类实现了InstantiationAwareBeanPostProcessor接口,所以会在Bean实例化前后对Bean做一系列额外的操作;
- AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization中会找出所有和当前Bean相关的Advice,如果找到就创建相应的动态代理类,如果找不到就不生成,返回原始类。
所以整个大流程就这么简单。
一些重要类:
- @EnableAspectJAutoProxy;
- AspectJAutoProxyRegistrar:注册AnnotationAwareAspectJAutoProxyCreator
- AnnotationAwareAspectJAutoProxyCreator:AOP动态代理自动生成的处理类,其他类似的类有AspectJAwareAdvisorAutoProxyCreator和InfrastructureAdvisorAutoProxyCreator等;
- AopConfigUtils:AOP配置工具类
- ProxyFactory:代理工厂
- AopProxy接口:常见实现类ObjenesisCglibAopProxy、JdkDynamicAopProxy
而这些的学习当然不是只看源码就能整明白,肯定有辅助的呀
书籍
除了spring之外,我还整理了一些其他的资料,一并送给大家
需要这些文档资料,关注+转发后,私信“资料”即可查看获取方式
视频:
Spring一百集出于篇幅原因,只展示一部分
需要这些资料,关注+转发后,私信“资料”查看获取方式