Spring源码分析

1. IOC容器的创建

  1. /*
  2. 我们需要清楚:
  3.     1. IOC是一个容器
  4.     2. 容器启动的时候会创建所有的单实例bean
  5.     3. 我们可以直接从容器中获取到某个bean
  7. 我们需要了解:
  8.     1. IOC容器的创建过程
  9.     2. 容器启动期间做了些什么、什么时候创建的所有单实例bean
  10.     3. IOC是如何创建这些单实例bean,并且进行管理的,最后将这些bean保存在什么地方
  12. 源码: 从HelloWorld开始，进行debug调试，边调试边查看控制台的打印
  14. =============================BeanFactory的创建以及准备工作==============================
  15. Spring容器的refresh()--->刷新容器
  16.     1. prepareRefresh()--->刷新前的预处理
  17.           initPropertySources()-->初始化一些属性设置(空方法，留给子类实现的)
  18.           getEnvironment().validateRequiredProperties();-->校验属性的合法性
  19.           this.earlyApplicationEvents = new LinkedHashSet<>();-->保存容器中一些早期的事件
  21.     2. obtainFreshBeanFactory();--->获取BeanFactory
  22.           refreshBeanFactory();-->刷新(创建)BeanFactory
  23.           getBeanFactory();-->获取BeanFactory
  24.           将BeanFactory返回
  26.     3. prepareBeanFactory(beanFactory);--->BeanFactory的预准备工作(对BeanFactory进行一些        设置)
  27.           设置BeanFactory的类加载器、支持表达式解析器等...
  28.           添加部分BeanPostProcessor后置处理器(ApplicationContextAwareProcessor)
  29.           设置一些忽略的自动装配的接口
  30.           注册可以解析的自动装配,使得我们可以直接在任何组件中进行自动注入
  31.           添加了BeanPostProcessor后置处理器(ApplicationListenerDetector)
  32.           给Bean中注册一些其他有用的组件(比如: 与环境有关的组件)
  34.     4. postProcessBeanFactory(beanFactory);--->BeanFactory准备工作完成之后进行的一些后置处        理工作(空方法，留给子类使用)
  35. ===================================================================================    
  36.     5. invokeBeanFactoryPostProcessors(beanFactory);--->执行BeanFactory后置处理器,在
  37.        BeanFactory标准初始化之后执行
  38.           先获取所有的BeanFactoryPostProcessor进行遍历
  39.           经过判断之后拿到所有的BeanDefinitionRegistryPostProcessor
  40.           跟据类型获取所有bean的名字，再按照优先级进排序
  41.           然后判断是否实现了Ordered顺序接口，再排序
  42.           最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessor
  44.     6. registerBeanPostProcessors(beanFactory);--->注册bean的后置处理器(作用: 拦截bean的创       建过程)
  45.           获取所有的BeanPostProcessor
  46.           后置处理器默认也是可以通过实现接口PriorityOrdered、Ordered来指定优先级
  47.           先注册实现了PriorityOrdered优先级接口的BeanPostProcessor，然后添加到BeanFactory中
  48.           再注册实现了Ordered顺序接口的BeanPostProcessor
  49.           最后注册没有实现任何优先级接口的BeanPostProcessor
  51.     7. initMessageSource();--->初始化信息源，支持SpringMVC中的国际化功能(消息绑定、消息解析)
  52.           获取BeanFactory
  53.           然后查看容器中是否有id为messageSource的组件,如果有，直接赋值给messageSource属性，如果             没有，则自己创建一个DelegatingMessageSource
  54.           MessageSource: 可以取出国际化配置文件中某个key的值，能按照区域信息进行获取
  55.           最后把创建好的messageSource注册到容器中，以后获取国际化配置文件的值的时候，可以自动注入          messageSource
  57.     8. initApplicationEventMulticaster--->初始化一些事件转化器(spring创建和销毁bean的时候会       产生一些其他的事件，需要借助这些事件转化器处理)
  58.           获取BeanFactory
  59.           然后从BeanFactory中获取applicationEventMulticaster
  60.           如果没有获取到，就会默认创建一个SimpleApplicationEventMulticaster，将创建的                  applicationEventMulticaster添加到BeanFactory中，以后使用的时候可以自动注入
  62.     9. onRefresh();--->初始化一些其他的组件，这是个空方法，留给子类实现的
  63.           子类可以重写该方法，在容器刷新的时候自定义一些其他组件
  65.     10. registerListeners();--->注册监听器
  66.           从容器中拿到所有的ApplicationListener组件
  67.           然后将每个监听器添加到事件转发器中
  68.           最后将一些早期的事件也添加到事件转发器中
  70.     11. finishBeanFactoryInitialization(beanFactory);--->完成BeanFactory的初始化,这个方          法里面才是对bean的初始化,重点研究
  71.           beanFactory.preInstantiateSingletons();-->初始化剩下的所有单实例bean
  72.           先获取容器中的所有bean,依次进行初始化和创建对象
  73.           获取bean的定义信息-->RootBeanDefinition
  74.           判断bean是否为抽象、单实例、懒加载的
  75.           判断是否为FactoryBean,也就是工厂bean(是否实现了FactoryBean接口)
  76.           getBean(beanName)-->才是真正的获取bean
  77.           getBean方法内部调用doGetBean()方法-->重点方法
  78.                   先获取缓存中保存的单实例bean,如果能获取到说明这个bean之前已经创建过，则直接返回
  79.                   若缓存中没有，则开始bean的创建对象流程
  80.                   先标记当前bean已经被创建,然后获取bean的定义信息
  81.                   获取当前bean依赖的其他bean的信息,如果有，则先把当前bean所依赖的bean创建出来
  82.                   启动单实例bean的创建流程: createBean(beanName, mbd, args);
  83.                   createBean底层又会调用doCreateBean()方法来创建bean实例
  84.                   doCreateBean()方法底层调用createBeanInstance()方法创建bean实例
  86.     12. finishRefresh();--->完成BeanFactory的初始化创建工作，IOC容器创建完成
  87. ====================================================================================
  90. 总结:
  91.     1. Spring容器启动的时候，会先保存所有注册进来的bean的定义信息
  92.         xml配置文件注册bean--> <bean></bean>
  93.         注解方式注册bean--> @Bean、@Service、@Controller...
  94.     2. Spring容器会在合适的时机创建这些bean
  95.         用到这个bean的时候，调用getBean()方法创建bean,再保存到容器中
  96.         统一创建剩下所有bean的时候，调用finishBeanFactoryInitialization(beanFactory)
  97.     3. 后置处理器: 每一个bean创建完成之后，都会使用各种各样的后置处理器进行处理，增强bean的功能
  98.         AutowiredAnnotationBeanPostProcessor: 处理自动注入
  99.         AnnotationAwareAspectJAutoProxyCreator: 开发aop的功能，帮助我们创建代理对象
  100.     4. 事件驱动模型: ApplicationListener进行事件监听
  101. */
  103. //源码
  104. public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
  105.         this();
  106.         register(annotatedClasses);
  107.         refresh();   //所有单实例bean创建完成
  108. }
  111. //刷新容器
  112. @Override
  113. public void refresh() throws BeansException, IllegalStateException {
  114.     //保证多线程情况下，IOC容器只会被创建一次
  115.     synchronized (this.startupShutdownMonitor) {
  116.         //预处理--->准备刷新容器
  117.         prepareRefresh();
  119.         //ConfigurableListableBeanFactory是BeanFactory的子类
  120.         //这里准备了一个创建所有bean的工厂
  121.         //这一步,spring会解析xml配置文件将要创建的所有bean,并加入到beanDefinitionMap中
  122.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  124.         //此时所有的bean已经加入到beanFactory中，准备beanFactory(预准备)
  125.         prepareBeanFactory(beanFactory);
  127.         try {
  128.             //BeanFactory准备工作完成之后进行的一些后置处理工作(空方法，留给子类使用)
  129.             postProcessBeanFactory(beanFactory);
  131.             //执行BeanFactory后置处理器,在BeanFactory标准初始化之后执行
  132.             invokeBeanFactoryPostProcessors(beanFactory);
  134.             //注册bean的后置处理器
  135.             registerBeanPostProcessors(beanFactory);
  137.             //初始化信息源，用来支持SpringMVC中的国际化功能(消息绑定、消息解析)
  138.             initMessageSource();
  140.             //初始化一些事件转化器(spring创建和销毁bean的时候会产生一些其他的事件，需要借助这些事件                转化器处理)
  141.             initApplicationEventMulticaster();
  143.             //初始化一些其他的组件，这是个空方法，留给子类实现的
  144.             onRefresh();
  146.             //注册监听器
  147.             registerListeners();
  149.             //完成BeanFactory的初始化,这个方法里面才是对bean的初始化,重点研究
  150.             finishBeanFactoryInitialization(beanFactory);
  152.             //此时已经完成了容器的刷新
  153.             finishRefresh();
  154.         }
  155.         catch (BeansException ex) {
  156.             if (logger.isWarnEnabled()) {
  157.                 logger.warn("Exception encountered during context initialization - " +"cancelling refresh attempt: " + ex);
  158.             }
  159.             destroyBeans();
  160.             cancelRefresh(ex);
  161.             throw ex;
  162.         }
  163.         finally {
  164.             resetCommonCaches();
  165.         }
  166.     }
  167. }
  170. //预处理
  171. protected void prepareRefresh() {
  172.     this.startupDate = System.currentTimeMillis();
  173.     this.closed.set(false);
  174.     this.active.set(true);
  176.     if (logger.isInfoEnabled()) {
  177.         logger.info("Refreshing " + this);
  178.     }
  180.     //空方法，留给子类实现
  181.     initPropertySources();
  183.     //校验属性的合法性
  184.     getEnvironment().validateRequiredProperties();
  186.     //保存容器中一些早期的时间
  187.     this.earlyApplicationEvents = new LinkedHashSet<>();
  188. }
  191. //获取BeanFactory
  192. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  193.     //先刷新BeanFactory
  194.     refreshBeanFactory();
  195.     //获取BeanFactory
  196.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  197.     if (logger.isDebugEnabled()) {
  198.         logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
  199.     }
  200.     return beanFactory;  //返回BeanFactory
  201. }
  204. //BeanFactory的预准备工作
  205. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  206.     //设置类加载器
  207.     beanFactory.setBeanClassLoader(getClassLoader());
  208.     //设置表达式解析器
  209.     beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  210.     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
  211.     //添加ApplicationContextAwareProcessor
  212.     beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  213.     //设置一些忽略的自动装配的接口
  214.     beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  215.     beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  216.     beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  217.     beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  218.     beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  219.     beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
  220.     //注册可以解析的自动装配,使得我们可以直接在任何组件中进行自动注入
  221.     beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  222.     beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  223.     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  224.     beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  225.     //添加了BeanPostProcessor后置处理器
  226.     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
  227.     //给Bean中注册一些其他有用的组件(比如: 与环境有关的组件)
  228.     if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  229.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  230.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  231.     }
  232.     if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  233.         beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  234.     }
  235.     if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  236.         beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  237.     }
  238.     if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  239.         beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  240.     }
  241. }
  244. //执行BeanFactory后置处理器
  245. protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  246.     //执行BeanFactoryPostProcessor的方法
  247.     PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  248.     if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  249.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  250.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  251.     }
  252. }
  255. //执行BeanFactoryPostProcessor的方法
  256. public static void invokeBeanFactoryPostProcessors(
  257.     ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  259.     Set<String> processedBeans = new HashSet<>();
  260.     //判断bean是否属于BeanDefinitionRegistry
  261.     if (beanFactory instanceof BeanDefinitionRegistry) {
  262.         BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  263.         List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
  264.         List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
  265.         //拿到所有的BeanFactoryPostProcessor进行遍历
  266.         for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  267.             if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  268.                 //经过判断之后拿到所有的BeanDefinitionRegistryPostProcessor
  269.                 BeanDefinitionRegistryPostProcessor registryProcessor =
  270.                     (BeanDefinitionRegistryPostProcessor) postProcessor;
  271.                 registryProcessor.postProcessBeanDefinitionRegistry(registry);
  272.                 registryProcessors.add(registryProcessor);
  273.             }
  274.             else {
  275.                 regularPostProcessors.add(postProcessor);
  276.             }
  277.         }
  278.         List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
  279.         //跟据类型获取所有bean的名字
  280.         String[] postProcessorNames =
  281.           beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  282.         for (String ppName : postProcessorNames) {
  283.             //PriorityOrdered: 判断是否实现了优先级排序
  284.             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  285.                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  286.                 processedBeans.add(ppName);
  287.             }
  288.         }
  289.         //按优先级排序
  290.         sortPostProcessors(currentRegistryProcessors, beanFactory);
  291.         registryProcessors.addAll(currentRegistryProcessors);
  292.         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  293.         currentRegistryProcessors.clear();
  294.     }
  296.     //跟据类型获取所有bean的名字
  297.     postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  298.     for (String ppName : postProcessorNames) {
  299.         //判断是否实现了Ordered接口
  300.         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
  301.             currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  302.             processedBeans.add(ppName);
  303.         }
  304.     }
  305.     //再排序
  306.     sortPostProcessors(currentRegistryProcessors, beanFactory);
  307.     registryProcessors.addAll(currentRegistryProcessors);
  308.     invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  309.     currentRegistryProcessors.clear();
  311.     //最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessor
  312.     boolean reiterate = true;
  313.     while (reiterate) {
  314.         reiterate = false;
  315.         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  316.         for (String ppName : postProcessorNames) {
  317.             if (!processedBeans.contains(ppName)) {
  318.                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  319.                 processedBeans.add(ppName);
  320.                 reiterate = true;
  321.             }
  322.         }
  323.         sortPostProcessors(currentRegistryProcessors, beanFactory);
  324.         registryProcessors.addAll(currentRegistryProcessors);
  325.         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  326.         currentRegistryProcessors.clear();
  327.     }
  328. }
  331. //注册bean的后置处理器
  332. protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  333.     PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
  334. }
  337. //获取所有的BeanPostProcessor
  338. public static void registerBeanPostProcessors(
  339.     ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
  340.     String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
  341.     //统计数量
  342.     int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
  343.     //检查
  344.     beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
  345.     List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
  346.     List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
  347.     List<String> orderedPostProcessorNames = new ArrayList<>();
  348.     List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  349.     for (String ppName : postProcessorNames) {
  350.         //通过实现优先级接口来指定优先级
  351.         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  352.             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  353.             priorityOrderedPostProcessors.add(pp);
  354.             if (pp instanceof MergedBeanDefinitionPostProcessor) {
  355.                 internalPostProcessors.add(pp);
  356.             }
  357.         }
  358.         else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
  359.             orderedPostProcessorNames.add(ppName);
  360.         }
  361.         else {
  362.             nonOrderedPostProcessorNames.add(ppName);
  363.         }
  364.     }
  365.     //排序
  366.     sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  367.     registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
  368.     List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
  369.     for (String ppName : orderedPostProcessorNames) {
  370.         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  371.         orderedPostProcessors.add(pp);
  372.         if (pp instanceof MergedBeanDefinitionPostProcessor) {
  373.             internalPostProcessors.add(pp);
  374.         }
  375.     }
  376.     sortPostProcessors(orderedPostProcessors, beanFactory);
  377.     registerBeanPostProcessors(beanFactory, orderedPostProcessors);
  378.     List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
  379.     for (String ppName : nonOrderedPostProcessorNames) {
  380.         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  381.         nonOrderedPostProcessors.add(pp);
  382.         if (pp instanceof MergedBeanDefinitionPostProcessor) {
  383.             internalPostProcessors.add(pp);
  384.         }
  385.     }
  386.     registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
  387.     sortPostProcessors(internalPostProcessors, beanFactory);
  388.     registerBeanPostProcessors(beanFactory, internalPostProcessors);
  389.     beanFactory.addBeanPostProcessor(new     ApplicationListenerDetector(applicationContext));
  390. }
  393. //初始化信息源，用来支持SpringMVC中的国际化功能(消息绑定、消息解析)
  394. protected void initMessageSource() {
  395.     //获取BeanFactory
  396.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  397.     //是否存在id为messageSource的组件
  398.     if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
  399.         this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
  400.         if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
  401.             HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
  402.             if (hms.getParentMessageSource() == null) {
  403.                 hms.setParentMessageSource(getInternalParentMessageSource());
  404.             }
  405.         }
  406.         if (logger.isDebugEnabled()) {
  407.             logger.debug("Using MessageSource [" + this.messageSource + "]");
  408.         }
  409.     }
  410.     else {
  411.         //如果没有，默认创建一个DelegatingMessageSource
  412.         DelegatingMessageSource dms = new DelegatingMessageSource();
  413.         dms.setParentMessageSource(getInternalParentMessageSource());
  414.         this.messageSource = dms;
  415.         //最后把创建好的messageSource注册到容器中，以后获取国际化配置文件的值的时候，可以自动注入          messageSource
  416.         beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
  417.         if (logger.isDebugEnabled()) {
  418.             logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
  419.                          "': using default [" + this.messageSource + "]");
  420.         }
  421.     }
  422. }
  425. //MessageSource: 可以取出国际化配置文件中某个key的值，能按照区域信息进行获取
  426. public interface MessageSource {
  427.     @Nullable
  428.     //获取国际化配置文件的值
  429.     String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);
  430. }
  433. //初始化一些事件转化器(spring创建和销毁bean的时候会产生一些其他的事件，需要借助这些事件转化器处理)
  434. protected void initApplicationEventMulticaster() {
  435.     //获取BeanFactory
  436.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  437.     //是否有id为applicationEventMulticaster的组件
  438.     if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  439.         this.applicationEventMulticaster =
  440.             beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  441.         if (logger.isDebugEnabled()) {
  442.             logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  443.         }
  444.     }
  445.     else {
  446.         //如果没有，默认创建一个SimpleApplicationEventMulticaster
  447.         this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  448.         beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  449.         if (logger.isDebugEnabled()) {
  450.             logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
  451.                          APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
  452.                          "': using default [" + this.applicationEventMulticaster + "]");
  453.         }
  454.     }
  455. }
  458. //初始化一些其他的IOC容器，这是个空方法，留给子类实现的
  459. protected void onRefresh() throws BeansException {
  461. }
  464. //注册监听器
  465. protected void registerListeners() {
  466.     for (ApplicationListener<?> listener : getApplicationListeners()) {
  467.         getApplicationEventMulticaster().addApplicationListener(listener);
  468.     }
  469.     //从容器中拿到所有的ApplicationListener组件
  470.     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  471.     for (String listenerBeanName : listenerBeanNames) {
  472.       //将每个监听器添加到事件转发器中
  473.       getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  474.     }
  475.     //将一些早期的事件也添加到事件转发器中
  476.     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  477.     this.earlyApplicationEvents = null;
  478.     if (earlyEventsToProcess != null) {
  479.         for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
  480.             getApplicationEventMulticaster().multicastEvent(earlyEvent);
  481.         }
  482.     }
  483. }
  486. //完成BeanFactory的初始化,这个方法里面才是对bean的初始化,重点研究
  487. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  488.     if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  489.         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  490.         beanFactory.setConversionService(
  491.             beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  492.     }
  493.     if (!beanFactory.hasEmbeddedValueResolver()) {
  494.         beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  495.     }
  496.     String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  497.     for (String weaverAwareName : weaverAwareNames) {
  498.         getBean(weaverAwareName);
  499.     }
  500.     beanFactory.setTempClassLoader(null);changes.
  501.     beanFactory.freezeConfiguration();
  502.     //重点: 初始化所有剩下的单实例bean
  503.     beanFactory.preInstantiateSingletons();
  504. }
  507. //初始化所有剩下的单实例bean
  508. public void preInstantiateSingletons() throws BeansException {
  509.     if (logger.isTraceEnabled()) {
  510.         logger.trace("Pre-instantiating singletons in " + this);
  511.     }
  512.     List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  513.     for (String beanName : beanNames) {
  514.         //拿到所有bean的定义信息
  515.         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  516.         //判断bean是否为非抽象、单例、非懒加载
  517.         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  518.             //判断是否为FactoryBean
  519.             if (isFactoryBean(beanName)) {
  520.                 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  521.                 //是否实现了FactoryBean接口
  522.                 if (bean instanceof FactoryBean) {
  523.                     FactoryBean<?> factory = (FactoryBean<?>) bean;
  524.                     boolean isEagerInit;
  525.                     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  526.                         isEagerInit = AccessController.doPrivileged(
  527.                             (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  528.                             getAccessControlContext());
  529.                     }
  530.                     else {
  531.                         isEagerInit = (factory instanceof SmartFactoryBean &&
  532.                                        ((SmartFactoryBean<?>) factory).isEagerInit());
  533.                     }
  534.                     if (isEagerInit) {
  535.                         getBean(beanName);
  536.                     }
  537.                 }
  538.             }
  539.             //普通bean(不是FactoryBean)走这里
  540.             else {
  541.                 getBean(beanName);
  542.             }
  543.         }
  544.     }
  545.     //获取所有的bean的名称 至此所有的单实例的bean已经加入到单实例Bean的缓存池中，所谓的单实例缓存池实际上就是一个ConcurrentHashMap
  546.     for (String beanName : beanNames) {
  547.         //从单例缓存池中获取所有的对象
  548.         Object singletonInstance = getSingleton(beanName);
  549.         //判断当前的bean是否实现了SmartInitializingSingleton接口
  550.         if (singletonInstance instanceof SmartInitializingSingleton) {
  551.             SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  552.             if (System.getSecurityManager() != null) {
  553.                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  554.                     smartSingleton.afterSingletonsInstantiated();
  555.                     return null;
  556.                 }, getAccessControlContext());
  557.             }
  558.             else {
  559.                 smartSingleton.afterSingletonsInstantiated();
  560.             }
  561.         }
  562.     }
  563. }
  566. public Object getBean(String name) throws BeansException {
  567.     //真正的获取Bean的逻辑
  568.     return doGetBean(name, null, null, false);
  569. }
  572. //调用doGetBean
  573. protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  574.             @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  575.         //在这里传入进来的name可能是别名、也有可能是工厂beanName,所以在这里需要转换
  576.         final String beanName = transformedBeanName(name);
  577.         Object bean;
  578.         //先尝试去缓存中获取对象
  579.         Object sharedInstance = getSingleton(beanName);
  580.         if (sharedInstance != null && args == null) {
  581.             if (logger.isDebugEnabled()) {
  582.                 if (isSingletonCurrentlyInCreation(beanName)) {
  583.                     logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
  584.                             "' that is not fully initialized yet - a consequence of a circular reference");
  585.                 }
  586.                 else {
  587.                     logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
  588.                 }
  589.             }
  590.             /**
  591.              * 如果sharedInstance是普通的单例bean，下面的方法会直接返回。但如果
  592.              * sharedInstance是FactoryBean类型的，则需调用getObject()工厂方法获取真正的
  593.              * bean实例。如果用户想获取 FactoryBean 本身，这里也不会做特别的处理，直接返回
  594.              * 即可。毕竟 FactoryBean 的实现类本身也是一种 bean，只不过具有一点特殊的功能而已。
  595.              */
  596.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  597.         }
  598.         else {
  599.             //Spring只能解决单例对象的setter注入的循环依赖,不能解决构造器注入，也不能解决多实例的循环依赖
  600.             if (isPrototypeCurrentlyInCreation(beanName)) {
  601.                 throw new BeanCurrentlyInCreationException(beanName);
  602.             }
  603.             //如果缓存中没有，则会开始创建bean对象的流程
  604.             //首先,判断是否有父工厂
  605.             BeanFactory parentBeanFactory = getParentBeanFactory();
  606.             //若存在父工厂,且当前的bean工厂中没有我们需要的bean的定义信息,那么bean定义信息则存在于                父beanFactory中
  607.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  608.                 //获取bean的原始名称
  609.                 String nameToLookup = originalBeanName(name);
  610.                 //若为AbstractBeanFactory类型，委托父类处理
  611.                 if (parentBeanFactory instanceof AbstractBeanFactory) {
  612.                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  613.                             nameToLookup, requiredType, args, typeCheckOnly);
  614.                 }
  615.                 else if (args != null) {
  616.                     //委托给父类BeanFactory的getBean()处理
  617.                     return (T) parentBeanFactory.getBean(nameToLookup, args);
  618.                 }
  619.                 else {
  620.                     //没有args，委托给标准的getBean()处理
  621.                     return parentBeanFactory.getBean(nameToLookup, requiredType);
  622.                 }
  623.             }
  625.             /**
  626.              * 方法参数typeCheckOnly ，是用来判断调用getBean(...) 方法时，表示是否为仅仅进行类型检查获取Bean对象
  627.              * 如果不是仅仅做类型检查，而是创建Bean对象，则需要调用markBeanAsCreated(String beanName) 方法，进行标记
  628.              */
  629.             if (!typeCheckOnly) {
  630.                 markBeanAsCreated(beanName);
  631.             }
  632.             try {
  633.                 //从容器中获取beanName相应的GenericBeanDefinition对象，并将其转换为RootBeanDefinition对象
  634.                 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  635.                 //检查当前创建的bean定义是不是抽象的bean定义
  636.                 checkMergedBeanDefinition(mbd, beanName, args);
  637.                 //处理dependsOn的依赖(这个不是我们所谓的循环依赖 而是bean创建前后的依赖)
  638.                 //依赖bean的名称
  639.                 String[] dependsOn = mbd.getDependsOn();
  640.                 if (dependsOn != null) {
  641.                     for (String dep : dependsOn) {
  642.                         //beanName是当前正在创建的bean,dep是正在创建的bean的依赖的bean的名称
  643.                         if (isDependent(beanName, dep)) {
  644.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  645.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  646.                         }
  647.                         //保存的是依赖beanName之间的映射关系：依赖beanName -> beanName的集合
  648.                         registerDependentBean(dep, beanName);
  649.                         try {
  650.                             //获取dependsOn的bean
  651.                             getBean(dep);
  652.                         }
  653.                         catch (NoSuchBeanDefinitionException ex) {
  654.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  655.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  656.                         }
  657.                     }
  658.                 }
  659.                 //是单实例则创建单例Bean
  660.                 if (mbd.isSingleton()) {
  661.                     //把beanName和一个singletonFactory匿名内部类传入用于回调
  662.                     sharedInstance = getSingleton(beanName, () -> {
  663.                         try {
  664.                             //创建bean
  665.                             //底层调用doCreateBean()返回bean实例
  666.                             return createBean(beanName, mbd, args);
  667.                         }
  668.                         catch (BeansException ex) {
  669.                             //创建bean的过程中发生异常,需要销毁关于当前bean的所有信息
  670.                             destroySingleton(beanName);
  671.                             throw ex;
  672.                         }
  673.                     });
  674.                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  675.                 }
  676.                 //如果是多实例bean
  677.                 else if (mbd.isPrototype()) {
  678.                     Object prototypeInstance = null;
  679.                     try {
  680.                         beforePrototypeCreation(beanName);
  681.                         prototypeInstance = createBean(beanName, mbd, args);
  682.                     }
  683.                     finally {
  684.                         afterPrototypeCreation(beanName);
  685.                     }
  686.                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  687.                 }
  688.                 else {
  689.                     String scopeName = mbd.getScope();
  690.                     final Scope scope = this.scopes.get(scopeName);
  691.                     if (scope == null) {
  692.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  693.                     }
  694.                     try {
  695.                         Object scopedInstance = scope.get(beanName, () -> {
  696.                             beforePrototypeCreation(beanName);
  697.                             try {
  698.                                 return createBean(beanName, mbd, args);
  699.                             }
  700.                             finally {
  701.                                 afterPrototypeCreation(beanName);
  702.                             }
  703.                         });
  704.                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  705.                     }
  706.                     catch (IllegalStateException ex) {
  707.                         throw new BeanCreationException(beanName,
  708.                                                         "Scope '" + scopeName + "' is not active for the current thread; consider " +
  709.                                                         "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  710.                                                         ex);
  711.                     }
  712.                 }
  713.             }
  714.             catch (BeansException ex) {
  715.                 cleanupAfterBeanCreationFailure(beanName);
  716.                 throw ex;
  717.             }
  718.         }
  719. }
  722. //调用doCreateBean()方法返回一个bean实例
  723. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  724.     throws BeanCreationException {
  725.     //BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器等
  726.     BeanWrapper instanceWrapper = null;
  727.     if (mbd.isSingleton()) {
  728.         //从没有完成的FactoryBean中移除
  729.         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  730.     }
  731.     if (instanceWrapper == null) {
  732.         //重点: 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化 比较复杂也                很重要
  733.         instanceWrapper = createBeanInstance(beanName, mbd, args);
  734.     }
  735.     try {
  736.         //给我们的属性进行赋值(调用set方法进行赋值),利用反射调用set方法
  737.         populateBean(beanName, mbd, instanceWrapper);
  738.         //进行对象初始化操作(在这里可能生成代理对象)
  739.         exposedObject = initializeBean(beanName, exposedObject, mbd);
  740.     }
  741. }
  744. //createBeanInstance: 创建bean实例
  745. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
  746.     //从bean定义中解析出当前bean的class对象
  747.     Class<?> beanClass = resolveBeanClass(mbd, beanName);
  749.     //检测类的访问权限。默认情况下，对于非 public 的类，是允许访问的。若禁止访问，这里会抛出异常
  750.     if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  751.         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  752.                                         "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  753.     }
  754.     Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
  755.     if (instanceSupplier != null) {
  756.         return obtainFromSupplier(instanceSupplier, beanName);
  757.     }
  758.     //工厂方法,我们通过配置类来进行配置的话 采用的就是工厂方法
  759.     if (mbd.getFactoryMethodName() != null) {
  760.         return instantiateUsingFactoryMethod(beanName, mbd, args);
  761.     }
  762.     //判断当前构造函数是否被解析过
  763.     boolean resolved = false;
  764.     //有没有必须进行依赖注入
  765.     boolean autowireNecessary = false;
  766.     if (args == null) {
  767.         synchronized (mbd.constructorArgumentLock) {
  768.             //判断我们的bean定义信息中的resolvedConstructorOrFactoryMethod(用来缓存我们的已经解析的构造函数或者工厂方法)
  769.             if (mbd.resolvedConstructorOrFactoryMethod != null) {
  770.                 //修改已经解析过的构造函数的标志
  771.                 resolved = true;
  772.                 //修改标记为ture 标识构造函数或者工厂方法已经解析过
  773.                 autowireNecessary = mbd.constructorArgumentsResolved;
  774.             }
  775.         }
  776.     }
  777.     //若被解析过
  778.     if (resolved) {
  779.         if (autowireNecessary) {
  780.             //通过有参的构造函数进行反射调用
  781.             return autowireConstructor(beanName, mbd, null, null);
  782.         }
  783.         else {
  784.             //调用无参数的构造函数进行创建对象
  785.             return instantiateBean(beanName, mbd);
  786.         }
  787.     }
  789.     //通过bean的后置处理器选举出合适的构造函数创建对象
  790.     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  791.     //通过后置处理器解析出构造器对象不为null或获取bean定义中的注入模式是构造器注入或bean定义信息ConstructorArgumentValues或获取通过getBean的方式传入的构造器函数参数类型不为null
  792.     if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  793.         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  794.         //通过构造函数创建对象
  795.         return autowireConstructor(beanName, mbd, ctors, args);
  796.     }
  797.     //使用无参数的构造函数调用创建对象
  798.     return instantiateBean(beanName, mbd);
  799. }
  802. //先从缓存中获取对象
  803. public Object getSingleton(String beanName) {
  804.     return getSingleton(beanName, true);
  805. }
  808. //这里涉及到Spring的三级缓存，可以用它来解决循环依赖
  809. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  810.     //第一步:我们先尝试去一级缓存(单例缓存池中去获取对象,一般情况从该map中获取的对象是直接可以使用的)
  811.     //Spring IoC容器初始化加载单实例bean的时候第一次进来的时候 该map一般返回null
  812.     Object singletonObject = this.singletonObjects.get(beanName);
  813.     //若在第一级缓存中没有获取到对象,并且singletonsCurrentlyInCreation正在创建的单实例的list包          含该beanName
  814.     //Spring IoC容器初始化加载单实例bean的时候第一次进来的时候 该list中一般返回null,但是循环依赖的       时候可以满足该条件
  815.     if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  816.         synchronized (this.singletonObjects) {
  817.             //则尝试去二级缓存中获取对象(二级缓存中的对象是一个早期对象)
  818.             //何为早期对象:就是bean刚刚调用了构造方法，还没给bean的属性进行赋值的对象就是早期对象
  819.             singletonObject = this.earlySingletonObjects.get(beanName);
  820.             //二级缓存中也没有获取到对象,allowEarlyReference为true(参数是有上一个方法传递进来的                 true)
  821.             if (singletonObject == null && allowEarlyReference) {
  822.                 //则直接从三级缓存中获取ObjectFactory对象 这个对象就是用来解决循环依赖的关键所在
  823.                 //在getBean的过程中,当bean调用了构造方法的时候,把早期对象包裹成一个                              ObjectFactory暴露到三级缓存中
  824.                 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  825.                 //从三级缓存中获取到对象不为空
  826.                 if (singletonFactory != null) {
  827.                     //在这里通过暴露的ObjectFactory包装对象中,通过调用他的getObject()来获取我                        们的早期对象
  828.                     //在这个环节中会调用到 getEarlyBeanReference()来进行后置处理
  829.                     singletonObject = singletonFactory.getObject();
  830.                     //把早期对象放置在二级缓存,
  831.                     this.earlySingletonObjects.put(beanName, singletonObject);
  832.                     //ObjectFactory 包装对象从三级缓存中删除掉
  833.                     this.singletonFactories.remove(beanName);
  834.                 }
  835.             }
  836.         }
  837.     }
  838.     return singletonObject;
  839. }
  842. //此时已经完成了容器的刷新
  843. protected void finishRefresh() {
  844.     //清理缓存
  845.     clearResourceCaches();
  846.     //初始化跟生命周期有关的后置处理器,默认从容器找是否有id为lifecycleProcessor的组件,如果没有，就         默认创建DefaultLifecycleProcessor
  847.     initLifecycleProcessor();
  848.     //拿到生命周期处理器，然后回调onRefresh()
  849.     getLifecycleProcessor().onRefresh();
  850.     //发布事件-->容器刷新完成事件
  851.     publishEvent(new ContextRefreshedEvent(this));
  852.     LiveBeansView.registerApplicationContext(this);
  853. }
  856. //初始化跟生命周期有关的后置处理器
  857. protected void initLifecycleProcessor() {
  858.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  859.     if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
  860.         this.lifecycleProcessor =
  861.             beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
  862.         if (logger.isDebugEnabled()) {
  863.             logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
  864.         }
  865.     }
  866.     else {
  867.         DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
  868.         defaultProcessor.setBeanFactory(beanFactory);
  869.         this.lifecycleProcessor = defaultProcessor;
  870.         beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
  871.         if (logger.isDebugEnabled()) {
  872.             logger.debug("Unable to locate LifecycleProcessor with name '" +
  873.                          LIFECYCLE_PROCESSOR_BEAN_NAME +
  874.                          "': using default [" + this.lifecycleProcessor + "]");
  875.         }
  876.     }
  877. }

