上节我们通过注解@EnableAspectJAutoProxy作为Aop源码分析的入口，最后发现做了那么多工作仅仅是把AnnotationAwareAspectJAutoProxyCreator这个后置处理器注册和创建并进行添加操作，为啥说AnnotationAwareAspectJAutoProxyCreator是一个后置处理器，可以通过它的继承实现关系来发现如下图所示：
AnnotationAwareAspectJAutoProxyCreator.png
从它的家族类图不难发现AnnotationAwareAspectJAutoProxyCreator 是一个InstantiationAwareBeanPostProcessor类型的后置处理器，既然前面我们分析它的创建和注册过程，本节来看看在Aop中是如何用到它的，同样我们还是 以我们的测试类作为入口进行分析，测试代码如下：
//Aop测试
@Test
public void testAop(){
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAop.class);
MathCalculator calculator = applicationContext.getBean(MathCalculator.class);
calculator.div(10,5);
applicationContext.close();
}
分析的入口还是以我们AnnotationConfigApplicationContext容器的创建作为分析入口，跟踪代码来到：
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
this.register(componentClasses);
this.refresh();
}
首先Dbug来到了AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(...)构造方法，其中核心的是 this.refresh()方法，此方法的作用之前也已经提到过了，继续跟踪代码来到此方法，其中如下的代码片段值得我们注意：
this.finishBeanFactoryInitialization(beanFactory);
这段代码主要的目的是完成我们beanFactory的初始化工作和创建剩下未创建的单实例bean（这里也就是我们自己的bean），继续跟踪代码来到：
首先一进方法对我们的beanFactory进行判断，具体如下：
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
- 上述是判断容器中是否id为conversionService 的bean ，其他的都是类似的操作这里不在一一仔细看了，继续跟踪代码来到如下的代码片段：
beanFactory.freezeConfiguration();
这段代码的意思是，将我们的 bean的定义的元信息进行缓存，不在做进一步的变化，跟踪代码来到DefaultListableBeanFactory类中：
private volatile String[] frozenBeanDefinitionNames;
public void freezeConfiguration() {
this.configurationFrozen = true;
this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}
Aop源码分析1.png
接着我们来到如下的代码片段：
beanFactory.preInstantiateSingletons();
上述这段代码主要的目的是初始化剩下的单实例bean，跟踪代码来到：
List<String> beanNames = new ArrayList(this.beanDefinitionNames);
首先从beanDefinitionNames中获取所有的bean的definition信息,接着是循环创建每一个bean
image.png
获取到bean的definition 信息之后进行while循环处理，跟踪代码会发现其实质做了如下的判断处理：
-
bean的定义是否抽象，是否不是单例的，是否是懒加载的。
-
通过如下代码来判断bean是否是一个BeanFactory类型的bean
if (this.isFactoryBean(beanName)) {
bean = this.getBean("&" + beanName);
break;
}
如果不是工厂Bean的话，通过this.getBean(beanName)来创建bean，继续跟踪代码来到类AbstractFactory类中：
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
继续跟踪代码来到#doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)方法：
- 首先通过如下代码来获取当前要创建bean的name值
String beanName = this.transformedBeanName(name);
- 接着是通过如下代码从缓存中通过beanName去获取单实例bean，如果能获取到则说明该beanBean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
Object sharedInstance = this.getSingleton(beanName);
这里分为两种情况，如果从缓存拿到了当前要创建的bean，直接返回到方法上一层继续循环遍历下一个待创建的bean，这里我截个没有创建的bean的图来走下后面的创建流程：
image.png
图中所显示的bean我们发现从缓存中没有获取到，那我们继续跟踪代码来到：
- 跟踪代码发下期间通过如下代码来检查bean 的定义信息是否在父BeanFactory中存在，如果存在的话，调用对应工厂Bean的方法去创建bean对象
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
...已省略.....
- 通过下面的操作来标记当前bean已经被创建过了
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
- 通过如下的操作来处理bean与bean之间依赖的问题
- 1.首先获取当前bean的定义信息
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
- 2.通过如下操作来先获取当前bean所依赖的其他bean组件，如果存在依赖的bean的话，通过getBean(...)进行依赖bean组件的创建
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var24) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
}
}
}
- 接下来是真正的创建过程：
this.createBean(beanName, mbd, args);
继续跟踪代码来到AbstractAutowireCapableBeanFactory类中的#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)方法，具体来看如下分析：
image.png
其中上图中所示的是方法的参数 mbd参数为bean的定义的信息
- 期间通过如下代码片段操作：
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
通过方法#resolveBeforeInstantiation(beanName, mbdToUse)的拦截，让BeanPostProcessor【后置处理器】尝试着返回一个代理对象，继续跟踪代码来到：
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = this.determineTargetType(beanName, mbd);
if (targetType != null) {
bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = bean != null;
}
return bean;
}
-
首先在此方法中我们的InstantiationAwareBeanPostProcessor后置处理器先执行了
-
接着进入if语句执行我们的
bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
进去方法来到：
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
Iterator var3 = this.getBeanPostProcessors().iterator();
while(var3.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var3.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
获取所有的BeanPostProcessor接着遍历处理类型是InstantiationAwareBeanPostProcessor的后置处理器然后调用它的#postProcessBeforeInstantiation（...）方法具体去处理，至于处理的逻辑这里不在细看，继续跟踪代码来到：
if (beanInstance != null) {
return beanInstance;
}
如果没有获取代理对象，那么进行对象的真正创建过程：
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
创建过程的细节，在上一篇中我们已经详细的说过了，这里不在累赘，其实到这里我们本篇的核心已经说完了，不知还记得开篇的那张类的依赖关系图，我们说了AnnotationAwareAspectJAutoProxyCreator实质是一个InstantiationAwareBeanPostProcessor类型的后置处理器，通过我们一步步的Dbug发现，在我们的每一个Bean的创建之前都会调用InstantiationAwareBeanPostProcessor类型的#postProcessBeforeInstantiation（...）方法进行相关的处理操作，既然知道了AnnotationAwareAspectJAutoProxyCreator的作用，那么在下节我们来分析#postProcessBeforeInstantiation（...）调用此方法具体做了什么？
网友评论