Spring 启动过程--基于xml配置的bean

既然是基于xml配置bean，那么首先看一下book.xml文件：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="book"  class="com.pojo.Book">
        <property name="name" value="spring">property>
    bean>
beans>

然后再看一下spring的启动类：

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("book.xml");
        Book book =(Book) context.getBean("book");
        System.out.println(book.getName());
    }
}

查看spring的应用上下文,构造函数new ClassPathXMLApplicationContext(“book.xml”)

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
	}

然后可以看到

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh();
		}
	}

1、启动的环境super(parent);

首先是ClassPathXmlApplicationContext调用父类的方法super(parent),即AbstractXmlApplicationContext类的方法，该类又调用其父类AbstractRefreshableConfigApplicationContext的方法，该类又调用AbstractRefreshableApplicationContext类的方法，该类又调用AbstractApplicationContext类的方法，其中包含setParent(parent)方法，即

	@Override
	public void setParent(@Nullable ApplicationContext parent) {
		this.parent = parent;
		if (parent != null) {
			Environment parentEnvironment = parent.getEnvironment();
			if (parentEnvironment instanceof ConfigurableEnvironment) {
				getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
			}
		}
	}

其中getEnvironment()

/* 如果有environment的值，那么就设置为当前的environment值；如果没有设置环境，那么就启用默认的creatEnvironment()创建默认的环境*/
public ConfigurableEnvironment getEnvironment() {
		if (this.environment == null) {
			this.environment = createEnvironment();
		}
		return this.environment;
	}

默认的createEnvironment()方法：

protected ConfigurableEnvironment createEnvironment() {
		return new StandardEnvironment();
	}

即创建一个标准的环境。StandardEnvironment的具体内容是：

public class StandardEnvironment extends AbstractEnvironment {

	/** System environment property source name: {@value}. */
	public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";

	/** JVM system properties property source name: {@value}. */
	public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";


	@Override
	protected void customizePropertySources(MutablePropertySources propertySources) {
		propertySources.addLast(
				new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
		propertySources.addLast(
				new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
	}

}

由于StandardEnvironment 继承 AbstractEnvironment，AbstractEnvironment又实现了ConfigurableEnvironment接口。

上述几个类的关系是：

继承

继承

继承

继承

AbstractRefreshableApplicationContext

AbstractApplicationContext

AbstractRefreshableConfigApplicationContext

AbstractXmlApplicationContext

ClassPathXmlApplicationContext

2、设置配置文件setConfigLocations(configLocations)

	/**
	 * Set the config locations for this application context.
	 * 
If not set, the implementation may use a default as appropriate.
	 */
	public void setConfigLocations(@Nullable String... locations) {
		if (locations != null) {
			Assert.noNullElements(locations, "Config locations must not be null");
			this.configLocations = new String[locations.length];
			for (int i = 0; i < locations.length; i++) {
				this.configLocations[i] = resolvePath(locations[i]).trim();
			}
		}
		else {
			this.configLocations = null;
		}
	}

这里设置的locations是可变参数，可以设置多个xml配置文件，也可以不设置。如果不设置，那么就使用默认的设置。

3、刷新–refresh()

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				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();
			}
		}
	}

首先，是synchronized (this.startupShutdownMonitor) ，这一步的操作是保证容器初始化是互斥的，容器只加载和初始化一次。

3.1 prepareRefresh()

准备reFresh的spring上下文：

	/**准备用来刷新的上下文，设置其启动时间和active标志以及执行属性源的任何初始化。
	 * Prepare this context for refreshing, setting its startup date and
	 * active flag as well as performing any initialization of property sources.
	 */
	protected void prepareRefresh() {
		// Switch to active.
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);

		// Initialize any placeholder property sources in the context environment.
		initPropertySources();//子类什么也不做，函数体为空

		// Validate that all properties marked as required are resolvable:
		// see ConfigurablePropertyResolver#setRequiredProperties
		getEnvironment().validateRequiredProperties();

		// Store pre-refresh ApplicationListeners...
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

