public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
	......
	//加載或刷新配置的持久表示形式，
    //可能是XML文件、屬性文件或關(guān)系數(shù)據(jù)庫模式。
    //由于這是一個啟動方法，它應(yīng)該銷毀已經(jīng)創(chuàng)建的單例
    //如果失敗，則避免懸而未決的資源。換句話說，在調(diào)用該方法之后，要么全部實(shí)例化，要么根本不實(shí)例化。
    //如果無法初始化bean工廠，則拋出BeanException異常，拋出IllegalStateException異常
    //如果已初始化且不支持多次刷新嘗試
	void refresh() throws BeansException, IllegalStateException;
    ......
}

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
    ......
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 準(zhǔn)備此上下文以進(jìn)行刷新
			prepareRefresh();
			// 告訴子類刷新內(nèi)部bean工廠
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// 準(zhǔn)備bean工廠，以便在此上下文中使用
			prepareBeanFactory(beanFactory);
			try {
				// 允許在上下文子類中對bean工廠進(jìn)行后處理
				postProcessBeanFactory(beanFactory);
				// 調(diào)用在上下文中注冊為bean的工廠處理器
				invokeBeanFactoryPostProcessors(beanFactory);
				// 注冊攔截bean創(chuàng)建的bean處理器
				registerBeanPostProcessors(beanFactory);
				// 為此上下文初始化消息源。
				initMessageSource();
				// 為此上下文初始化事件多播
				initApplicationEventMulticaster();
				// 初始化特定上下文子類中的其他特殊bean
				onRefresh();
				// 檢查偵聽器bean并注冊它們
				registerListeners();
				// 實(shí)例化所有剩余的（非懶加載）單例
				finishBeanFactoryInitialization(beanFactory);
				// 最后一步：發(fā)布相應(yīng)的事件
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				// 銷毀已創(chuàng)建的單例以避免懸空資源
				destroyBeans();
				// 重置“活動”標(biāo)志
				cancelRefresh(ex);
				// 將異常傳播到調(diào)用方
				throw ex;
			}
			finally {
				// 重置Spring核心中的常見內(nèi)省緩存，因?yàn)槲覀兛赡懿辉傩枰獑卫齜ean的元數(shù)據(jù)。。。
				resetCommonCaches();
			}
		}
	}
 ......
}

public class contextText {
	ApplicationContext context = new ClassPathXmlApplicationContext("spring-bean.xml");
}

public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
......
	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh();
		}
	}
......
}

public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 初始化上下文環(huán)境，就是記錄下容器的啟動時間、活動狀態(tài)等
		prepareRefresh();
		...
    }
}

public abstract class AbstractApplicationContext {
    ...
    private long startupDate;
    private final AtomicBoolean active = new AtomicBoolean();
	private final AtomicBoolean closed = new AtomicBoolean();
    private Set<ApplicationEvent> earlyApplicationEvents;
    ...
    protected void prepareRefresh() {
        // 記錄此上下文開始時的系統(tǒng)時間（以毫秒為單位）
    	this.startupDate = System.currentTimeMillis();
    	// 記錄此上下文是否已關(guān)閉，這里設(shè)置為未關(guān)閉
    	this.closed.set(false);
    	// 記錄此上下文是否處于活動狀態(tài)，這里設(shè)置為活動狀態(tài)
    	this.active.set(true);
    	if (logger.isInfoEnabled()) {
    		logger.info("Refreshing " + this);
    	}
    	// 這也是交由子類擴(kuò)展的方法。具體子類為 GenericWebApplicationContext，主要是初始化屬性源，
    	// 將 ServletContext 和 ServletConfig 屬性配置添加到 Environment 環(huán)境上下文中
    	initPropertySources();
    	// 校驗(yàn) Environment 中那些必備的屬性配置是否存在，不存在則拋異常。
    	getEnvironment().validateRequiredProperties();
    	// 創(chuàng)建 ApplicationEvent 事件集合
    	this.earlyApplicationEvents = new LinkedHashSet<>();
    }
}

public abstract class AbstractApplicationContext {
    ...
    public void refresh() throws BeansException, IllegalStateException {
    	synchronized (this.startupShutdownMonitor) {
    		...
    		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    		...
    	}
    }
    ...
    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        // 該方法也是由子類擴(kuò)展，其子類有 AbstractRefreshableApplicationContext 和 GenericApplicationContext，
        // 該方法主要設(shè)置 BeanFactory 的 serializationId 屬性值，也就是序列化id
    	refreshBeanFactory();
    	// 通過 getBeanFactory 返回 BeanFactory 對象。同樣也是由子類擴(kuò)展，調(diào)用的是 GenericApplicationContext 類中的 getBeanFactory 方法。
    	// 返回的是 DefaultListableBeanFactory 。
    	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    	if (logger.isDebugEnabled()) {
    		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    	}
    	return beanFactory;
    }
    ...
}

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
   ......
	/** Bean factory for this context */
	@Nullable
	private DefaultListableBeanFactory beanFactory;
    ......
	@Override
	public final ConfigurableListableBeanFactory getBeanFactory() {
		synchronized (this.beanFactoryMonitor) {
			if (this.beanFactory == null) {
				throw new IllegalStateException("BeanFactory not initialized or already closed - " +
						"call 'refresh' before accessing beans via the ApplicationContext");
			}
			return this.beanFactory;
		}
	}
    ......
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        ...
		prepareBeanFactory(beanFactory);
		...	
    }
    ...
}
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 設(shè)置類加載器
	beanFactory.setBeanClassLoader(getClassLoader());
	// 設(shè)置表達(dá)式解析器，主要用來解析 EL 表達(dá)式； Bean 初始化完成后填充屬性時會用到
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	// 設(shè)置屬性注冊解析器，主要用來解析 Bean 中的各種屬性類型，如 String、int 等
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
	// 添加一個后置處理器：ApplicationContextAwareProcessor。
	// 該后置處理器用于向?qū)崿F(xiàn)了 Aware 系列接口的 bean 設(shè)置相應(yīng)屬性。
	// （后置處理器和 Aware 接口也是比較核心的概念，后面會有文章詳細(xì)討論）
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	// 以下接口，在自動注入時會被忽略，其都是 Aware 系列接口
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
	// 當(dāng)以下特殊的 Bean 需自動注入時，指定其注入的類型 。
	// 如：注入 BeanFactory 時，注入的類型對象為 ConfigurableListableBeanFactory 。
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);
	// 添加 ApplicationListenerDetector 后置處理器。
	// 該后置處理器用來檢測那些實(shí)現(xiàn)了 ApplicationListener 接口的 bean，并將其添加到應(yīng)用上下文的事件廣播器上。
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
	// 判斷容器中是否存在 loadTimeWeaver Bean，如果存在則上下文使用臨時的 ClassLoader 進(jìn)行類型匹配。
	// 集成 AspectJ 時會用到 loadTimeWeaver 對象。
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
	// 注冊和環(huán)境相關(guān)的 Bean，如 environment、systemProperties、systemEnvironment
	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());
	}
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        ...
        postProcessBeanFactory(beanFactory);
        ...   
    }
}