2. Aop面向切面

3. 声明式事务

/*
原理: @EnableTransactionManagement-->开启基于声明式事务的注解开发
    1. 利用TransactionManagementConfigurationSelector给容器中导入两个组件
        AutoProxyRegistrar、ProxyTransactionManagementConfiguration
    2. AutoProxyRegistrar: 实现了ImportBeanDefinitionRegistrar给容器中注册了一个               InfrastructureAdvisorAutoProxyCreator组件
            InfrastructureAdvisorAutoProxyCreator: 利用后置处理器机制在对象创建以后，包装对                象，返回一个代理对象(增强器)，代理对象执行方法利用拦截器链进行调用
    3. ProxyTransactionManagementConfiguration: 
          1. 给容器中注册事务增强器，事务增强器使用AnnotationTransactionAttributeSource解析事              务注解
          2. 给容器中注册事务拦截器TransactionInterceptor，该拦截器保存了事务的属性信息，以及事              务管理器(底层是一个MethodInterceptor方法拦截器)
          3. MethodInterceptor: 在目标方法执行的时候执行拦截器链
          4. 事务拦截器：
                  1. 先获取事务相关的属性、再获取PlatformTransactionManager
                2. 如果事先没有添加任何的transactionManager,则最终会从容器中按照类型获取一个                      PlatformTransactionManager
                3. 执行目标方法时出现异常，获取到事务管理器，利用事务管理回滚操作
                   如果正常，利用事务管理器提交事务   
*/

