Spring 启动流程

大致流程

1. Spring启动流程

按Bean状态描述：

1. 创建Bean工厂
2. 对Bean工厂后置处理
3. 通过@Component和@Import扫描BeanDefinition，加入到Bean工厂
4. 注册Bean后置处理器，用于拦截Bean创建
5. 实例化
6. 填充属性
7. 初始化
   • 调用aware方法
   • BeanPostProcessor实例化前执行
   • 调用初始化方法
   • BeanPostProcessor实例化后执行
8. 将Bean放到Bean工厂里

按方法描述：

准备阶段：

• this()
  • 调用父类构造方法，获取Bean工厂，默认DefaultListableBeanFactory
  • 注册5个内置BeanDefinition
  • 设置哪些类生成的对象可以被Spring托管，默认是被@Component标记的类
  • 判断被Conditional注解标记的类能否被Spring托管
• register(componentClasses) 注册componentClasses的BeanDefinition

刷新阶段refresh()：

• prepareRefresh 准备上下文
• obtainFreshBeanFactory 获取Bean工厂
• prepareBeanFactory Bean工厂初始化
• postProcessBeanFactory 后置处理Bean工厂，空方法，扩展点
• invokeBeanFactoryPostProcessors 执行BeanFactory的后置处理器。在这里
  • 扫描@Component那些BeanDefinition
  • 执行@Import的逻辑
• registerBeanPostProcessors 注册Bean的后置处理器，用于拦截Bean的创建
• initMessageSource 初始化消息源
• initApplicationEventMulticaster 初始化事件派发器，用来发布事件
• onRefresh 用来初始化一些特殊的Bean，目前默认是空方法，未实现
• registerListeners 注册监听器
• finishBeanFactoryInitialization 初始化所有剩余的单实例Bean(没有使用懒加载的Bean).整个Spring IOC的核心
• finishRefresh 发布事件
  

2. 三级缓存

3. 准备创建Bean

4. 创建Bean的过程

源码分析

创建Spring容器

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringTest.class);

进入构造方法

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		/**
		 * 调用父类构造，创建默认Bean工厂
		 * 初始化内置的后置处理器，可以用于解析常用注解
		 * 初始化环境信息，类加载器，初始化配置文件解析器
		 *
		 * 五个内置BeanDefinition
		 * BeanFactory.BeanDefinitionMap=>
		 * 0 = "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"
		 * 1 = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"
		 * 2 = "org.springframework.context.annotation.internalCommonAnnotationProcessor"
		 * 3 = "org.springframework.context.event.internalEventListenerProcessor"
		 * 4 = "org.springframework.context.event.internalEventListenerFactory"
		 */
		this();
		// 解析配置类并将配置类封装为一个bean定义注册到Bean定义注册中心
		/**
		 *
		 * 将入参类加入
		 *  BeanFactory.BeanDefinitionMap=>
		 * 	0 = "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"
		 * 	1 = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"
		 * 	2 = "org.springframework.context.annotation.internalCommonAnnotationProcessor"
		 * 	3 = "org.springframework.context.event.internalEventListenerProcessor"
		 * 	4 = "org.springframework.context.event.internalEventListenerFactory"
		 *
		 * 	5 = componentClasses
		 */
		register(componentClasses);
		// 执行刷新的容器操作
		refresh();
	}

