public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
	// 准备上下文刷新，准备此上下文以进行刷新，设置其启动日期和是否正在刷新的,
	//标志以及验证标记为必需的所有属性是否可解析等。
	prepareRefresh();

	// 告诉子类刷新内部bean工厂，并返回一个ConfigurableListableBeanFactory实例,
	//在这一步里，Spring将配置文件的信息装入容器的BeanDefintion，此时Bean还未初始化。
	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

	// 让当前这个beanfactory接手当前上下文，包括设置类加载器（setBeanClassLoader）,
	//设置后置处理器（addBeanPostProcessor），BeanFactory接口不在普通工厂中注册为可解析类型。
	prepareBeanFactory(beanFactory);

	try {
		// 允许在上下文子类中对bean工厂进行后处理。
		postProcessBeanFactory(beanFactory);

		//调用工厂后置处理器
		invokeBeanFactoryPostProcessors(beanFactory);

		// 注册后置处理器
		registerBeanPostProcessors(beanFactory);

		// 初始化消息源
		initMessageSource();

		// 初始化上下文事件广播器.
		initApplicationEventMulticaster();

		// 初始化其他特殊的Bean，由具体子类实现
		onRefresh();

		// 检查并注册事件监听器
		registerListeners();

		// 除了懒加载模式的Bean，其他的Bean全部初始化并且单实例化
		finishBeanFactoryInitialization(beanFactory);

		// 发布事件公高，完成容器刷新.
		finishRefresh();
	}

	catch (BeansException ex) {
		if (logger.isWarnEnabled()) {
		logger.warn("Exception encountered during context initialization - " +
			"cancelling refresh attempt: " + ex);
		}

		// 清除已经加载的Bean，避免资源浪费
		destroyBeans();

		// 重置刷新标志为false（active = false）
		cancelRefresh(ex);

		// 发布异常
		throw ex;
	}

	finally {
		//重置Spring在初始化IOC容器过程中的缓存
		resetCommonCaches();
	}
	}
}

protected void prepareRefresh() {
	// 表示在真正做refresh操作之前需要准备做的事情：
 
	// 设置Spring容器的启动时间，撤销关闭状态，开启活跃状态。
	this.startupDate = System.currentTimeMillis();
	this.closed.set(false);
	this.active.set(true);
 
	if (logger.isInfoEnabled()) {
		logger.info("Refreshing " + this);
	}
 
	// Initialize any placeholder property sources in the context environment
	// 初始化属性源信息,初始化占位符
	initPropertySources();
 
	// Validate that all properties marked as required are resolvable
	// see ConfigurablePropertyResolver#setRequiredProperties
	// 验证环境信息里一些必须存在的属性
	getEnvironment().validateRequiredProperties();
 
	// Allow for the collection of early ApplicationEvents,
	// to be published once the multicaster is available...
	this.earlyApplicationEvents = new LinkedHashSet<>();
}

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	// 获取刷新Spring上下文的Bean工厂
	refreshBeanFactory();
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// Tell the internal bean factory to use the context's class loader etc.
	// 设置classloader(用于加载bean)，设置表达式解析器(解析bean定义中的一些表达式)，添加属性编辑注册器(注册属性编辑器)
	beanFactory.setBeanClassLoader(getClassLoader());
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
 
	// Configure the bean factory with context callbacks.
	// 添加ApplicationContextAwareProcessor这个BeanPostProcessor。取消ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware、EnvironmentAware这5个接口的自动注入。
	// 因为ApplicationContextAwareProcessor把这6个接口的实现工作做了
	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.
	// 设置特殊的类型对应的bean。BeanFactory对应刚刚获取的BeanFactory；
	// ResourceLoader、ApplicationEventPublisher、ApplicationContext这3个接口对应的bean都设置为当前的Spring容器
	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.
	// 注入一些其它信息的bean实例，比如environment、systemProperties等
	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());
	}
}

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()));
	}
}

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);