//源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({TransactionManagementConfigurationSelector.class})
public @interface EnableTransactionManagement {
    boolean proxyTargetClass() default false;    //默认false

    AdviceMode mode() default AdviceMode.PROXY;  //默认是proxy

    int order() default 2147483647;
}


public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
    public TransactionManagementConfigurationSelector() {
    }

    protected String[] selectImports(AdviceMode adviceMode) {
        switch(adviceMode) {
            case PROXY:   //创建一个String数组: AutoProxyRegistrar
            return new String[]{AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
        case ASPECTJ:
            return new String[]{"org.springframework.transaction.aspectj.AspectJTransactionManagementConfiguration"};
        default:
            return null;
        }
    }
}


//实现ImportBeanDefinitionRegistrar接口
public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean candidateFound = false;
        Set<String> annoTypes = importingClassMetadata.getAnnotationTypes();
        for (String annoType : annoTypes) {
            AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
            if (candidate == null) {
                continue;
            }
            Object mode = candidate.get("mode");
            Object proxyTargetClass = candidate.get("proxyTargetClass");
            if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
                    Boolean.class == proxyTargetClass.getClass()) {
                candidateFound = true;
                if (mode == AdviceMode.PROXY) {   //默认就是proxy对象
                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                    if ((Boolean) proxyTargetClass) {   //默认返回false
                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                        return;
                    }
                }
            }
        }
}