主要方法含义

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			/**
			 * 1.准备上下文的刷新工作，记录bean容器的启动时间，容器活跃状态
			 *    验证系统中一些属性和属性值的设置等.
			 *    使用LinkedHashSet初始化earlyApplicationListeners和earlyApplicationEvents
			 */
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			/**
			 * 2.获取Bean工厂，期间会做解析和加载bean定义的一些列工作.生成BeanDefinition对象.
			 * 此处返回的beanFactory的真实类型为：DefaultListableBeanFactory
			 *
			 *
			 * 自定义的xsd约束文件也会在该步骤进行解析，通过实现BeanDefinitionParser接口，并实现parse方法
			 * 解析自定义标签时通过实现NamespaceHandlerSupport接口，并实现init方法进行实现
			 */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			/**
			 * 3.bean工厂的初始化准备工作，设置bean工厂的一些属性
			 * 比如：创建bean工厂时，需要忽略哪些接口，需要注册哪些bean，需要设置哪些Bean的后置处理器等.
			 *
			 * 例如常用的：ApplicationContextAwareBeanPostProcessor, ApplicationListenerDetector
			 *
			 * 此外，注册一些和环境相关的bean单实例bean.
			 */
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				/**
				 * 4.Bean定义加载完毕之后实现，目前方法为空实现，留给开发人员进行自定义扩展。
				 * 	  和BeanFactoryPostProcessor中的方法postProcessBeanFactory相同
				 *
				 * 该方法在Bean定义加载完毕之后，Bean实例化之前会执行
				 * 比如在BeanFactory加载完所有的Bean定义之后，想要修改某个bean的定义信息，可以通过重写这个方法实现.
				 * 比如：在xml中配置了<bean id="user"><property name="name" value="wb"></property></bean>
				 * 如果想在不修改配置文件的情况下修改name的值，可以使用如下的方法：
				 * class MyApplicationContext extends ClassPathXmlApplicationContext{
				 public MyApplicationContext(String s){
				 super(s);
				 }
				 @Override
				 protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
				 BeanDefinition beanDefinition = beanFactory.getBeanDefinition("user");
				 PropertyValue propertyValue=new PropertyValue("name", "www.so.com");
				 beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
				 }
				 */
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				/**
				 * 5.执行beanFactory的后置处理器
				 *
				 * 先执行BeanDefinitionRegistryPostProcessor接口的实现类的postProcessBeanDefinitionRegistry方法，
				 *   执行过程中，也是先执行实现了优先级接口PriorityOrdered的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
				 *   然后执行实现了Ordered接口的...
				 *   最后执行未实现PriorityOrdered接口和Ordered接口的...
				 *
				 * 然后执行BeanFactoryPostProcessor接口的实现类的postProcessBeanFactory方法
				 *   执行过程中，也是先执行实现了优先级接口PriorityOrdered的BeanFactoryPostProcessor的postProcessBeanFactory方法
				 *   然后执行实现了Ordered接口的...
				 *   最后执行未实现PriorityOrdered接口和Ordered接口的...
				 *
				 *   其中也涉及到了排序过程
				 *
				 *
				 * 在这里，将用户自定义的Bean扫描为BeanDefinition，加入BeanFactory
				 *  配置类中的Selector类型的组件和@Component,@ComponentScan中的元数据信息也会在该步骤中进行解析
				 *    还包括执行条件注解@Condition的回调逻辑
				 *
				 *
				 *  ImportBeanDefinitionRegistrar对应的registerBeanDefinitions方法也会在该步骤中调用，给容器中注册自定义的组件.
				 *
				 *  注册@Import里的BeanDefinition
				 */
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				/**
				 * 6. 注册所有bean的后置处理器，用于拦截Bean的创建
				 * BeanPostProcessor会被获取实例
				 * BeanPostProcessor也会被排序，
				 * PriorityOrdered->Ordered->普通的
				 */
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				/**
				 * 7.初始化消息源
				 * 用来做国际化，消息绑定，消息解析等功能
				 * 一般在SpringMVC中会使用到.
				 */
				initMessageSource();

				// Initialize event multicaster for this context.
				/**
				 * 8.初始化事件派发器，用来发布事件
				 * 	如果容器中有类型为ApplicationEventMulticaster的派发器组件，则直接获取使用
				 * 	如果容器中没有，则默认创建一个类型为SimpleApplicationEventMulticaster的派发器并加入容器，供容器派发事件使用
				 */
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				/**
				 * 9.用来初始化一些特殊的Bean，目前默认是空方法，未实现，可以通过继承AbstractApplicationContext类，
				 *   然后覆写该方法进行自定义特殊bean的初始化.
				 *
				 * 比如：AbstractRefreshableWebApplicationContext中onRefresh方法用来初始化主题能力.
				 *
				 * SpringBoot也是在改步骤中启动内嵌Tomcat容器的
				 */
				onRefresh();

				// Check for listener beans and register them.
				/**
				 * 10.注册监听器
				 * 将监听器绑定到广播器上，将监听器对应的beanName绑定到到第8步初始化的事件派发器中，
				 *   如果之前有发布的事件，则直接通过事件派发器将事件派发出去.
				 */
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				/**
				 * 11.初始化所有剩余的单实例Bean(没有使用懒加载的Bean).整个Spring IOC的核心.
				 *
				 * 包括执行@PostConstruct标注的方法.
				 *
				 * 注意：SpringMVC的父子容器创建Bean的过程：
				 *   SpringMVC中，存在着父容器和子容器。当父容器启动之后，会通过该方法将所有的Dao和Service对应的Bean创建出来，保存到beanFactory的单例缓存容器中
				 *   当子容器启动之后，也会通过该方法将所有的Controller，viewResolver，HandlerMapping对应的Bean创建出来，然后放入到beanFactory的单例缓存容器中.
				 */
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				/**
				 *  12.发布事件。例如容器中的刷新事件:ContextRefreshedEvent就是在这一步中发布. SpringCloud在该步骤中会启动web服务
				 *
				 */
				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();
			}
		}
	}