• 首先是设置active标志为true，
• 然后初始化资源。这里的初始化资源，函数体为空，即子类什么也不错。
• 然后验证所有被标记为required的properties。这里getEnvironment()的返回值为ConfigurableEnvironment类型，然后执行validateRequiredProperties()方法。该方法是接口ConfigurablePropertyResolver的方法，这里使用到的实现类为AbstractPropertyResolver：

@Override
	public void validateRequiredProperties() {
		MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
		for (String key : this.requiredProperties) {
			if (this.getProperty(key) == null) {
				ex.addMissingRequiredProperty(key);
			}
		}
		if (!ex.getMissingRequiredProperties().isEmpty()) {
			throw ex;
		}
	}

这里的this.requiredProperties是setRequiredProperties(String… requiredProperties)方法设置的所需要的properties

public void setRequiredProperties(String... requiredProperties) {
		for (String key : requiredProperties) {
			this.requiredProperties.add(key);
		}
	}

如果有被指定为required的property没有获取到，那么就会抛出MissingRequiredPropertiesException异常。

• 存储pre-refresh ApplicationListeners：如果没有earlyApplicationListeners就新建一个，如果有就reset为pre-refresh状态
• 允许 this.earlyApplicationEvents = new LinkedHashSet<>();

3.2 obtainFreshBeanFactory()

通知子类刷新内部的beanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();
	}

可以看到，其中调用的是refreshBeanFactory()方法，该方法在抽象类AbstractApplicationContext中只是抽象方法，没有实现，由其子类AbstractRefreshableApplicationContext实现具体方法：

	@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

• 如果已经有BeanFactory存在，那么先销毁Bean，然后关闭BeanFactory。

• 然后创建一个BeanFactory：

  protected DefaultListableBeanFactory createBeanFactory() {
  		return new DefaultListableBeanFactory(getInternalParentBeanFactory());
  	}
  

  为当前上下文创建一个内部的BeanFactory，其中传入的getInternalParentBeanFactory()

  /**
  	 * Return the internal bean factory of the parent context if it implements
  	 * ConfigurableApplicationContext; else, return the parent context itself.
  	 * @see org.springframework.context.ConfigurableApplicationContext#getBeanFactory
  	 */
  @Nullable
  	protected BeanFactory getInternalParentBeanFactory() {
  		return (getParent() instanceof ConfigurableApplicationContext ?
  				((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent());
  	}
  

  如果实现了ConfigurableApplicationContext，那么就调用其父类的上下文的BeanFactory，否则就返回其父类本身。

• 设置BeanFactory的SerializationId

• 由当前上下文对BeanFactory做个性化设置

  protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
  		if (this.allowBeanDefinitionOverriding != null) {
  			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
  		}
  		if (this.allowCircularReferences != null) {
  			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
  		}
  	}
  

• 加载loadBeanDefinitions()

  由于当前类AbstractRefreshableApplicationContext没有具体实现loadBeanDefinitions的内容，由其子类实现，这里由AbstractXmlApplicationContext类实现：

  @Override
  	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
  		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
  		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
  
  		// Configure the bean definition reader with this context's
  		// resource loading environment.
  		beanDefinitionReader.setEnvironment(this.getEnvironment());
  		beanDefinitionReader.setResourceLoader(this);
  		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
  
  		// Allow a subclass to provide custom initialization of the reader,
  		// then proceed with actually loading the bean definitions.
  		initBeanDefinitionReader(beanDefinitionReader);
  		loadBeanDefinitions(beanDefinitionReader);
  	}
  

  • 首先创建一个XMLBeanDefinitionReader给这个给定的BeanFactory；
  • 在加载环境时配置当前的上下文的bean definition reader
  • 允许子类的自定义reader，然后处理实际加载的定义

3.3 prepareBeanFactory(beanFactory)准备当前上下文的BeanFactory

	/**
	 * Configure the factory's standard context characteristics,
	 * such as the context's ClassLoader and post-processors.
	 * @param beanFactory the BeanFactory to configure
	 */
	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		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);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// Register default environment beans.
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

• 首先设置让BeanFactory去使用当前上下文的classloader、ExpressionResolver和PropertyEditorRegistrar
• 使用上下文回调配置BeanFactory，包括bean的后置处理器
• 把未注册为可解析类型的BeanFactory 接口，注册为bean
• 将早期的用来检测内部bean的早期后置处理器注册为ApplicationListeners
• 如果有LoadTimerWeaver，就准备weaving，并设置一个临时的classLoader。（为啥要设置？）
• 设置默认的环境bean