@Nullable
    public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
        return registerAutoProxyCreatorIfNecessary(registry, (Object)null);
    }

@Nullable
public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
        return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
}


@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
    @Bean(
        name = {"org.springframework.transaction.config.internalTransactionAdvisor"}
    )
    @Role(2)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        //添加事务属性源
        advisor.setTransactionAttributeSource(this.transactionAttributeSource());
        advisor.setAdvice(this.transactionInterceptor());
        if (this.enableTx != null) {
            advisor.setOrder((Integer)this.enableTx.getNumber("order"));
        }

        return advisor;
    }

    @Bean
    @Role(2)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

    @Bean
    @Role(2)
    public TransactionInterceptor transactionInterceptor() {
        TransactionInterceptor interceptor = new TransactionInterceptor();
       //保存事务属性
       interceptor.setTransactionAttributeSource(this.transactionAttributeSource());
        if (this.txManager != null) {
            interceptor.setTransactionManager(this.txManager);  //保存事务增强器
        }
        return interceptor;
    }
}


public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource implements Serializable {
    public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
        this.publicMethodsOnly = publicMethodsOnly;
        this.annotationParsers = new LinkedHashSet(2);
        //注解解析器: 解析spring事务的一些注解
        this.annotationParsers.add(new SpringTransactionAnnotationParser());
        if (jta12Present) {
            this.annotationParsers.add(new JtaTransactionAnnotationParser());
        }

        if (ejb3Present) {
            this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
        }

    }
}


