spring源码-spring启动（待完善）

spring启动代码

    // spring启动
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
 
 
    // 调AnnotationConfigApplicationContext构造方法
    public AnnotationConfigApplicationContext(Class... componentClasses) {
		// 构造DefaultListableBeanFactory、AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner
		this();
		register(componentClasses);
		refresh();
	}
 
 

spring启动流程

1. 构造方法， 创建DefaultListableBeanFactory（bean工厂），AnnotatedBeanDefinitionReader（读取器）和ClassPathBeanDefinitionScanner（扫描器）

2. 解析配置类，注册BeanDefinition到BeanFactory， 扫描

3. 准备阶段，添加一些类加载器， el表达式解析器， 类型转换器， 三个BeanPostProcessor, 以及ignoreDependencyInterface和ResolvableDependency

4. 初始化国际化MessageSource对象

5. 初始化事件发布器

6. 把用户定义的ApplicationListener对象添加到ApplicationContext中，等Spring启动完就发布事件

7. 实例化非懒加载单例bean， 存入单例池

8. 调用Lifecycle Bean的start()方法

9. 发布ContextRefreshedEvent事件

refresh方法解析

    @Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
 
			// Prepare this context for refreshing.
			prepareRefresh();
 
			// Tell the subclass to refresh the internal bean factory.
			// 判断能否重复刷新，并且返回一个BeanFactory, 刷新不代表完全情况，主要是先执行Bean的销毁，然后重新生成一个BeanFactory，再在接下来的步骤中重新去扫描等等
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
			// Prepare the bean factory for use in this context.
			// 准备BeanFactory
			// 1. 设置BeanFactory的类加载器、SpringEL表达式解析器、类型转化注册器
			// 2. 添加三个BeanPostProcessor，注意是具体的BeanPostProcessor实例对象
			// 3. 记录ignoreDependencyInterface
			// 4. 记录ResolvableDependency
			// 5. 添加三个单例Bean
			prepareBeanFactory(beanFactory);
 
			try {
				// Allows post-processing of the bean factory in context subclasses.
				// 子类来设置一下BeanFactory
				postProcessBeanFactory(beanFactory);
 
				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
 
				// Invoke factory processors registered as beans in the context.
				// BeanFactory准备好了之后，执行BeanFactoryPostProcessor，开始对BeanFactory进行处理
				// 默认情况下:
				// 此时beanFactory的beanDefinitionMap中有6个BeanDefinition，5个基础BeanDefinition+AppConfig的BeanDefinition
				// 而这6个中只有一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor
				// 这里会执行ConfigurationClassPostProcessor进行@Component的扫描，扫描得到BeanDefinition，并注册到beanFactory中
				// 注意：扫描的过程中可能又会扫描出其他的BeanFactoryPostProcessor，那么这些BeanFactoryPostProcessor也得在这一步执行
				invokeBeanFactoryPostProcessors(beanFactory);  // scanner.scan()
 
				// Register bean processors that intercept bean creation.
				// 将扫描到的BeanPostProcessors实例化并排序，并添加到BeanFactory的beanPostProcessors属性中去
				registerBeanPostProcessors(beanFactory);
 
				beanPostProcess.end();
 
				// Initialize message source for this context.
				// 设置ApplicationContext的MessageSource，要么是用户设置的，要么是DelegatingMessageSource
				initMessageSource();
 
				// Initialize event multicaster for this context.
				// 设置ApplicationContext的applicationEventMulticaster，要么是用户设置的，要么是SimpleApplicationEventMulticaster
				initApplicationEventMulticaster();
 
				// Initialize other special beans in specific context subclasses.
				// 给子类的模板方法
				onRefresh();
 
				// Check for listener beans and register them.
				// 把定义的ApplicationListener的Bean对象，设置到ApplicationContext中去，并执行在此之前所发布的事件
				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();
				contextRefresh.end();
			}
		}
	}

1. prepareRefresh()
   1. 记录启动时间
   2. 可以允许子容器设置一些内容到Environment中
   3. 验证Environment中是否包括了必须要有的属性

2. obtainFreshBeanFactory()

   1. 判断能否重复刷新

   2. 调子类的refreshBeanFactory方法获取bean

3. prepareBeanFactory(beanFactory)

   1. 设置beanFactory的类加载器
   2. 设置表达式解析器：StandardBeanExpressionResolver，用来解析Spring中的表达式
   3. 添加PropertyEditorRegistrar：ResourceEditorRegistrar，PropertyEditor类型转化器注册器，用来注册一些默认的PropertyEditor
   4. 添加一个Bean的后置处理器：ApplicationContextAwareProcessor，是一个BeanPostProcessor，用来执行EnvironmentAware、ApplicationEventPublisherAware等回调方法
   5. 添加ignoredDependencyInterface：可以向这个属性中添加一些接口，如果某个类实现了这个接口，并且这个类中的某些set方法在接口中也存在，那么这个set方法在自动注入的时候是不会执行。比如EnvironmentAware这个接口，如果某个类实现了这个接口，那么就必须实现它的setEnvironment方法，而这是一个set方法，和Spring中的autowire是冲突的，那么Spring在自动注入时是不会调用setEnvironment方法的，而是等到回调Aware接口时再来调用（注意，这个功能仅限于xml的autowire，@Autowired注解是忽略这个属性的）
4. postProcessBeanFactory(beanFactory) ： 提供给AbstractApplicationContext的子类进行扩展

5. invokeBeanFactoryPostProcessors：执行BeanFactoryPostProcessor

   1. 解析AppConfig类
   2. 扫描得到BeanDefinition并注册
   3. 解析@Import，@Bean等注解得到BeanDefinition并注册

6. registerBeanPostProcessors：把BeanFactory中所有的BeanPostProcessor找出来并实例化得到一个对象，并添加到BeanFactory中去

7. initMessageSource：如果BeanFactory中存在一个叫messageSource的BeanDefinition，那么会把这个Bean对象创建出来并赋值给ApplicationContext的messageSource属性，让ApplicationContext拥有国际化的功能

8. initApplicationEventMulticaster： 如果BeanFactory中存在一个叫做"applicationEventMulticaster"的BeanDefinition，那么会把这个Bean对象创建出来并赋值给ApplicationContext的applicationEventMulticaster属性，让ApplicationContext拥有事件发布的功能

9. onRefresh：子类模板方法， 扩展点

10. registerListeners：把定义的ApplicationListener的Bean对象，设置到ApplicationContext中去，并执行在此之前所发布的事件

11. finishBeanFactoryInitialization：完成BeanFactory的初始化，实例化非懒加载的单例Bean

12. finishRefresh

    1. 设置lifecycleProcessor

    2. 调用LifecycleBean的start

    3. 发布ContextRefreshedEvent事件