Spring的启动过程

Spring的启动过程

Spring的启动过程：描述Spring容器的启动的过程；涵盖了启动时候的所有的过程，自己的学习记录一下；

1、新建我们的IOC容器

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

2、调用refresh();方法，初始化我们的IOC容器

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
   
		this();
		register(annotatedClasses);
		refresh();
}

3、第一步：准备上下文环境；prepareRefresh();

@Override
	protected void prepareRefresh() {
   
    // 清理我们的扫描对象
		this.scanner.clearCache();
		super.prepareRefresh();
}

这里的sanner是ClassPathBeanDefinitionScanner 组件，主要的功能是根据我们的路径以及给定的bean的注册起注册我们的bean组件。也就是发现@Component、@Repository、@Service、@Controller这些注解的组件；

4、第二步：得到一个beanFactory对象：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   
    // 刷bean的对象
		refreshBeanFactory();
  	//得到beanfactory组件
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
   
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
}

得到的beanFactory的类型是：DefaultListableBeanFactory，这就是我们的bean的工厂，创建我们的接下来的bean组件。

5、第三步：预处理beanFactory组件：prepareBeanFactory(beanFactory);

5.1 首先告诉bean factory 用的上下文类加载器

// 设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置EL表达式的解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 设置ResourceEditorRegistrar注册器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

5.2 配置bean factory的回掉，也就是XXXXAware，

		// 添加后置处理器
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

5.3 设置environment=StandardEnvironment

beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

@Override
	public ConfigurableEnvironment getEnvironment() {
   
		if (this.environment == null) {
   
			this.environment = createEnvironment();
		}
		return this.environment;
}

5.4 设置 systemProperties= 系统变量

beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());

5.5 设置系统的环境 systemEnvironment

6、第四步：给子实现类一个机会 对 beanFactory组件进行后处理

postProcessBeanFactory(beanFactory);

/**
	 * Modify the application context's internal bean factory after its standard
	 * initialization. All bean definitions will have been loaded, but no beans
	 * will have been instantiated yet. This allows for registering special
	 * BeanPostProcessors etc in certain ApplicationContext implementations.
	 * @param beanFactory the bean factory used by the application context
	 */
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   
	}

这个时候改变的时候，是所有的bean的定义已经加载完毕，但是全部都是没有初始化的，这个时候，我们可以修改里面的基本属性。这个允许注册特殊的BeanPostProcessors 后置处理器。

7、第五步：调用bean工厂的后置处理器：invokeBeanFactoryPostProcessors(beanFactory);

/**
	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
	 * respecting explicit order if given.
	 * <p>Must be called before singleton instantiation.
	 */
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   
    // 具体的实现，是这个方法帮助咱们实现的
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
   
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

初始化以及调用所有 BeanFactoryPostProcessor 的对象，根据跟定的顺序

7.1 首先，在IOC容器中获取到所有的beanFactory的后置处理器；BeanDefinitionRegistryPostProcessor定义的后置处理器；

// 首先获取到后置处理器的名字
String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

之后根据优先级进行分类：

PriorityOrdered：实现该接口的后置处理器先执行；

Ordered：实现该接口的后置处理器中间执行；

没有任何实现的，最后执行；

/**
	 * Invoke the given BeanDefinitionRegistryPostProcessor beans.
	 */
	private static void invokeBeanDefinitionRegistryPostProcessors(
			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
   

		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
   
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		}
}

之后调用postProcessBeanFactory的回掉：

invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

7.2 其次：在IOC容器中获取到所有的BeanFactoryPostProcessor后置处理器：

String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

它的处理的过程与上面的BeanDefinitionRegistryPostProcessor是类似的&#x