Spring源码——2 （refresh方法）

	如果我需要在bean对象的创建过程中，详细了解每一个步骤完成的进度，我应该怎么做?
在不同的阶段娈做不同的处理工作，应该怎么办?

	观察者模式：监听器，监听事件

---

在AbstractApplicationContext抽象类中 重写了方法refresh（其中有许多方法）

1.prepareRefresh方法 (准备刷新)

准备此上下文以便刷新。

protected void prepareRefresh() {
		// Switch to active.切换到激活状态，设置一下启动时间 关闭状态设置成false 激活为true
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);

		if (logger.isDebugEnabled()) {
			if (logger.isTraceEnabled()) {
				logger.trace("Refreshing " + this);
			}
			else {
				logger.debug("Refreshing " + getDisplayName());
			}
		}

		// 初始化上下文环境中任意占位符属性源
		//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...
		// 当multicaster 可用，就发布
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

2.obtainFreshBeanFactory （获得最新的bean工厂）

告诉子类刷新内部bean工厂。

创建的这个工厂叫做 DefaultListableBeanFactory

	//AbstractApplicationContext中 获得最新的bean工厂
	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();
	}

	//AbstractRefreshableApplicationContext类中
	@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			// 创建的这个工厂叫做 DefaultListableBeanFactory
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 创建后 给一个序列化 id
			beanFactory.setSerializationId(getId());
			// 定制化设置属性
			customizeBeanFactory(beanFactory);
			// 加载bean自定义 ， 封装成对象
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

3.prepareBeanFactory(beanFactory) 准备Bean工厂

准备bean工厂以便在本文中使用。（进行beanFactory 设置属性值，属性赋值）

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		if (!shouldIgnoreSpel) {
			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.ignoreDependencyInterface(ApplicationStartup.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 (!IN_NATIVE_IMAGE && 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());
		}
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}

4.postProcessBeanFactory(beanFactory) bean工厂增强器（bean工厂后置处理器）

允许在上下文子类中对bean工厂进行后处理。

//调用的是BeanFactoryPostProcessor  的postProcessBeanFactory方法
@FunctionalInterface
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

但是点进来发现这是一个空方法
也就是说，没做扩展时里面空的，有了留给子类进行实现

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

5.invokeBeanFactoryPostProcessors(beanFactory);（调用Bean工厂后置处理器）

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

	/**
	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
	 * 实例化和调用所有被注册的Bean工厂后置处理器的beans（多个自定义的beans）
	 * respecting explicit order if given.
	 * 尊重明确的顺序（执行 先创建的按照一个顺序）
	 * <p>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 (!IN_NATIVE_IMAGE && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

6.registerBeanPostProcessors(beanFactory);

注册拦截bean创建的bean处理器。

	/**
	 * Instantiate and register all BeanPostProcessor beans,
	 * 实例化 和 注册 所有的bean后置处理器中（自定义的beans）
	 * respecting explicit order if given.
	 * 按照你制定的顺序
	 * <p>Must be called before any instantiation of application beans.
	 * 必须应用程序bean实例化之前进行 注册
	 */
	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

7.initMessageSource()初始化源信息 （国际化等）

为此上下文初始化消息源。（一个国际化处理)

	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 + "]");
			}
		}
	}

8.initApplicationEventMulticaster()初始化应用程序事件

初始化此上下文的事件multicaster（多播器，发布监听事件）。

9.onRefresh() 刷新时（空实现，子类实现）

初始化特定上下文子类中的其他特殊bean。

10.registerListeners() 注册监听器

检查侦听器bean并注册它们。（实例化之前会进行监听）

11.finishBeanFactoryInitialization(beanFactory) 完成bean工厂初始化

实例化所有剩余的（非懒加载初始化）单例。

找到他的实现类

进行反射哪几项 实例化创建bean对象

12.finishRefresh() 完成刷新

最后一步：发布相应的事件。

	/**
	 * Finish the refresh of this context, invoking the LifecycleProcessor's
	 * onRefresh() method and publishing the
	 * {@link org.springframework.context.event.ContextRefreshedEvent}.
	 */
	@SuppressWarnings("deprecation")
	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.
		if (!IN_NATIVE_IMAGE) {
			LiveBeansView.registerApplicationContext(this);
		}
	}