//各种事务注解的解析
public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
        Propagation propagation = (Propagation)attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        Isolation isolation = (Isolation)attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        rbta.setQualifier(attributes.getString("value"));
        ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList();
        Class<?>[] rbf = attributes.getClassArray("rollbackFor");
    }
}


//底层实际上是一个方法拦截器
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
    public TransactionInterceptor(PlatformTransactionManager ptm, Properties attributes) {
        this.setTransactionManager(ptm);
        this.setTransactionAttributes(attributes);
    }

    //实际上就是代理对象在执行
    @Nullable
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null;
        Method var10001 = invocation.getMethod();
        invocation.getClass();
        return this.invokeWithinTransaction(var10001, targetClass, invocation::proceed);
    }
}



@Nullable
    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, TransactionAspectSupport.InvocationCallback invocation) throws Throwable {
        TransactionAttributeSource tas = this.getTransactionAttributeSource();
        TransactionAttribute txAttr = tas != null ? tas.getTransactionAttribute(method, targetClass) : null;
        //获取PlatformTransactionManager
        PlatformTransactionManager tm = this.determineTransactionManager(txAttr);
        String joinpointIdentification = this.methodIdentification(method, targetClass, txAttr);


@Nullable
    protected PlatformTransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr) {
        if (txAttr != null && this.beanFactory != null) {
            String qualifier = txAttr.getQualifier();
            if (StringUtils.hasText(qualifier)) {
                return this.determineQualifiedTransactionManager(this.beanFactory, qualifier);
            } else if (StringUtils.hasText(this.transactionManagerBeanName)) {
                return this.determineQualifiedTransactionManager(this.beanFactory, this.transactionManagerBeanName);
            } else {
                PlatformTransactionManager defaultTransactionManager = this.getTransactionManager();
                if (defaultTransactionManager == null) {
                    defaultTransactionManager = (PlatformTransactionManager)this.transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY);
                    //默认为容器中添加PlatformTransactionManager
                    if (defaultTransactionManager == null) {
                        defaultTransactionManager = (PlatformTransactionManager)this.beanFactory.getBean(PlatformTransactionManager.class);
                        this.transactionManagerCache.putIfAbsent(DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
                    }
                }

                return defaultTransactionManager;
            }
        } else {
            return this.getTransactionManager();
        }
        if (txAttr != null && tm instanceof CallbackPreferringPlatformTransactionManager) {
            TransactionAspectSupport.ThrowableHolder throwableHolder = new TransactionAspectSupport.ThrowableHolder();

            try {
                result = ((CallbackPreferringPlatformTransactionManager)tm).execute(txAttr, (status) -> {
                    TransactionAspectSupport.TransactionInfo txInfo = this.prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);

                    Object var9;
                    try {
                        Object var8 = invocation.proceedWithInvocation();
                        return var8;
                    } catch (Throwable var13) {
                        if (txAttr.rollbackOn(var13)) {
                            if (var13 instanceof RuntimeException) {
                                throw (RuntimeException)var13;
                            }

                            throw new TransactionAspectSupport.ThrowableHolderException(var13);
                        }

                        throwableHolder.throwable = var13;
                        var9 = null;
                    } finally {
                        this.cleanupTransactionInfo(txInfo);
                    }

                    return var9;
                });
                if (throwableHolder.throwable != null) {
                    throw throwableHolder.throwable;
                } else {
                    return result;
                }
            } catch (TransactionAspectSupport.ThrowableHolderException var19) {
                throw var19.getCause();
            } catch (TransactionSystemException var20) {
                if (throwableHolder.throwable != null) {
                    this.logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                    var20.initApplicationException(throwableHolder.throwable);
                }

                throw var20;
            } catch (Throwable var21) {
                if (throwableHolder.throwable != null) {
                    this.logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                }

                throw var21;
            }
        } else {
            TransactionAspectSupport.TransactionInfo txInfo = this.createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            result = null;

            try {
                result = invocation.proceedWithInvocation();
            } catch (Throwable var17) {
                //如果出现了异常，就会回滚
                this.completeTransactionAfterThrowing(txInfo, var17);
                throw var17;
            } finally {
                this.cleanupTransactionInfo(txInfo);
            }

            this.commitTransactionAfterReturning(txInfo);
            return result;
        }
    }
}


