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

		...
    }
}

public class AnnotationConfigServletWebServerApplicationContext
		extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {

    ...
	
	@Override
	protected void prepareRefresh() {
	
	    // 清除 Class 的元數據緩存。底層用 Map 保存元數據，執(zhí)行 Map 的 clear 方法
		this.scanner.clearCache();
		
		// 調用父類，也就是 AbstractApplicationContext 的 prepareRefresh 方法
		super.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();
    	
    	// 記錄此上下文是否已關閉，這里設置為未關閉
    	this.closed.set(false);
    	
    	// 記錄此上下文是否處于活動狀態(tài)，這里設置為活動狀態(tài)
    	this.active.set(true);
    
    	if (logger.isInfoEnabled()) {
    		logger.info("Refreshing " + this);
    	}
    
    	// 這也是交由子類擴展的方法。具體子類為 GenericWebApplicationContext，主要是初始化屬性源，
    	// 將 ServletContext 和 ServletConfig 屬性配置添加到 Environment 環(huán)境上下文中
    	initPropertySources();
    
    	// 校驗 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() {
        // 該方法也是由子類擴展，其子類有 AbstractRefreshableApplicationContext 和 GenericApplicationContext，
        // 因當前是 Servlet Web 應用，所以執(zhí)行的是 GenericApplicationContext 中的 refreshBeanFactory 方法。
        // 該方法主要設置 BeanFactory 的 serializationId 屬性值，也就是序列化id
    	refreshBeanFactory();
    	
    	// 通過 getBeanFactory 返回 BeanFactory 對象。同樣也是由子類擴展，調用的是 GenericApplicationContext 類中的 getBeanFactory 方法。
    	// 返回的是 DefaultListableBeanFactory 。
    	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    	if (logger.isDebugEnabled()) {
    		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    	}
    	return beanFactory;
    }
    
    ...
}

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

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 設置類加載器
	beanFactory.setBeanClassLoader(getClassLoader());
	// 設置表達式解析器，主要用來解析 EL 表達式； Bean 初始化完成后填充屬性時會用到
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	// 設置屬性注冊解析器，主要用來解析 Bean 中的各種屬性類型，如 String、int 等
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
	// 添加一個后置處理器：ApplicationContextAwareProcessor。
	// 該后置處理器用于向實現了 Aware 系列接口的 bean 設置相應屬性。
	// （后置處理器和 Aware 接口也是比較核心的概念，后面會有文章詳細討論）
	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);

	// 當以下特殊的 Bean 需自動注入時，指定其注入的類型 。
	// 如：注入 BeanFactory 時，注入的類型對象為 ConfigurableListableBeanFactory 。
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	// 添加 ApplicationListenerDetector 后置處理器。
	// 該后置處理器用來檢測那些實現了 ApplicationListener 接口的 bean，并將其添加到應用上下文的事件廣播器上。
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// 判斷容器中是否存在 loadTimeWeaver Bean，如果存在則上下文使用臨時的 ClassLoader 進行類型匹配。
	// 集成 AspectJ 時會用到 loadTimeWeaver 對象。
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// 注冊和環(huá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);
        ...   
    }
}

public class AnnotationConfigServletWebServerApplicationContext
		extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {

    private final AnnotatedBeanDefinitionReader reader;

	private final ClassPathBeanDefinitionScanner scanner;

	private final Set<Class<?>> annotatedClasses = new LinkedHashSet<>();

	private String[] basePackages;
    
    ...
    
	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 先執(zhí)行父類 ServletWebServerApplicationContext 的 postProcessBeanFactory 方法。
		// 跳轉到 1 查看父類實現
		super.postProcessBeanFactory(beanFactory);
		
		// basePackages 存儲的是類路徑。先判斷是否為 null，不為 null 則通過 ClassPathBeanDefinitionScanner 的 scan 方法
		// 掃描該路徑下符合條件的 Class，并將 Class 信息包裝成 BeanDefinition 注冊到容器中，
		// 當然，這里沒有指定掃描路徑，所以不會進入這個 if。
		// （BeanDefinition 概念會在后面章節(jié)詳細討論）
		if (this.basePackages != null && this.basePackages.length > 0) {
			this.scanner.scan(this.basePackages);
		}
		
		// annotatedClasses 存儲的 Class 集合。先判斷該集合是否為空，不為空則通過
		// AnnotatedBeanDefinitionReader 的 register 方法將 Class 信息包裝成 BeanDefinition 注冊到容器中，
		// 這里同樣沒有設置 Class 集合內容，所以不會進入這個 if。
		if (!this.annotatedClasses.isEmpty()) {
			this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
		}
	}	    
}

1、
public class ServletWebServerApplicationContext extends GenericWebApplicationContext
		implements ConfigurableWebServerApplicationContext {
    ...

    @Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 添加 BeanPostProcessor 后置處理器：WebApplicationContextServletContextAwareProcessor，
		// 該后置處理器主要是從 ConfigurableWebApplicationContext 上下文中獲取 ServletContext 和 ServletConfig 對象
		beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
		
		// 添加一個 忽略自動注入的接口
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
	}
    ...		    
}