spring启动流程探索二、refresh()（1）

refresh()

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//准备上下文刷新，设置启动时间，和存活标志，加载资源
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			// 告诉子类刷新内部 bean factory
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			// 在上下文中 准备beanFactory
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				// 处理在beanfactory 的postProcess
				// 主要是提供给三方框架来扩展的
				postProcessBeanFactory(beanFactory);
				// 调用工厂处理器注册beans到上下文
				// Invoke factory processors registered as beans in the context.
				// 处理beanFactory内部的beanFactoryPostProcessors
				// 然后处理注册在beanFactory 的BeanDefinitionRegistryPostProcessor
				// 按PriorityOrdered >Ordered>none的顺序执行postProcessBeanDefinitionRegistry方法
				// 再执行postProcessBeanFactory方法

				//2. 处理注册再beanFactory 的BeanFactoryPostProcessor
				// 按PriorityOrdered >Ordered>none的顺序执行postProcessBeanFactory
				// 清除缓冲 todo 未细看
				invokeBeanFactoryPostProcessors(beanFactory);

				// 按PriorityOrdered >Ordered>none按PriorityOrdered >Ordered>none
				// 注册 bean processors
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

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

				// Initialize event multicaster for this context.
				// 在上下文初始化多播器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

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

				// Instantiate all remaining (non-lazy-init) singletons.
				// 实例化bean  单例的
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

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

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

refresh这个方法里面涉及的类和方法多而杂，如果突然一下子去看的话特别容易被劝退，所以我们一次性不讲很多，大家可以跟我一起慢慢学。先来个简单的提提神

prepareRefresh()

protected void prepareRefresh() {
		// Switch to active.
		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...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

其实看这个类名就能知道意思，刷新前的准备，那这个类就是做一些准备工作，准备上下文刷新，设置启动时间，和存活标志，加载资源

obtainFreshBeanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();
	}

refreshBeanFactory

	@Override
	protected final void refreshBeanFactory() throws IllegalStateException {
		// 查看context上下问是否刷新中
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		// 设置一个序列id
		this.beanFactory.setSerializationId(getId());
	}

这个方法也很简单，就是看看context 是否在创建，然后给beanFactory设置一个唯一id

prepareBeanFactory(beanFactory)

好了 兄弟们，第一个大家伙来了，这个方法要做的工作有很多，具体的一些我写在代码注释里

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		// 告诉内部bean factory 使用上下文的class load
		beanFactory.setBeanClassLoader(getClassLoader());
		// 设置el 表达式的解析器
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		// 忽略一些接口的自动装配EnvironmentAware,
		// EmbeddedValueResolverAware,
		// ResourceLoaderAware
		//ApplicationEventPublisherAware
		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.
		// 注册一些自动装配的类 （往这个集合中resolvableDependencies）
		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.
		// 注册初期的ApplicationListenerDetector监听器侦测器
		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.
		// 注册一些默认的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());
		}
	}

这里面涉及到beanFactory.registerSingleton方法，这个方法其实开始不打算在这里讲的，但是想了想还是在这讲，先给大家留个印象。

registerSingleton(String beanName, Object singletonObject)

	@Override
	public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
		// 注册给定的singletonObject
		super.registerSingleton(beanName, singletonObject);
		// 更新manualSingletonNames
		updateManualSingletonNames(set -> set.add(beanName), set -> !this.beanDefinitionMap.containsKey(beanName));
		clearByTypeCache();
	}

updateManualSingletonNames()

private void updateManualSingletonNames(Consumer<Set<String>> action, Predicate<Set<String>> condition) {
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				if (condition.test(this.manualSingletonNames)) {
					Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
					action.accept(updatedSingletons);
					this.manualSingletonNames = updatedSingletons;
				}
			}
		}
		else {
			// Still in startup registration phase
			if (condition.test(this.manualSingletonNames)) {
				action.accept(this.manualSingletonNames);
			}
		}
	}

super.registerSingleton(beanName, singletonObject);

@Override
	public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
		Assert.notNull(beanName, "Bean name must not be null");
		Assert.notNull(singletonObject, "Singleton object must not be null");
		synchronized (this.singletonObjects) {
			Object oldObject = this.singletonObjects.get(beanName);
			if (oldObject != null) {
				throw new IllegalStateException("Could not register object [" + singletonObject +
						"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
			}
			addSingleton(beanName, singletonObject);
		}
	}

addSingleton(beanName, singletonObject);

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// singletonObjects 单例池，一级缓存
			this.singletonObjects.put(beanName, singletonObject);
			// singletonObjects 单例工厂，三级级缓存
			this.singletonFactories.remove(beanName);
			// singletonObjects 早期单例池，二级级缓存
			this.earlySingletonObjects.remove(beanName);
			// 已经注册的单例
			this.registeredSingletons.add(beanName);
		}
	}

prepareBeanFactory的方法主要是做了以下内容：
取消一些类的自动装配
更新了一些类的自动装配
注册一些默认environment bean
postProcessBeanFactory(beanFactory)是一个扩展接口，spring内部并没有对他实现，所以就没啥好讲的
invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory)这个方法内容太多了。我打算拿出单独的一章节来讲。可能有的小伙伴看到我写的东西杂，而且贴的代码很多，不大愿意看了。我还是劝下大家 耐心看看，学习源码就是这样，只要了解了refresh这个方法，spring中很多东西就很容易看明白了，后面去讲spring的架构也更容易理解。
最后谢谢大家的观看，点点赞，我会给大家带来更多的源码解析。