//回滚
protected void completeTransactionAfterThrowing(@Nullable TransactionAspectSupport.TransactionInfo txInfo, Throwable ex) {
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "] after exception: " + ex);
            }

            if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
                try {

                txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());  //回滚
                } catch (TransactionSystemException var6) {
                    this.logger.error("Application exception overridden by rollback exception", ex);
                    var6.initApplicationException(ex);
                    throw var6;
                } catch (Error | RuntimeException var7) {
                    this.logger.error("Application exception overridden by rollback exception", ex);
                    throw var7;
                }
            } else {
                try {
                    txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
                } catch (TransactionSystemException var4) {
                    this.logger.error("Application exception overridden by commit exception", ex);
                    var4.initApplicationException(ex);
                    throw var4;
                } catch (Error | RuntimeException var5) {
                    this.logger.error("Application exception overridden by commit exception", ex);
                    throw var5;
                }
            }
        }

}

4. Spring的一些高频面试题

1. BeanFactory和ApplicationContext的区别

/*
1. BeanFactory: bean工厂接口，负责创建bean实例，是Spring最底层的接口
2. ApplicationContext: 是BeanFactory的子接口，更多的是负责容器功能的实现，可以基于BeanFactory创建好的对象之上完成强大的容器功能，容器从map中获取bean,并且实现AOP功能，都依赖于ApplicationContext
3. 综上所述: BeanFactory是最底层的接口，ApplicationContext是BeanFactory的子接口，是留给程序员使用的IOC接口
*/

SpringMVC源码分析

MyBatis源码分析