（12）spring注解学习之AOP原理--AnnotationAwareAspectJAutoProxyCreator的创建和注册过程

AnnotationAwareAspectJAutoProxyCreator的继承关系

 * 	AnnotationAwareAspectJAutoProxyCreator---------initBeanFactory()
 * 		->AspectJAwareAdvisorAutoProxyCreator
 * 			->AbstractAdvisorAutoProxyCreator------setBeanFactory()
 * 				->AbstractAutoProxyCreator---------setBeanFactory()
 * 					implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 * 				关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory
 * 
 * AbstractAutoProxyCreator.setBeanFactory()
 * AbstractAutoProxyCreator.有后置处理器的逻辑；
 * 
 * AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()
 * 
 * AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

流程：

* 1）、传入配置类，创建ioc容器
* 2）、注册配置类，调用refresh（）刷新容器--创建容器中所有的bean；
* 3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；
* 		1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
* 		2）、给容器中加别的BeanPostProcessor
* 		3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
* 		4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；
* 		5）、注册没实现优先级接口的BeanPostProcessor；
* 		6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；
* 			创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
* 			1）、创建Bean的实例
* 			2）、populateBean；给bean的各种属性赋值
* 			3）、initializeBean：初始化bean；
* 				1）、invokeAwareMethods()：处理Aware接口的方法回调
* 				2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
* 				3）、invokeInitMethods()；执行自定义的初始化方法
* 				4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
* 			4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder
* 		7）、把BeanPostProcessor注册到BeanFactory中；
* 				beanFactory.addBeanPostProcessor(postProcessor);
 * =======以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程========

1. 传入配置类，创建ioc容器

2. 注册配置类，调用refresh（）刷新容器–创建容器中所有的bean

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		this();
		//将配置类传进来
		register(annotatedClasses);
		refresh();
}

3. registerBeanPostProcessors(beanFactory)–注册bean的后置处理器来方便拦截bean的创建

3.1 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

3.2 给容器中加别的BeanPostProcessor

3.3 优先注册实现了PriorityOrdered接口的BeanPostProcessor

// 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<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<BeanPostProcessor>();
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);

3.4 再给容器中注册实现了Ordered接口的BeanPostProcessor

// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<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);

3.5 注册没实现优先级接口的BeanPostProcessor

// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
	BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
	nonOrderedPostProcessors.add(pp);
	if (pp instanceof MergedBeanDefinitionPostProcessor) {
		internalPostProcessors.add(pp);
	}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

3.6 注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中（分析3.3–3.5的过程）

getBean()方法就是创建bean

BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

3.6.1 创建bean的实例

getBean(ppName, BeanPostProcessor.class)
	doGetBean(name, requiredType, null, false)
		     //先检查cache 里面是否有手动注册的bean实例
		1. Object sharedInstance = getSingleton(beanName);
		
		     //如果上一步发现没有注册过的bean实例，就需要创建这个bean，创建之前先标记   
		2. markBeanAsCreated(beanName);
	
		//标记完之后先找出创建这个bean 依赖的其他bean，先创建这些依赖bean 		
	 	3. registerDependentBean(dep, beanName);
	 	
	 	//创建完依赖bean之后开始创建这个bean实例	
	 	4. sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {}) 
	 		4.1 singletonObject = singletonFactory.getObject();
	 			createBean(beanName, mbd, args);
	 					//先尝试通过代理返回这个bean实例
	 					Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
	 					Object bean = doCreateBean(beanName, mbdToUse, args)
	 						populateBean(beanName, mbd, instanceWrapper);
	 						initializeBean
							{
							  applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
							  invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
							  applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
							}	
	 		4.2 addSingleton(beanName, singletonObject);

3.6.2 populateBean—给bean的各种属性赋值

3.6.3 initializeBean：初始化bean

• initializeBean（）
  

3.6.3.1 invokeAwareMethods()

• invokeAwareMethods()：判断bean实例是不是继承了Aware接口，处理Aware接口的方法回调
• AnnotationAwareAspectJAutoProxyCreator确实实现了BeanFactoryAware 接口
  
• AbstractAutoProxyCreator.setBeanFactory()
  
• AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

1. 利用反射得到了 AdvisorFactory工厂
2. 利用适配器获取 AdvisorsBuilder建造器

protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		super.initBeanFactory(beanFactory);
		if (this.aspectJAdvisorFactory == null) {
			this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
		}
		this.aspectJAdvisorsBuilder =
				new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}

3.6.3.2 applyBeanPostProcessorsBeforeInitialization()

3.6.3.3 invokeInitMethods()

3.6.3.4 applyBeanPostProcessorsAfterInitialization()

3.6.4 bean创建实例结束，放在集合里

3.7 把BeanPostProcessor注册到BeanFactory中-- beanFactory.addBeanPostProcessor(postProcessor);

• beanFactory.addBeanPostProcessor(postProcessor)