SpringIOC注解启动原理，后置处理器BeanPostProcessor，Spring-Aop原理，Spring-Transaction原理（个人笔记）

【Spring注解驱动原理】

一.this()：

将6种默认的【beanFactory后置处理器】注册到 applicationContext 容器中，
这里的后置处理器分2种,后面会有专门的 invokeBeanFactoryPostProcessors(beanFactory) 方法执行：
(1)【BeanDefinitionRegistryPostProcessor】：1种 【ConfigurationClassPostProcessor】 用来解析Configuration配置类
(2)【BeanFactoryPostProcessor】：5种 【PersistenceAnnotationBeanPostProcessor】【AutowiredAnnotationBeanPostProcessor】
【CommonAnnotationBeanPostProcessor】【EventListenerMethodProcessor】【DefaultEventListenerFactory】
总结：初始化 applicationContext IOC容器

二.register()：

总结：将配置类 【xxxConfig】 注册到applicationContext容器中，至此,applicationContext容器中一共有7个bean信息

三.refresh()：

1.prepareRefresh()：
总结：刷新前的准备工作

2.obtainFreshBeanFactory()：
2.1：读取xml等配置文件中的bean定义信息转换为beanDefinition注册到beanFactory中
2.2：创建beanFactory对象
总结：创建beanFactory对象

3.prepareBeanFactory(beanFactory)：
总结：
3.1：设置类加载器，表达式解析器（SPEL）,属性解析器，忽略部分接口不注入，注册依赖
3.2：【ApplicationContextAwareProcessor bean后置处理器】【ApplicationListenerDetector bean后置处理器】注册到beanFactory中

4.postProcessBeanFactory(beanFactory)：
总结：空的方法，待子类继承

5.invokeBeanFactoryPostProcessors(beanFactory)：
5.1：获取之前注册到容器中的【ConfigurationClassPostProcessor beanFactory后置处理器】用来解析和增强Configuration配置类：
5.1.1：执行 invokeBeanDefinitionRegistryPostProcessors()方法：
解析@Configuration配置类，将配置类中的@Import,@ComponentScan,@Bean等类解析出来转换为 beanDefinition,然后注册到beanFactory中
5.1.2：执行 invokeBeanFactoryPostProcessors() 方法：
增强@Configuration配置类，将【ImportAwareBeanPostProcessor bean后置处理器】注册到beanFactory中
总结：解析和增强 @Configuration配置类，将配置类的注解标记的类转换为 beanDefinition信息 和【ImportAwareBeanPostProcessor bean后置处理器】注册到beanFactory中

6.registerBeanPostProcessors(beanFactory)：
总结：将beanDefinition类型为bean后置处理器的实例化为【BeanPostProcessor bean后置处理器】注册到beanFactory中

7.initMessageSource();
总结：将【MessageSource 国际化信息组件】实例化后添加到beanFactory的【registeredSingletons】中

8.initApplicationEventMulticaster()：
总结：将【ApplicationEventMulticaster 事件派发器】实例化后添加到beanFactory的【registeredSingletons】中

9.onRefresh()：
总结：空的方法，待子类继承

10.registerListeners()：
总结：将【ApplicationListener 事件监听器】注册到 【ApplicationEventMulticaster 事件派发器】中

