/**
 * Central interface to provide configuration for an application.
 * This is read-only while the application is running, but may be
 * reloaded if the implementation supports this.
 *
 * <p>An ApplicationContext provides:
 * <ul>
 * <li>Bean factory methods for accessing application components.
 * Inherited from {@link org.springframework.beans.factory.ListableBeanFactory}.
 * <li>The ability to load file resources in a generic fashion.
 * Inherited from the {@link org.springframework.core.io.ResourceLoader} interface.
 * <li>The ability to publish events to registered listeners.
 * Inherited from the {@link ApplicationEventPublisher} interface.
 * <li>The ability to resolve messages, supporting internationalization.
 * Inherited from the {@link MessageSource} interface.
 * <li>Inheritance from a parent context. Definitions in a descendant context
 * will always take priority. This means, for example, that a single parent
 * context can be used by an entire web application, while each servlet has
 * its own child context that is independent of that of any other servlet.
 * </ul>
 *
 * <p>In addition to standard {@link org.springframework.beans.factory.BeanFactory}
 * lifecycle capabilities, ApplicationContext implementations detect and invoke
 * {@link ApplicationContextAware} beans as well as {@link ResourceLoaderAware},
 * {@link ApplicationEventPublisherAware} and {@link MessageSourceAware} beans.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @see ConfigurableApplicationContext
 * @see org.springframework.beans.factory.BeanFactory
 * @see org.springframework.core.io.ResourceLoader
 */
 
 public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    String getId();

    String getApplicationName();

    String getDisplayName();

    long getStartupDate();

    ApplicationContext getParent();

    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
        throws BeansException {
    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        refresh();
    }
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {

    	// 刷新前准备，主要是设置开始时间以及标识active标志位为true
    	prepareRefresh();
    
    	// 从配置中加载BeanDefinition, 创建BeanFactory实例
    	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    	// BeanFactory准备工作
    	// 1. 设置加载Bean用的ClassLoader，解析Bean定义表达式的表达式解析器，读取BeanDefinition的属性编辑注册器。
    	// 2. 添加ApplicationContextAwareProcessor这个BeanPostProcessor。
    	// 3. 设置特殊的Bean，BeanFactory, ResourceLoader, ApplicationEventPublisher, ApplicationContext。
    	// 4. 设置环境变量。
    	prepareBeanFactory(beanFactory);
    
    	try {
    	    // 在BeanFactory创建完成后，交给子类实现的一个扩展点，如web项目中配置ServletContext
    		postProcessBeanFactory(beanFactory);
    
    		// 实例化并执行所有注册的BeanFactoryPostProcessor
    		invokeBeanFactoryPostProcessors(beanFactory);
    
    		// 实例化并注册所有BeanPostProcessor
    		registerBeanPostProcessors(beanFactory);
    
    		// 初始化消息源
    		initMessageSource();
    
    		// 初始化上下文事件机制
    		initApplicationEventMulticaster();
    		
    		// 为特殊的上下文预留的方法，初始化特殊的bean
    		onRefresh();
    
    		// 注册监听器
    		registerListeners();
    
    		// 冻结所有配置并实例化所有非lazy-init的单例bean
    		finishBeanFactoryInitialization(beanFactory);
    
    		// 初始化生命周期，发布容器事件
    		finishRefresh();
    	}
    
    	catch (BeansException ex) {
    		logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);
    
    		// 销毁已经创建的单例bean
    		destroyBeans();
    
    		// 重置active标识
    		cancelRefresh(ex);
    
    		throw ex;
    	}
    }
}

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	refreshBeanFactory();
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}

protected final void refreshBeanFactory() throws BeansException {
	// 如果已存在BeanFactory，则销毁所有bean并关闭BeanFactory
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		// 实例化一个新的BeanFactory
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		// 设置序列化id为唯一id
		beanFactory.setSerializationId(getId());
		// BeanFactory的自定义配置
		customizeBeanFactory(beanFactory);
		// 加载BeanDefinitions
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

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

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

	// 设置classLoader(用于加载bean)
	beanFactory.setBeanClassLoader(getClassLoader());
	
	// 设置表达式解析器StandardBeanExpressionResolver(解析bean定义中的一些表达式)
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	
	// 添加属性编辑注册器(注册属性编辑器)
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// 添加ApplicationContextAwareProcessor这个BeanPostProcessor，保存在beanFactory的beanPostProcessors列表中
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	
	/** 
	 * 取消
	 * EnvironmentAware, 
	 * EmbeddedValueResolverAware,
	 * ResourceLoaderAware, 
	 * ApplicationEventPublisherAware, 
	 * MessageSourceAware, 
	 * ApplicationContextAware这6个接口的自动注入。
	 * 因为ApplicatioinContextAwareProcessor把这6这个接口的实现工作做了。
	 * 
	 */
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

	/**
	 * 设置特殊类型对应的bean。
	 * beanFactory对应刚刚获取的BeanFactory
	 * ResourceLoader, ApplicationEventPublisher, ApplicationContext这3个接口对应的bean都设置为当前的Spring容器。
	 * 
	 * 保存在beanFactory的resolvableDependencies(ConcurrentHashMap)中。
	 */
	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));

	// 检查代码织入
	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()));
	}

	/**
	 * 注册默认的environment, systemProperties, systemEnvironment
	 * 保存在beanFactory的singletonObjects(ConcurrentHashMap)、registeredSingletons(LinkedHashSet)、manualSingletonNames(LinkedHashSet)中
	 */
	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());
	}
}

//ResourceAdapterApplicationContext中override的postProcessBeanFactory()方法：
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    beanFactory.addBeanPostProcessor(new BootstrapContextAwareProcessor(this.bootstrapContext));
    beanFactory.ignoreDependencyInterface(BootstrapContextAware.class);
    beanFactory.registerResolvableDependency(BootstrapContext.class, this.bootstrapContext);
    beanFactory.registerResolvableDependency(WorkManager.class, new ObjectFactory<WorkManager>() {
        public WorkManager getObject() {
            return ResourceAdapterApplicationContext.this.bootstrapContext.getWorkManager();
        }
    });
}

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

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

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

// Check for listener beans and register them.
registerListeners();