二、Bean生命周期中AOP的流程
@EnableAspectJAutoProxy注解
源码分析:
下面是@EnableAspectJAutoProxy 的源码：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
//..
}
根据@Import可知，该注解导入了AspectJAutoProxyRegistrar.class
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//往容器里注册组件的关键代码 (如果有必要的话注册AspectJAnnotationAutoProxyCreator)
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
//...代码省略
}
}
该类实现了ImportBeanDefinitionRegistrar 接口 ，也就意味着会直接往容器里注册一个组件。
我们一路点击该方法，下面贴出最后关键的两步代码。
AopConfigUtils类下 1 ==> 2
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
private static BeanDefinition registerOrEscalateApcAsRequired(
Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
//由上面的代码得知要注册的类是AnnotationAwareAspectJAutoProxyCreator
// 下面的AUTO_PROXY_CREATOR_BEAN_NAME值为 "org.springframework.aop.config.internalAutoProxyCreator" ，也就是之后在容器中的id值或者beanName。
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
//...判断容器里是否有，有的话做一些其他操作。
return null;
}
//容器中没有改组件，那么就注册进去
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
//.....省略一些步骤
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
结论:
由以上步骤可得出@EnableAspectJAutoProxy 最终的目的是将
id 为org.springframework.aop.config.internalAutoProxyCreator
class 为AnnotationAwareAspectJAutoProxyCreator 的组件注册进容器中。
那么下面的切入点很明确了，我们就来研究下AnnotationAwareAspectJAutoProxyCreator
AnnotationAwareAspectJAutoProxyCreator 类
1.AnnotationAwareAspectJAutoProxyCreator 介绍
源码分析:
下图是该类的一个继承树
由该图我们可以得出 AnnotationAwareAspectJAutoProxyCreator类 实现了两个我们在IOC中介绍到的两个熟悉接口: BeanFactoryAware 和 BeanPostProcessor 下面会着重再次介绍这两个接口 ，同时也实现了Order接口(该接口后面的源码分析中会用到)
简单回顾:
1. BeanPostProcessor 接口
被称为后置处理器或者增强器。该接口主要是在 bean的初始化前后执行，目的是为了对bean对象做一些扩展操作，主要需实现两个方法
1） Object postProcessBeforeInitialization(Object bean, String beanName) 初始化之前执行。
2）Object postProcessAfterInitialization(Object bean, String beanName) 初始化之后执行。
2.BeanFactoryAware 接口
该接口主要是在 初始化之前回调 也是上面所描述的执行postProcessBeforeInitialization之前执行。同样也是为了提供一些扩展操作，而该接口的扩展方法主要是能够操作beanFactory
void setBeanFactory(BeanFactory beanFactory)
圆规正转： 接下来我们就要看看在AnnotationAwareAspectJAutoProxyCreator的家族类里 主要对这两个接口的实现方法做了哪些操作。(这里只是简单的分析，看一下方法的调用过程。在之后对bean声明周期中aop的流程分析会用到。)
1.setBeanFactory方法的实现
AbstractAdvisorAutoProxyCreator 类
public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
//实现BeanFactoryAware的方法
public void setBeanFactory(BeanFactory beanFactory) {
//会先去父类AbstractAutoProxyCreator 调用setBeanFactory
super.setBeanFactory(beanFactory);
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalArgumentException(
"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
}
//这里调用了initBeanFactory,而它并不是直接掉下面自己的initBeanFactory方法，在子类
//AnnotationAwareAspectJAutoProxyCreator里也实现了该方法,该方法会在下面贴出来。
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory){
this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
}
}
AbstractAutoProxyCreator 类
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
//保存beaFactory
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
}
AnnotationAwareAspectJAutoProxyCreator 类
public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.initBeanFactory(beanFactory);
if (this.aspectJAdvisorFactory == null) {
this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
}
this.aspectJAdvisorsBuilder =
new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}
}
2.postProcessBeforeInitialization 和 postProcessAfterInitialization 以及 postProcessBeforeInstantiation的实现
注: 其中postProcessBeforeInstantiation是我们之后的bean声明周期流程中会涉及到的方法。
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
//Bean init前执行
public Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//什么时候这个判断会成立呢？
//如果不出现循环引用的话，remove方法必定返回Null
//所以这个remove(cacheKey) != bean肯定会成立
//如果发生循环依赖的话，这个判断就不会成立
//而wrapIfNecessary这里就完成AOP代理了
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
//完成AOP代理
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
//这个方法的主要目的就是在不考虑通知的情况下，确认哪些Bean不需要被代理
//1.Advice,Advisor,Pointcut类型的Bean不需要被代理
//2.不是原始Bean被包装过的Bean不需要被代理，例如 ScopedProxyFactoryBean
//实际上并不只是这些Bean不需要被代理，如果没有对应的通知需要被应用到这个Bean上的话
//这个Bean也是不需要被代理的，只不过不是在这个方法中处理的。
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = getCacheKey(beanClass, beanName);
//如果beanName为空 或者这个bean提供了定制的targetSource
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
//advisedBeans是一个map,其中Key是BeanName,value代表了这个Bean是否需要被代理
//如果已经包含了这个key,不需要在进行判断了，直接返回即可。
//因为这个方法的目的就是在实例化前就确认哪些Bean是不需要进行AOP的
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
//说明还没有对这个Bean进行处理过
//在这里回对SpringAOP中的基础设施bean，例如Advice,Pointcut,Advisor做标记
//标志他们不需要被代理，对应的就是将其放入到advisedBeans中，value设置为false
//其次，如果这个Bean不是最原始的Bean,那么也不进行代理，也将其value设置为false
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
//是否为这个Bean提供了定制的TargetSource
//如果提供了定制的TargetSource，那么直接在这一步创建一个代理对象并返回
//一般不会提供
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;
}
}
结论：
通过上面的源码我们大致了解了AnnotationAwareAspectJAutoProxyCreator 的家族继承，并且得出在后面的Bean生命周期流程分析中需要我们重点关注的 setBeanFactory，postProcessBeforeInitialization，postProcessAfterInitialization ，postProcessBeforeInstantiation方法。
2.创建和注册AnnotationAwareAspectJAutoProxyCreator 类的流程分析
1.传入配置类
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfigOfAop.class);
2.注册配置类,调用refresh()刷新容器
AnnotationConfigApplicationContext 类
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
//....省略代码
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
//...省略代码
}
AbstractApplicationContext 类
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
//...省略代码
//该方法被称为Spring的核心方法。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
//创建IOC容器
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.
//这一步是我们本次要研究的 目的是 注册Bean的后置处理器(实现了BeanPostProcecssor接口的类)
//其中就包括我们之前所说的 BeanName为internalAutoProxyCreator的Bean
//也就是注册 AnnotationAwareAspectJAutoProxyCreator 类
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. registerBeanPostProcessors(beanFactory) 方法
最终会调用到下面这个类的registerBeanPostProcessors方法。
PostProcessorRegistrationDelegate 类
这个类与Spring中的任何类没有继承关系，我个人把它理解成spring-context-support 包下的工具类
class PostProcessorRegistrationDelegate {
//省略其他代码....
//由该方法名直观可看出，该方法是注册BeanPostProcessor用的
//该方法的参数分别为 beanFactory 和 applicationContext
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//获取所有实现了BeanPostProcessor接口的 Bean的名字
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
//由于实现了BeanPostProcessor的类也是需要创建Bean，但是他们的创建要早于普通的Bean
//(这里说的普通Bean指的是没有实现BeanPostProcessor的Bean类)
//其中会存在实现了BeanPostProcessor的Bean 依赖普通的Bean，那么该普通的Bean由于要先创建而没有经过该有的后置处理器。而这种操作就会被下面这个BeanPostProcessorChecker后置处理器检查出来。
// 添加 BeanPostProcessorChecker类 也是实现了BeanPostProcessor接口的类
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
//将实现了PriorityOrdered，Ordered还有剩下的 BeanPostProcessor 类分离出来
//实现了priorityOrdered 接口的后置处理器集合 (这里注意存的是Bean对象)
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
//内部后置处理器集合(这里注意存的是Bean对象)
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
//实现了Ordered接口的后置处理器集合 (这里注意存的仅仅只是Bean的名字)
List<String> orderedPostProcessorNames = new ArrayList<>();
//除上面剩下的后置处理器集合 (这里注意存的仅仅只是Bean的名字)
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
//遍历所有的后置处理器BeanName
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//如果是实现了PriorityOrdered的后置处理器，那么就通过getBean创建Bean对象并放入priorityOrdered 接口的后置处理器集合中
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
//如果是既实现了PriorityOrdered又实现了MergedBeanDefinitionPostProcessor的后置处理器，就放入内部后置处理器集合中
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
//如果是实现了Ordered接口的后置处理器，直接把Bean名字放入实现了Ordered接口的后置处理器集合
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
//最终把剩下的后置处理器的名字也归为一类，放到贫民集合中去
nonOrderedPostProcessorNames.add(ppName);
}
}
//下面的代码要注意注册顺序。
// First, register the BeanPostProcessors that implement PriorityOrdered.
//1.先注册priorityOrderedPostProcessors（实现了priorityOrdered 接口的后置处理器集合）中的后置处理器
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
//2.再通过orderedPostProcessorNames集合得到 orderedPostProcessors后置处理器Bean的集合
//将orderedPostProcessors集合中的后置处理器注册进beanFactory中
//重点: 因为我们之前探讨的AnnotationAwareAspectJAutoProxyCreator 类它实现了Ordered接口，因此他会在这里被创建Bean对象。
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
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.
//3.然后再将剩下的后置处理器跟上面一样的方式注册进BeanFactory中
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.
//4.最终注册内部后置处理器到BeanFactory中
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).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
//....省略其他代码
}
上面这段代码 我们要注意各个后置处理器集合存储的类型，以及它们后来注册的顺序
1.首先注册的是实现了priorityOrdered 接口的后置处理器，他们的集合本就是Bean的对象集合，
2.接着会注册实现了Ordered接口的后置处理器，而实现了该接口的集合只是Bean的Name集合，因此相比于上一步多了一个 beanFactory.getBean(beanName)的过程， 而在getBean的过程中会经过Bean创建的生命周期，最终会调用执行实现了priorityOrdered 接口的后置处理器。
3.最终剩下的后置处理器在创建bean的过程中 会分别经过 实现了priorityOrdered 和 Ordered 接口的后置处理器。
结论: priorityOrdered > Ordered > noOrdered(都没实现的后置处理器) 。 因而我们也可以在自定义后置处理器的时候通过实现不同的接口来控制后面后置处理器的创建过程。
4.因为我们之前探讨的AnnotationAwareAspectJAutoProxyCreator 类它实现了Ordered接口，因此他会在上面的方法中调用 beanFactory.getBean(ppName, BeanPostProcessor.class) 被创建Bean对象。接下来我会简单带过Bean的创建过程(之后会有专门的一章来详细分析bean的创建过程)。
AbstractBeanFactory类
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
//...省略代码
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//...省略代码
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//执行createBean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//省略代码...
}
//省略代码
}
AbstractAutowireCapableBeanFactory类
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
//..省略代码
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
//..省略代码
try {
//执行doCreateBean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
//..省略代码
}
//此方法是真正创建Bean的方法。
//创建bean对象的过程大体上包含3步骤
// 1.实例化
// 2.赋值(注入依赖)
// 3.初始化
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//1.实例化
instanceWrapper = createBeanInstance(beanName, mbd, args);
// Initialize the bean instance.
Object exposedObject = bean;
//2.赋值 (注入依赖)
populateBean(beanName, mbd, instanceWrapper);
//3.初始化。(这里是AnnotationAwareAspectJAutoProxyCreator 类创建的关键方法点)
exposedObject = initializeBean(beanName, exposedObject, mbd);
return exposedObject;
}
}
//在Bean的初始化前后也会做一些事情
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
//1.执行实现了的关于 Aware接口的方法 (由于AnnotationAwareAspectJAutoProxyCreator实现了BeanFactoryAware接口，那么首先会进这一步)
invokeAwareMethods(beanName, bean);
//2.执行后置处理器的 前置方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//3.执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
//4.执行后置处理器的 后置方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
//...省略代码
//这里会执行AnnotationAwareAspectJAutoProxyCreator中的setBeanFactory方法，也就是我们在之前所研究的setBeanFactory执行流程。(往beanFactory里面放了一些有关于后面被代理bean所使用的动态代理的工具)
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
//..省略代码
}
至此 AnnotationAwareAspectJAutoProxyCreator 也就被创建并注册到了IOC容器中
( id 为org.springframework.aop.config.internalAutoProxyCreator
class 为AnnotationAwareAspectJAutoProxyCreator 的组件注册进容器中。)
Bean生命周期中 AOP的流程分析
声明: 该分析的过程 是基于普通的且需要动态代理的bean 且第一次创建的前提下。
AnnotationAwareAspectJAutoProxyCreator 创建成Bean对象 注册到IOC容器中 ,同时也放到了后置处理器集合中。(也就是所有的后置处理器也都被注册了进去)，那么接下来会创建剩下的非懒加载的bean 。废话不多说，上代码：
首先从refresh()方法入手。
AbstractApplicationContext类
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
//...省略代码
//该方法被称为Spring的核心方法。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
prepareRefresh();
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
prepareBeanFactory(beanFactory);
try {
postProcessBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
registerBeanPostProcessors(beanFactory);
initMessageSource();
initApplicationEventMulticaster();
onRefresh();
registerListeners();
//创建剩下的非懒加载的bean 这也是我们本次研究的入口
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
}
}
}
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//,,,省略代码
//创建剩下的非懒加载的bean
beanFactory.preInstantiateSingletons();
}
//省略代码。。。。。
}
由于我们本次研究的重点不是bean的创建过程，所以我会省略部分代码及调用过程
beanFactory.preInstantiateSingletons() --> getBean(beanName) --> doGetBean(name, null, null, false) ---> createBean(beanName, mbd, args) --> docreateBean --> initializeBean
在该调用过程中 抓住其中两个方法中出现了关于aop的执行过程
- createBean 中的 resolveBeforeInstantiation 方法
- initializeBean 中的 执行后置处理器applyBeanPostProcessorsAfterInitialization方法
1.createBean 中的 resolveBeforeInstantiation 方法
AbstractAutowireCapableBeanFactory类
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
//...省略代码
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
//...此处省略代码
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//注意这里有句官方的注释，给后置处理器一个机会来处理并返回代理对象(因此我们要研究一下该方法)
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//如果上面返回的bean不是null 那么就直接返回，否则执行下面的doCreateBean方法。
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.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException ex) {
throw ex;
}
catch (ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
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) {
//执行BeanPostProcessorsBeforeInstantiation方法
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//执行BeanPostProcessorsAfterInitialization方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
//执行BeanPostProcessorsBeforeInstantiation方法
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
//遍历所有的后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//判断它是否是实现了InstantiationAwareBeanPostProcessor接口
//看到这个接口我们就会想到之前的 AnnotationAwareAspectJAutoProxyCreator 实现了该接口，而且他也是aop的关键类。
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//是的话，就执行该后置处理器的postProcessBeforeInstantiation方法，该方法在之前也有过分析
//这里明确的一点是，返回的是null
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
//...省略代码
}
这一步最终会调用到AnnotationAwareAspectJAutoProxyCreator 的父类AbstractAutoProxyCreator中的postProcessBeforeInstantiation方法。这个方法我们在前面分析AnnotationAwareAspectJAutoProxyCreator 的时候做过解析（这个方法的主要目的就是在不考虑通知的情况下，确认哪些Bean不需要被代理）。 而我们研究的是需要被代理的类，那么这里的返回值是null。
2.initializeBean 中的 执行后置处理器applyBeanPostProcessorsAfterInitialization方法
AbstractAutowireCapableBeanFactory类
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//执行Aware接口的方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//调用initDestoryAnnotationBeanPostProcessor的postProcessBeforeInitialization方法 处理@PostConstructor注解的方法
//另外还有一部分aware方法也是在这里调用的
wrappedBean = applyBeanPostProcessorsBeforeInitialization方法
(wrappedBean, beanName);
}
try {
//如果实现了initializingBean,会调用afterPropertiesSet方法
//如果XML中配置了init-method属性，会调用对应的初始化方法。
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//在这里完成AOP
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
完成AOP，对应的就来到了applyBeanPostProcessorsAfterInitialization方法
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
实际上就是调用了所有后置处理器的postProcessAfterInitialization方法，继而会来到我们前面分析到的AnnotationAwareAspectJAutoProxyCreator 父类AbstractAutoProxyCreator 的 postProcessAfterInitialization方法中
1.postProcessAfterInitialization 方法的执行
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//什么时候这个判断会成立呢？
//如果不出现循环引用的话，remove方法必定返回Null
//所以这个remove(cacheKey) != bean肯定会成立
//如果发生循环依赖的话，这个判断就不会成立
//而wrapIfNecessary这里就完成AOP代理了
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
//完成AOP代理
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
2.wrapIfNecessary 方法的执行
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
//在postProcessBeforeInstantiation方法中可能已经完成过代理了
//如果已经完成代理了，那么直接返回这个代理的对象。
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
//在PostProcessBeforeInstantiation方法中可能已经将其标记为不需要代理了
//这种情况下，也直接返回这个Bean
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
//跟在PostProcessBeforeInstantiation方法中的逻辑一样
//如果不需要代理，直接返回，同时在advisedBeans中标记成false
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
//获取可以应用到这个Bean上的通知
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
//如果存在通知的话，说明需要被代理
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//到这里创建代理，实际上底层就是New了一个ProxyFactory来创建代理的
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
//如果没有通知的话，也将这个Bean标记为不需要代理。
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
关于代理的具体源码分析，在上一篇文章中已经做了介绍，所以不再赘述。现在我们的重点放在Spring如何解析出来通知，对应的方法就是getAdvicesAndAdvisorsForBean，源码如下:
第一步：
调用org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
//通过findEligibleAdvisors方法返回对应的通知
//这个方法会返回所有能应用在指定Bean上的通知。
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
第二步：
调用org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findEligibleAdvisors
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
//获取到所有的通知
List<Advisor> candidateAdvisors = findCandidateAdvisors();
//从获取到的通知中筛选出能应用到这个Bean上的通知
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
第三步：
调用org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors
//这个方法的目的就是为了获取到所有的通知
protected List<Advisor> findCandidateAdvisors() {
//先调用父类的方法，父类会去查找容器中所有属于Advisor类型的Bean
List<Advisor> advisors = super.findCandidateAdvisors();
//这个类本身会通过一个aspectJAdvisorBuilder来构建通知
//构建的逻辑就是基于@Aspect注解所标注的类中的方法
if (this.aspectJAdvisorsBuilder != null) {
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
//最后返回这些通知
return advisors;
}
第四步:
org.springframework.aop.aspectj.annotation.BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors 构建通知
public List<Advisor> buildAspectJAdvisors() {
List<String> aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
synchronized (this) {
aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
List<Advisor> advisors = new LinkedList<>();
aspectNames = new LinkedList<>();
//会获取到容器中所有的BeanName
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
for (String beanName : beanNames) {
//如果BeanName配置了正则匹配的话，那么就按照正则表达式的匹配规则进行过滤
//默认是没有的，可以认为 isEligibleBean 始终返回true
if (!isEligibleBean(beanName)) {
continue;
}
// We must be careful not to instantiate beans eagerly as in this case they
// would be cached by the Spring container but would not have been weaved.
Class<?> beanType = this.beanFactory.getType(beanName);
if (beanType == null) {
continue;
}
//判断类上是否有@Aspect注解
if (this.advisorFactory.isAspect(beanType)) {
aspectNames.add(beanName);
AspectMetadata amd = new AspectMetadata(beanType, beanName);
//默认就是SINGLETON,代理切面对象是单例的
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
//最后从这个切面实例中解析出所有的通知
//关于通知解析的代码具体就不再分析了。
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory);
}
advisors.addAll(classAdvisors);
}
//....省略了部分代码
return advisors;
}
第五步：
回头从第二步的 第二个注释开始
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#findAdvisorsThatCanApply
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
根据前面所获得的Advisor集合进行遍历，然后根据每个Advisor对应的切点来进行匹配，如果合适就返回。
总结：
对应的简单流程图如下：