11.finishBeanFactoryInitialization(beanFactory)：
11.1：FactoryBean类型的 非抽象&单例&非懒加载 bean 通过FactoryBean方法来创建
11.2：非FactoryBean类型的 非抽象&单例&非懒加载 bean 通过getBean()方法来创建:
11.2.1：先尝试从缓存【SingletonObjects】中获取bean，缓存【SingletonObjects】中没有，开始bean的创建对象流程
11.2.2：判断当前bean是否有依赖的其他bean,如果有，先创建依赖的其他bean
  (1)获取所有【InstantiationAwareBeanPostProcessor】后置处理器并执行【postProcessBeforeInstantiation()】方法             /**AOP后置处理器创建代理对象返回 【AnnotationAwareAspectJAutoProxyCreator】 before()
  (2.1)如果上面方法有返回对象，执行 【postProcessAfterInstantiation()】方法，尝试返回proxy bean对象
  (2.2)如果上面方法没有返回对象，执行 doCreateBean()方法创建bean对象
（3）调用构造函数 construct()，创建空的bean
（4）获取所有【MergedBeanDefinitionPostProcessor】后置处理器并执行【postProcessMergedBeanDefinition()】方法     /**自动装配后置处理器 【AutowiredAnnotationBeanPostProcessor】解析@Autowire注解
（5）进入 populateBean()方法，实现注入属性，属性赋值
（5.2）获取所有【InstantiationAwareBeanPostProcessor】后置处理器并执行【postProcessProperties()】方法                   /**自动装配后置处理器 【AutowiredAnnotationBeanPostProcessor】 注入@Autowire属性
（6）获取所有【BeanPostProcessor】后置处理器并执行【postProcessBeforeInitialization()】方法
（7）执行bean的【init()】方法
（8）获取所有【BeanPostProcessor】后置处理器并执行【postProcessAfterInitialization()】方法
（9）创建bean对象完毕,放进缓存【SingletonObjects】

 【后置处理器BeanPostProcessor原理】

1、InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(beanClass, beanName)
该方法在创建对象之前会先掉用，如果有返回实例则直接使用不会去走下面创建对象的逻辑,并在之后执行 BeanPostProcessor.postProcessAfterInitialization(result,
beanName)
2、SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(beanClass, beanName)
如果需要的话，会在实例化对象之前执行
3、MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(mbd, beanType, beanName)
在对象实例化完毕 注入属性之前执行
4、InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)
在bean创建完毕实例化之前执行
5、InstantiationAwareBeanPostProcessor.postProcessProperties(pvs, filteredPds, bw.getWrappedInstance(),
beanName)
在bean的property属性注入完毕 向bean中设置属性之前执行
6、BeanPostProcessor.postProcessBeforeInitialization(result, beanName)
在bean初始化（自定义init或者是实现了InitializingBean.afterPropertiesSet()）之前执行
7、BeanPostProcessor.postProcessAfterInitialization(result, beanName)
在bean初始化（自定义init或者是实现了InitializingBean.afterPropertiesSet()）之后执行
8、其中DestructionAwareBeanPostProcessor方法的postProcessBeforeDestruction(Object bean, String beanName)会在销毁对象前执行

【AOP原理】

1.容器启动配置类/配置文件中，标记了@EnableAspectJAutoProxy开启aop功能的注解

2.根据@EnableAspectJAutoProxy的@Import(AspectJAutoProxyRegistrar.class)向容器中注入一个AnnotationAwareAspectJAutoProxyCreator组件
（1）AnnotationAwareAspectJAutoProxyCreator组件作用：每一个bean创建的时候，构造器走完后，进入后置处理器方法 postProcessAfterInstantiation()，进入包装方法，包装完成后返回一个代理对象 proxyBean

3.后置处理器方法 postProcessAfterInstantiation():
（1）根据 @Aspect 注解获取容器中所有候选增强器（advisor：@before,@after等）
（2）根据 @Pointcut 切入点获取当前bean是否在范围内，并获取可以用的的增强器（advisor：@before,@after等）
（3）因为增强器执行有顺序，给增强器集合进行排序,顺序为 Expose(自带) => afterThrowing => afterReturn => after => before
（4）如果增强器数量等于0，说明当前bean不需要增强，当前反之，就创建bean的代理对象,该代理对象包装了需要增强的增强器集合(jdk动态代理/cglib动态代理)

4.准备执行代理对象 proxyBean 的目标方法:
（1）循环每一个 proxyBean 的增强器，并包装成一个 MethodIntercepter 方法拦截器链对象

5.拦截器链执行过程：
（1）如果没有拦截器或者拦截器的标记索引和拦截器数组大小-1一样，执行目标方法
（2）每次从拦截器链中获取一个拦截器，拦截器的标记索引就会+1，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行拦截方法完成后再执行自己的拦截方法
（3）当从拦截器链获取到最后一个 before 拦截器时，不同于其他的拦截器，它会先执行 before 拦截器的拦截方法，再执行目标方法
（4）然后再依次执行 after => afterReturn => afterThrowing =>Expose(自带) => 完成

【Transaction原理】

1.容器启动配置类/配置文件中，标记了 @EnableTransactionManagement 开启事务tx功能的注解

2.根据@EnableTransactionManagement注解向容器中注入 AutoProxyRegistrar  ProxyTransactionManagementConfiguration两个组件
2.1 AutoProxyRegistrar组件作用：该组件会向容器中注入 InfrastructureAdvisorAutoProxyCreator 这个后置处理器
（1）InfrastructureAdvisorAutoProxyCreator作用：每一个bean创建的时候，构造器走完后，进入后置处理器方法 postProcessAfterInstantiation() 作用，进入包装方法，包装完成后返回一个代理对象 proxyBean

2.2 ProxyTransactionManagementConfiguration组件作用：该组件会向容器中注入 事务增强器 BeanFactoryTransactionAttributeSourceAdvisor

3.后置处理器方法 postProcessAfterInstantiation():
（1）根据之前注入的 BeanFactoryTransactionAttributeSourceAdvisor 为候选增强器
（2）根据 @Transaction 获取当前bean是否在范围内，并获取可以用的的增强器 BeanFactoryTransactionAttributeSourceAdvisor
（3）因为增强器执行有顺序，给增强器集合进行排序
（4）如果增强器数量等于0，说明当前bean不需要增强，当前反之，就创建bean的代理对象,该代理对象包装了需要增强的增强器集合(jdk动态代理/cglib动态代理)

4.准备执行代理对象 proxyBean 的目标方法:
（1）循环每一个 proxyBean 的增强器（这里只有1个事务增强器 BeanFactoryTransactionAttributeSourceAdvisor），并包装成一个 MethodIntercepter
方法拦截器链对象

5.拦截器链执行过程：
（1）如果没有拦截器或者拦截器的标记索引和拦截器数组大小-1一样，执行目标方法
（2）每次从拦截器链中获取一个拦截器，拦截器的标记索引就会+1，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行拦截方法完成后再执行自己的拦截方法
（3）先执行目标方法，如果有异常，根据try catch来执行事务管理器的回滚方法 rollback()，如果没有异常，就执行事务管理器的提交方法 commit()