SpringAOP源码解析
1.环境搭建
pom文件加入aspects的依赖
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.1.9.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.1.9.RELEASE</version> </dependency>
定义一个需要被切入的bean
public class MathCaculator { public int div(int i,int j){ System.out.println("MathCaculator.div......."); return i/j; } }
定义切面类
@Aspect public class LogAspects { //抽取公共的切点表达式 //1.本类引用 @Pointcut("execution(public int com.shiki.aop.MathCaculator.*(..))") public void pointCut(){}; //@Before在目标方法之前切入,切入点表达式(指定在哪个方法切入) @Before("pointCut()") public void logStart(JoinPoint joinPoint){ Object[] args = joinPoint.getArgs(); System.out.println(""+joinPoint.getSignature().getName()+"除法运行...参数列表式:{"+ Arrays.asList(args)+"}"); } @After("pointCut()") public void logEnd(JoinPoint joinPoint){ System.out.println(""+joinPoint.getSignature().getName()+"除法结束..."); } //JoinPoint一定要出现在参数表的第一位 @AfterReturning(value = "pointCut()",returning = "result") public void logReturn(JoinPoint joinPoint,Object result){ System.out.println("除法运行...返回值:{"+result+"}"); } @AfterThrowing(value = "pointCut()",throwing = "exception") public void logException(Exception exception){ System.out.println("除法运行...异常信息:{"+exception+"}"); } }
将业务逻辑类和切面类注册到容器中
@EnableAspectJAutoProxy @Configuration public class MainConfigOfAOP { //业务逻辑类加入容器中 @Bean public MathCaculator caculator(){ return new MathCaculator(); } //切面类加入容器中 @Bean public LogAspects logAspects(){ return new LogAspects(); } }
测试代码
public class IOCTest_AOP { @Test public void test01(){ AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfAOP.class); MathCaculator caculator = context.getBean(MathCaculator.class); caculator.div(1,1); context.close(); } }
测试执行结果:
Spring注解版AOP分为三步:
1)、将业务逻辑组件和切面类都加入到容器中,告诉Sprinf哪个是切面类(@Aspect) 2)、在切面类上的每一个通知方法上标注通知注解,告诉Spring何时何地运行(切入点表达式) 3)、开启基于注解的AOP模式
*如何切入AOP源码进行分析?
核心思想:看给容器中注册类什么组件,这个组件什么时候工作,提供了什么功能
从@EnableAspectJAutoProxy入手,查看@EnableAspectJAutoProxy源码
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Import({AspectJAutoProxyRegistrar.class}) public @interface EnableAspectJAutoProxy { boolean proxyTargetClass() default false; boolean exposeProxy() default false; }
注意到EnableAspectJAutoProxy向容器中导入了AspectJAutoProxyRegistrar这个组件,点进源码,在方法入口处打上断点
debug方式启动容器,跟进到这个方法
发现返回了这个bean,即internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator。
可见利用AspectJAutoProxyRegistrar自定义给容器中注册Bean,这个bean就是AnnotationAwareAspectJAutoProxyCreator,顾名思义是“注解通知切面自动代理创建”。
下面研究AnnotationAwareAspectJAutoProxyCreator
2.AnnotationAwareAspectJAutoProxyCreator分析
首先查看AnnotationAwareAspectJAutoProxyCreator的继承关系
AnnotationAwareAspectJAutoProxyCreator的父类AbstractAutoProxyCreator实现了SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware接口。因此AnnotationAwareAspectJAutoProxyCreator具备了bean后置处理器和beanFactory的功能,我们重点来研究AnnotationAwareAspectJAutoProxyCreator作为后置处理器和BeanFactoryAware做了哪些工作,只要知道了这个,那么SpringAOP的流程就差不多清楚了。
在AnnotationAwareAspectJAutoProxyCreator类中没有发现从SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware接口重写的方法,所以到AnnotationAwareAspectJAutoProxyCreator的父类里寻找相关方法。
首先从直接实现SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware接口的AbstractAutoProxyCreator开始找。AbstractAutoProxyCreator里有重写的setBeanFactory方法和后置处理器相关的方法,在这些方法上打上断点。
继续查看AbstractAutoProxyCreator的直接子类AbstractAdvisorAutoProxyCreator,虽然它的父类重写了setBeanFactory方法,但是它又重写了这个方法,先打上断点。
注意到AbstractAdvisorAutoProxyCreator的setBeanFactory方法里调用了一个initBeanFactory方法。
继续查看AbstractAdvisorAutoProxyCreator的子类AspectJAwareAdvisorAutoProxyCreator,没有发现可疑的方法。最后查看AnnotationAwareAspectJAutoProxyCreator,发现了从父类重写的initBeanFactory方法。
它的父类里的initBeanFactory方法里会调用到这里,在这个方法上打上断点。
现在我们已经找出了AnnotationAwareAspectJAutoProxyCreator及其父类中所有与后置处理器和BeanFactoryAware有关的方法并在有意义的方法上(直接返回的不算)打上断点了。整理一下思路。
AbstractAutoProxyCreator.setBeanFactory() AbstractAutoProxyCreator.postProcessBeforeInstantiation() AbstractAutoProxyCreator.postProcessAfterInitialization AbstractAdvisorAutoProxyCreator.setBeanFactory()->initBeanFactory AspectJAwareAdvisorAutoProxyCreator 无 AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()
3.创建和注册AnnotationAwareAspectJAutoProxyCreator
debug方式启动容器,启动之后先来到了AbstractAutoProxyCreator的setBeanFactory方法,这个方法是从我自己写的测试方法过来的,向后跟踪栈轨迹。
注册bean processor用于拦截bean的创建
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext { @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. prepareRefresh(); // Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. // 注册BeanPostProcessor来拦截bean的创建 registerBeanPostProcessors(beanFactory); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); } } } }
3.1BeanPostProcessor注册的过程
这一步就是在创建internalAutoProxyCreator的BeanPostProcessor即AnnotationAwareAspectJAutoProxyCreator
final class PostProcessorRegistrationDelegate { public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { //1.先获取ioc容器已经定义了的需要创建对象的BeanPostProcessor String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; //2.给容器中加别的BeanPostProcessor beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); List<BeanPostProcessor> internalPostProcessors = new ArrayList<>(); List<String> orderedPostProcessorNames = new ArrayList<>(); List<String> nonOrderedPostProcessorNames = new ArrayList<>(); for (String ppName : postProcessorNames) { //3.优先注册实现了PriorityOrdered接口的BeanPostProcessor if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); priorityOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } //4.然后给容器中注册实现了Ordered接口的BeanPostProcessor else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } //5.最后注册没实现优先级接口的BeanPostProcessor else { nonOrderedPostProcessorNames.add(ppName); } } // First, register the BeanPostProcessors that implement PriorityOrdered. sortPostProcessors(priorityOrderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); // Next, register the BeanPostProcessors that implement Ordered. List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(); //6.注册BeanPostProcessor,实际上就是创建BeanPostProcessor对象,保存在容器中 for (String ppName : orderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); orderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } sortPostProcessors(orderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, orderedPostProcessors); // Now, register all regular BeanPostProcessors. List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(); for (String ppName : nonOrderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); nonOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors); // Finally, re-register all internal BeanPostProcessors. sortPostProcessors(internalPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, internalPostProcessors); // Re-register post-processor for detecting inner beans as ApplicationListeners, // moving it to the end of the processor chain (for picking up proxies etc). //7.把注册BeanPostProcessor注册到BeanFactory中 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); } }
3.2AnnotationAwareAspectJAutoProxyCreator的创建过程
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { instanceWrapper = this.createBeanInstance(beanName, mbd, args); } //1.创建bean的实例 Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } Object var7 = mbd.postProcessingLock; synchronized(mbd.postProcessingLock) { if (!mbd.postProcessed) { try { this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable var17) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17); } mbd.postProcessed = true; } } boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName); if (earlySingletonExposure) { if (this.logger.isTraceEnabled()) { this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } this.addSingletonFactory(beanName, () -> { return this.getEarlyBeanReference(beanName, mbd, bean); }); } Object exposedObject = bean; try { //2.给bean的各种属性赋值 this.populateBean(beanName, mbd, instanceWrapper); //3.初始化bean exposedObject = this.initializeBean(beanName, exposedObject, mbd); } catch (Throwable var18) { if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) { throw (BeanCreationException)var18; } throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18); } if (earlySingletonExposure) { Object earlySingletonReference = this.getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) { String[] dependentBeans = this.getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length); String[] var12 = dependentBeans; int var13 = dependentBeans.length; for(int var14 = 0; var14 < var13; ++var14) { String dependentBean = var12[var14]; if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."); } } } } try { this.registerDisposableBeanIfNecessary(beanName, bean, mbd); return exposedObject; } catch (BeanDefinitionValidationException var16) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16); } } }
3.3AnnotationAwareAspectJAutoProxyCreato的初始化过程
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { //1.处理Aware接口的方法回调 if (System.getSecurityManager() != null) { AccessController.doPrivileged(() -> { this.invokeAwareMethods(beanName, bean); return null; }, this.getAccessControlContext()); } else { this.invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; //2.执行后置处理器的postProcessorsBeforeInitialization if (mbd == null || !mbd.isSynthetic()) { wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName); } try { //3.执行自定义的初始化方法 this.invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable var6) { throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6); } //4.执行后置处理器的postProcessorsAfterInitialization if (mbd == null || !mbd.isSynthetic()) { wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; } }
至此,AnnotationAwareAspectJAutoProxyCreator创建成功并注册到了容器中。下一节研究AnnotationAwareAspectJAutoProxyCreator的执行时机。
4.AnnotationAwareAspectJAutoProxyCreator执行时机
AnnotationAwareAspectJAutoProxyCreator已经创建并注册到容器中,它会在bean创建时进行拦截。因此我们只要重点关注AnnotationAwareAspectJAutoProxyCreator是如何对自定义并注册进容器的业务逻辑类进行拦截和处理的。
将断点打到业务逻辑类注册的地方,向前追溯栈轨迹。箭头所指的finishBeanFactoryInitialization方法的作用正是完成BeanFactory的初始化,创建剩下的单实例bean,即当前的业务逻辑类MathCaculator。
4.1自定义的业务逻辑类的创建过程
1)首先遍历获取容器中所有bean,依次创建对象
getBean()–>doGetBean()–>getSingleton–>…
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable { @Override public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... //遍历获取容器中所有bean,依次创建对象 for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { final FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } } }
2)创建bean
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { //1.先从缓存中获取当前bean,如果能获取到,说明bean是之前被创建过的,直接使用,否则再创建 //只要创建好的bean都会被缓存起来(singletonObjects->ConcurrentHashMap) Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { if (this.singletonsCurrentlyInDestruction) { throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); } beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { // Has the singleton object implicitly appeared in the meantime -> // if yes, proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { throw ex; } } catch (BeanCreationException ex) { if (recordSuppressedExceptions) { for (Exception suppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throw ex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } afterSingletonCreation(beanName); } if (newSingleton) { addSingleton(beanName, singletonObject); } } return singletonObject; } } }
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { @Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { if (logger.isTraceEnabled()) { logger.trace("Creating instance of bean '" + beanName + "'"); } RootBeanDefinition mbdToUse = mbd; // Make sure bean class is actually resolved at this point, and // clone the bean definition in case of a dynamically resolved Class // which cannot be stored in the shared merged bean definition. Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. //希望后置处理器能返回一个代理对象,如果能返回代理对象就使用,如果不能就继续 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } try { //如果不能返回代理对象,才真正的去创建一个对象 Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { // A previously detected exception with proper bean creation context already, // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); } } }
后置处理器是如何返回代理对象的?
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { */ @Nullable protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // Make sure bean class is actually resolved at this point. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { // bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean; } @Nullable protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) { //拿到所有BeanPostProccessor,如果是InstantiationAwareBeanPostProcessor,就执行postProcessBeforeInstantiation方法 for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName); if (result != null) { return result; } } } return null; } }
而AnnotationAwareAspectJAutoProxyCreator正是一个InstantiationAwareBeanPostProcessor。
*InstantiationAwareBeanPostProcessor和BeanPostProcessor的区别:
BeanPostProcessor是在bean创建初始化完成后调用的;
InstantiationAwareBeanPostProcessor是在bean实例化之前尝试用后置处理器返回对象的。
所以AnnotationAwareAspectJAutoProxyCreator会在任何bean创建之前先尝试返回bean的实例。
5.创建AOP动态代理
由上一节可知,AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截,会调用postProcessBeforeInstantiation。因此这节重点研究postProcessBeforeInstantiation方法做了什么,重点关注自定义的业务逻辑类MathCaculator和切面类LogAspects。
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware { @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) { Object cacheKey = getCacheKey(beanClass, beanName); if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) { //1.判断当前bean是否在advisedBeans中(保存了所有需要增强的bean) if (this.advisedBeans.containsKey(cacheKey)) { return null; } if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return null; } } // 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; } //2.判断当前bean是否是基础类型的(Advice,Pointcut,Advisor,AopInfrastructureBean类型) protected boolean isInfrastructureClass(Class<?> beanClass) { boolean retVal = Advice.class.isAssignableFrom(beanClass) || Pointcut.class.isAssignableFrom(beanClass) || Advisor.class.isAssignableFrom(beanClass) || AopInfrastructureBean.class.isAssignableFrom(beanClass); if (retVal && logger.isTraceEnabled()) { logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]"); } return retVal; } //3.是否需要跳过 protected boolean shouldSkip(Class<?> beanClass, String beanName) { return AutoProxyUtils.isOriginalInstance(beanName, beanClass); } } //创建代理对象 @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; } //包装对象 protected 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. //1.获取当前bean的所有增强器(通知方法) Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { //2.保存当前bean在advisedBeans中 this.advisedBeans.put(cacheKey, Boolean.TRUE); //3.如果当前bean需要增强,创建当前对象代理对象 Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } //4.给容器中返回了当前对象使用cglib增强了的代理对象 //以后容器中获取到的就是这个组件增强后的代理对象,代理对象就会执行通知方法的流程 this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware { //如果当前bean需要增强,创建当前对象代理对象 protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) { if (this.beanFactory instanceof ConfigurableListableBeanFactory) { AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); } ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); if (!proxyFactory.isProxyTargetClass()) { if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } else { evaluateProxyInterfaces(beanClass, proxyFactory); } } //1.获取所有增强器(通知方法) Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); //2.保存到proxyFactory proxyFactory.addAdvisors(advisors); proxyFactory.setTargetSource(targetSource); customizeProxyFactory(proxyFactory); proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } //3.创建代理对象 return proxyFactory.getProxy(getProxyClassLoader()); } }
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable { //由spring决定是使用jdk动态代理还是cglib来创建代理对象 @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)) { return new JdkDynamicAopProxy(config); } 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]))); } }
至此,藉由SpringAOP创建出了目标类的代理对象,以后容器中获取到的就是这个组件增强后的代理对象,代理对象就会执行通知方法的流程。
6.各种增强器的执行顺序是如何和方法调用进行结合的?
由上一节可知,容器中保存了组件的代理对象(cglib增强后的对象),这个对象里面保存了详细信息(比如增强器,目标对象,xxx)。
目标方法的执行进入了这里。
class CglibAopProxy implements AopProxy, Serializable { //拦截目标方法的执行 @Override @Nullable public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { Object oldProxy = null; boolean setProxyContext = false; Object target = null; TargetSource targetSource = this.advised.getTargetSource(); try { if (this.advised.exposeProxy) { // Make invocation available if necessary. oldProxy = AopContext.setCurrentProxy(proxy); setProxyContext = true; } // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool... target = targetSource.getTarget(); Class<?> targetClass = (target != null ? target.getClass() : null); //根据proxyFactory获取目标方法的拦截器链 //拦截器链(每一个通知方法又被包装为方法拦截器,利用MethodInterceptor机制) List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); Object retVal; // Check whether we only have one InvokerInterceptor: that is, // no real advice, but just reflective invocation of the target. if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) { // We can skip creating a MethodInvocation: just invoke the target directly. // Note that the final invoker must be an InvokerInterceptor, so we know // it does nothing but a reflective operation on the target, and no hot // swapping or fancy proxying. Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args); retVal = methodProxy.invoke(target, argsToUse); } else { // We need to create a method invocation... retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed(); } retVal = processReturnType(proxy, target, method, retVal); return retVal; } finally { if (target != null && !targetSource.isStatic()) { targetSource.releaseTarget(target); } if (setProxyContext) { // Restore old proxy. AopContext.setCurrentProxy(oldProxy); } } } }
当前的代理对象包含一个默认的ExposeInvocationInterceptor拦截器和4个自定义的拦截器。
public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable { @Override public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException { List<MethodInterceptor> interceptors = new ArrayList<>(3); Advice advice = advisor.getAdvice(); //如果是MethodInterceptor直接加入数组 if (advice instanceof MethodInterceptor) { interceptors.add((MethodInterceptor) advice); } //如果不是用AdvisorAdapter转为MethodInterceptor for (AdvisorAdapter adapter : this.adapters) { if (adapter.supportsAdvice(advice)) { interceptors.add(adapter.getInterceptor(advisor)); } } if (interceptors.isEmpty()) { throw new UnknownAdviceTypeException(advisor.getAdvice()); } //返回MethodInterceptor数组 return interceptors.toArray(new MethodInterceptor[0]); } }
/** * 包裹MethodBeforeAdvice的方法拦截器 */ @SuppressWarnings("serial") public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable { private final MethodBeforeAdvice advice; /** * Create a new MethodBeforeAdviceInterceptor for the given advice. * @param advice the MethodBeforeAdvice to wrap */ public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) { Assert.notNull(advice, "Advice must not be null"); this.advice = advice; } @Override public Object invoke(MethodInvocation mi) throws Throwable { this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis()); return mi.proceed(); } }
/** *包裹AfterReturningAdvice的方法拦截器 */ @SuppressWarnings("serial") public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable { private final AfterReturningAdvice advice; /** * Create a new AfterReturningAdviceInterceptor for the given advice. * @param advice the AfterReturningAdvice to wrap */ public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) { Assert.notNull(advice, "Advice must not be null"); this.advice = advice; } @Override public Object invoke(MethodInvocation mi) throws Throwable { Object retVal = mi.proceed(); this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis()); return retVal; } }
/** *包裹AspectJAfterAdvice的方法拦截器 */ public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice, Serializable { public AspectJAfterAdvice( Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) { super(aspectJBeforeAdviceMethod, pointcut, aif); } @Override public Object invoke(MethodInvocation mi) throws Throwable { try { return mi.proceed(); } finally { invokeAdviceMethod(getJoinPointMatch(), null, null); } } @Override public boolean isBeforeAdvice() { return false; } @Override public boolean isAfterAdvice() { return true; } }
在拦截器链中,每一个拦截器最后都会调用MethodInvocation的proceed方法,如果简单的按拦截器链进行链式调用的话,MethodInvocation的proceed方法就会执行N次(N等于拦截器个数),更直观的讲,我们调用了caculator.div(1,1)方法,按照这个逻辑,会打印出4条记录(4个自定义拦截器)
MathCaculator.div....... MathCaculator.div....... MathCaculator.div....... MathCaculator.div....... MathCaculator.div.......
这显然不是我们想要的结果。那么Spring是如何控制执行链逻辑的?
public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable { protected final Object proxy; @Nullable protected final Object target; protected final Method method; protected Object[] arguments = new Object[0]; @Nullable private final Class<?> targetClass; /** * Lazily initialized map of user-specific attributes for this invocation. */ @Nullable private Map<String, Object> userAttributes; /** * List of MethodInterceptor and InterceptorAndDynamicMethodMatcher * that need dynamic checks. */ protected final List<?> interceptorsAndDynamicMethodMatchers; /** * Index from 0 of the current interceptor we're invoking. * -1 until we invoke: then the current interceptor. */ private int currentInterceptorIndex = -1; protected ReflectiveMethodInvocation( Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments, @Nullable Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) { this.proxy = proxy; this.target = target; this.targetClass = targetClass; this.method = BridgeMethodResolver.findBridgedMethod(method); this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments); this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers; } @Override public final Object getProxy() { return this.proxy; } @Override @Nullable public final Object getThis() { return this.target; } @Override public final AccessibleObject getStaticPart() { return this.method; } @Override public final Method getMethod() { return this.method; } @Override public final Object[] getArguments() { return this.arguments; } @Override public void setArguments(Object... arguments) { this.arguments = arguments; } @Override @Nullable public Object proceed() throws Throwable { // We start with an index of -1 and increment early. //1.如果没有拦截器直接执行目标方法,或者拦截器索引和拦截器数组-1大小一样(执行到了最后一个拦截器)执行目标方法 if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { return invokeJoinpoint(); } Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) { // Evaluate dynamic method matcher here: static part will already have // been evaluated and found to match. InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice; Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass()); //2.链式获取每一个拦截器,拦截器执行invoke方法,每一个拦截器等待上一个拦截器执行完成返回后再执行 if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) { return dm.interceptor.invoke(this); } else { // Dynamic matching failed. // Skip this interceptor and invoke the next in the chain. return proceed(); } } else { // It's an interceptor, so we just invoke it: The pointcut will have // been evaluated statically before this object was constructed. return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); } } @Nullable protected Object invokeJoinpoint() throws Throwable { return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments); } @Override public MethodInvocation invocableClone() { Object[] cloneArguments = this.arguments; if (this.arguments.length > 0) { // Build an independent copy of the arguments array. cloneArguments = new Object[this.arguments.length]; System.arraycopy(this.arguments, 0, cloneArguments, 0, this.arguments.length); } return invocableClone(cloneArguments); } @Override public MethodInvocation invocableClone(Object... arguments) { // Force initialization of the user attributes Map, // for having a shared Map reference in the clone. if (this.userAttributes == null) { this.userAttributes = new HashMap<>(); } // Create the MethodInvocation clone. try { ReflectiveMethodInvocation clone = (ReflectiveMethodInvocation) clone(); clone.arguments = arguments; return clone; } catch (CloneNotSupportedException ex) { throw new IllegalStateException( "Should be able to clone object of type [" + getClass() + "]: " + ex); } } @Override public void setUserAttribute(String key, @Nullable Object value) { if (value != null) { if (this.userAttributes == null) { this.userAttributes = new HashMap<>(); } this.userAttributes.put(key, value); } else { if (this.userAttributes != null) { this.userAttributes.remove(key); } } } @Override @Nullable public Object getUserAttribute(String key) { return (this.userAttributes != null ? this.userAttributes.get(key) : null); } public Map<String, Object> getUserAttributes() { if (this.userAttributes == null) { this.userAttributes = new HashMap<>(); } return this.userAttributes; } @Override public String toString() { // Don't do toString on target, it may be proxied. StringBuilder sb = new StringBuilder("ReflectiveMethodInvocation: "); sb.append(this.method).append("; "); if (this.target == null) { sb.append("target is null"); } else { sb.append("target is of class [").append(this.target.getClass().getName()).append(']'); } return sb.toString(); } }
上述代码proceed方法简单理解就是,在拦截器链中,每一个拦截器都是将后续所有拦截器作为一个整体来调用proceed方法。画图比较直观:
7.总结
至此,SpringAOP的原理差不多介绍完毕。我认为需要掌握以下几点:
1.AnnotationAwareAspectJAutoProxyCreator的创建和注册过程;
2.AnnotationAwareAspectJAutoProxyCreator是如何拦截bean的创建的;
3.AnnotationAwareAspectJAutoProxyCreator是如何生成代理对象的;
4.代理对象的拦截器链的构造过程和执行机制。
- 点赞
- 收藏
- 分享
- 文章举报
- Spring5.0源码深度解析之SpringBean的Aop源码分析
- Spring中AOP相关源码解析
- 杨老师课堂之springAOP事务控制源码解析
- Spring5.0源码深度解析之SpringBean的Aop通知调用链源码分析
- Spring AOP源码解析——AOP动态代理原理和实现方式
- Spring源码分析:AOP源码解析(下篇)
- Spring AOP源码解析:一:Advisor获取流程
- Spring核心框架 - AOP的原理及源码解析
- SpringBoot源码解析:AOP思想以及相应的应用
- SpringAOP源码解析之执行篇
- Spring源码分析:AOP源码解析(上篇)
- P7面试必备--springAOP底层源码深度解析
- Spring源码解析之四 ------ AOP原理和源码分析
- spring源码aop解析(一)
- Spring中AOP源码深入解析
- spring源码解析-AOP原理
- Spring----AOP面向切面编程例子解析(附源码)
- Spring中AOP源码深入解析
- spring aop自动配置源码解析
- Spring AOP功能源码解析