3.4 postProcessBeanFactory(beanFactory)

后置BeanFactory处理，这里的函数体为空

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

在标准初始化之后，允许修改该上下文的内部bean factory。

3.5 invokeBeanFactoryPostProcessors(beanFactory)

调用工厂处理器在当前上下文中注册bean。

/**
	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
	 * respecting explicit order if given.
	 * 
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 Bean，如果给定顺序，则遵循显式顺序。必须在单例实例化之前调用。

如果在这个时候发现loadTimerWeaver，那么就准备织入。

这里的BeanFactoryPostProcessor是在bean被创建之前的操作。

在创建xml定义的bean之前，需要先创建三个spring需要的bean：environment、systemProperties和systemEnvironment。

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());操作的过程如下：

3.6 registerBeanPostProcessors(beanFactory)

注册bean的后置处理器：Register bean processors that intercept bean creation.注册拦截bean创建的处理器。

/**
	 * Instantiate and register all BeanPostProcessor beans,
	 * respecting explicit order if given.
	 * 
Must be called before any instantiation of application beans.
	 */
	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

如果有顺序，按给定顺序实例化和注册所有的bean。必须在应用bean实例化之前被调用。

这里使用了委托代理的方式，调用registerBeanPostProcessors(beanFactory, this)。

3.7 initMessageSource();

初始化消息资源

	/**
	 * Initialize the MessageSource.
	 * Use parent's if none defined in this context.
	 */
	protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			// Make MessageSource aware of parent MessageSource.
			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
				if (hms.getParentMessageSource() == null) {
					// Only set parent context as parent MessageSource if no parent MessageSource
					// registered already.
					hms.setParentMessageSource(getInternalParentMessageSource());
				}
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			// Use empty MessageSource to be able to accept getMessage calls.
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
			}
		}
	}

查看beanFactory中是否含有“messagesource”这个bean，没有就去调用父类的messagesource。有的话就用beanFactory中有的，如果parent中没有MessageSource，就把这个Messagesource设置为parent的Messagesource。

3.8 initApplicationEventMulticaster();

	/**
	 * Initialize the ApplicationEventMulticaster.
	 * Uses SimpleApplicationEventMulticaster if none defined in the context.
	 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
	 */
	protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
						"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
			}
		}
	}

初始化ApplicationEventMulticaster，如果beanFactory中没有，那么就new一个SimpleApplicationEventMulticaster。

3.9 onRefresh();

	/**
	 * Template method which can be overridden to add context-specific refresh work.
	 * Called on initialization of special beans, before instantiation of singletons.
	 * 
This implementation is empty.
	 * @throws BeansException in case of errors
	 * @see #refresh()
	 */
	protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
	}

初始化一些特殊的bean，但是这里没有任何操作。

3.10 registerListeners();

/**
	 * Add beans that implement ApplicationListener as listeners.
	 * Doesn't affect other listeners, which can be added without being beans.
	 */
	protected void registerListeners() {
		// Register statically specified listeners first.
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let post-processors apply to them!
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// Publish early application events now that we finally have a multicaster...
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

添加作为listener的bean。

3.11 finishBeanFactoryInitialization(beanFactory);

/**
	 * Finish the initialization of this context's bean factory,
	 * initializing all remaining singleton beans.
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

3.12 finishRefresh

	/**
	 * Finish the refresh of this context, invoking the LifecycleProcessor's
	 * onRefresh() method and publishing the
	 * {@link org.springframework.context.event.ContextRefreshedEvent}.
	 */
	protected void finishRefresh() {
		// Clear context-level resource caches (such as ASM metadata from scanning).
		clearResourceCaches();

		// Initialize lifecycle processor for this context.
		initLifecycleProcessor();

		// Propagate refresh to lifecycle processor first.
		getLifecycleProcessor().onRefresh();

		// Publish the final event.
		publishEvent(new ContextRefreshedEvent(this));

		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}

3.13 resetCommonCaches();

最终，重置caches。