【spring源码】spring IOC容器底层源码分析

注：其他一些spring源码解读，如果有需要，可以参考：

• 【Spring源码】 后置处理器BeanPostProcessor底层原理分析
• 【spring源码】spring声明式事务底层源码分析
• 【spring源码】ApplicationListener事件监听底层原理
• 【spring源码】AOP底层源码分析

1.入口

• 看源码也得找个入口
• Demo:

    @Test
    public void test01(){
        //创建IOC容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig2.class);

        String[] definitionNames = applicationContext.getBeanDefinitionNames();
        for (String name : definitionNames) {
            System.out.println(name);
        }
    }

• 这是随便找的一个测试类，我们的入口就是该方法的第一行代码：new AnnotationConfigApplicationContext(MyConfig2.class);
• MyConfig2.class是配置类，不用管，我们点进AnnotationConfigApplicationContext的构造方法看看：

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
        this();
        //解析配置类,注册bean
        this.register(annotatedClasses);
        //spring的核心，在这个方法里，Spring完成了容器的初始化
        this.refresh();
    }

• register(annotatedClasses)解析配置类的，创建IOC容器的方法有多种，这里是用注解配置的方式，也就是 AnnotationConfigApplicationContext的方式来创建，除了这种还有其他方式，比如传统的xml方式：ClassPathXmlApplicationContext，大家应该不陌生，他们都有个共同的特点，先解析配置文件，先把你在配置文件中配置的bean注册起来（类信息，方法信息，依赖信息，是否单例等等。。只注册，不实例化和初始化）
• 这一步我们不细说，我们今天聊下面那个方法.refresh()

2.spring IOC核心refresh（）方法源码分析

• 熟悉Spring源码的对refresh（）这个方法应该不会陌生,spring的核心,我们点进去：

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            //容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等
            this.prepareRefresh();
            //获取新的beanFactory，销毁原有beanFactory、为每个bean生成BeanDefinition等
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
               //配置标准的beanFactory，设置ClassLoader，设置SpEL表达式解析器，添加忽略注入的接口，添加bean，添加bean后置处理器等
                this.postProcessBeanFactory(beanFactory);
                //模板方法，此时，所有的beanDefinition已经加载，但是还没有实例化。
                //允许在子类中对beanFactory进行扩展处理。比如添加ware相关接口自动装配设置，添加后置处理器等，是子类扩展 
                //prepareBeanFactory(beanFactory)的方法。
                // 实例化并调用所有注册的beanFactory后置处理器（实现接口BeanFactoryPostProcessor的bean，在beanFactory标准初始化之后执行）。
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //实例化和注册beanFactory中扩展了BeanPostProcessor的bean。
                this.registerBeanPostProcessors(beanFactory);
                //初始化国际化工具类MessageSource
                this.initMessageSource();
                //初始化事件广播器
                this.initApplicationEventMulticaster();
                //模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。
                this.onRefresh();
                //注册监听器，广播early application events
                this.registerListeners();
                //实例化所有剩余的（非懒加载）单例
                //实例化的过程各种BeanPostProcessor开始起作用。
                this.finishBeanFactoryInitialization(beanFactory);
                //refresh做完之后需要做的其他事情。
                //清除上下文资源缓存（如扫描中的ASM元数据）
                //初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）。
                //发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

• 注释已经很详细了，接下来我们一个方法一个方法聊：

2.1 prepareRefresh()刷新前的预处理

protected void prepareRefresh() {
        //记录时间
		this.startupDate = System.currentTimeMillis();
		//容器状态，是否关闭：false
		this.closed.set(false);
		//是否激活：true
		this.active.set(true);

        //打印刷新日志
		if (logger.isInfoEnabled()) {
			logger.info("Refreshing " + this);
		}

		//初始化一些属性设置;默认是个空的方法，等待子类自定义个性化的属性设置方法；
		initPropertySources();
		//检验属性的合法等
		getEnvironment().validateRequiredProperties();
		//保存容器中的一些早期的事件；
		this.earlyApplicationEvents = new LinkedHashSet();
	}

 protected void initPropertySources() {
		// 这个方法是个空的，等待子类重写
	}

• 首先，设置容器状态
• 然后，initPropertySources();这是个空的方法，等待子类自定义个性化的属性设置方法；
• 再然后validateRequiredProperties();检验属性的合法等
• 最后new LinkedHashSet();创建一个放置早期监听事件的的容器，等待之后派发器创建好之后方便派发（派发器的创建在后面的其他方法内）

2.2 obtainFreshBeanFactory();获取BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //刷新【创建】BeanFactory；
		refreshBeanFactory();
		//返回刚才GenericApplicationContext创建的BeanFactory对象；
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		//将创建的BeanFactory【DefaultListableBeanFactory】返回
		return beanFactory;
	}

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {

      private final DefaultListableBeanFactory beanFactory;
      public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	 }
	 
	 @Override
 	protected final void refreshBeanFactory() throws IllegalStateException {
 	    //CAS
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		this.beanFactory.setSerializationId(getId());
  	}
  	@Override
	public final ConfigurableListableBeanFactory getBeanFactory() {
		return this.beanFactory;
	}
// 省略了很多其他源码。。。

}

• refreshBeanFactory();刷新BeanFactory，其实是到GenericApplicationContext 无参构造里new DefaultListableBeanFactory();，然后设置了一个序列化Id
• getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；
• 最后将创建的BeanFactory【DefaultListableBeanFactory】返回；

2.3 prepareBeanFactory(beanFactory);BeanFactory的预准备工作

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置BeanFactory的类加载器、支持表达式解析器...
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		//添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

        //设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
		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、ResourceLoader、ApplicationEventPublisher、ApplicationContext
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		//添加BeanPostProcessor【ApplicationListenerDetector】
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 添加编译时的AspectJ；
		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()));
		}

		// 给BeanFactory中注册一些能用的组件；
		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,这个方法对BeanFactory进行一些设置
• 首先设置BeanFactory的类加载器、支持表达式解析器…
• 然后添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
• 然后设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
• 再然后注册可以解析的自动装配；我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
• 再再然后添加BeanPostProcessor【ApplicationListenerDetector】
• 然后添加编译时的AspectJ；
• 最后给BeanFactory中注册一些能用的组件；environment【ConfigurableEnvironment】、systemProperties【Map】、systemEnvironment【Map】

2.4 postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

• 子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置.
• 到这里为止，以上是BeanFactory的创建及预准备工作

2.5 invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set processedBeans = new HashSet();

      //是否是BeanDefinitionRegistry类型
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List regularPostProcessors = new LinkedList();
			List registryProcessors = new LinkedList();

           //遍历
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			   /是否是BeanDefinitionRegistryPostProcessor类型
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

            //获取所有的BeanDefinitionRegistryPostProcessor
			List currentRegistryProcessors = new ArrayList();

			// 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			//在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			//最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// 获取所有的BeanFactoryPostProcessor
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// 区分出那些实现了PriorityOrdered，那些实现了Ordered
		List priorityOrderedPostProcessors = new ArrayList();
		List orderedPostProcessorNames = new ArrayList();
		List nonOrderedPostProcessorNames = new ArrayList();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
		List orderedPostProcessors = new ArrayList();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		//最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor
		List nonOrderedPostProcessors = new ArrayList();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}

• BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的
• 它有两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
• 方法执行的时候
• 先执行实现了BeanDefinitionRegistryPostProcessor的bean,具体步骤:

1,获取所有的BeanDefinitionRegistryPostProcessor；

2,先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、

3,在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；

4,最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；

• 再执行实现了BeanFactoryPostProcessor的bean,具体步骤:

1,获取所有的BeanFactoryPostProcessor；

2,先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、

3,在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；

4,最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；

2.6 registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（Bean的后置处理器）

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

        //获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// 统计了一些数量，然后注册了一个自己的BeanPostProcessorChecker用于检查
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		//  区分出那些实现了PriorityOrdered，那些实现了Ordered
		List priorityOrderedPostProcessors = new ArrayList();
		List internalPostProcessors = new ArrayList();
		List orderedPostProcessorNames = new ArrayList();
		List nonOrderedPostProcessorNames = new ArrayList();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 先注册PriorityOrdered优先级接口的BeanPostProcessor；
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		//把每一个BeanPostProcessor；添加到BeanFactory中
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 再注册Ordered接口的
		List orderedPostProcessors = new ArrayList();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 最后注册没有实现任何优先级接口的
		List nonOrderedPostProcessors = new ArrayList();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 最终注册MergedBeanDefinitionPostProcessor；
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// 注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是
		//	applicationContext.addApplicationListener((ApplicationListener) bean);
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

• 上面注释比较清楚了，我们简单聊一下BeanPostProcessor（Bean的后置处理器）
• spring 中有很多BeanPostProcessor，简单列举一些：
• BeanPostProcessor、DestructionAwareBeanPostProcessor、InstantiationAwareBeanPostProcessorSmartInstantiationAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor
• 不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的，在下面用到的时候我们会聊。
• 对于BeanPostProcessor,如果还想了解更多，可见：
• 【Spring源码】 后置处理器BeanPostProcessor底层原理分析

2.7 initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）

protected void initMessageSource() {
       //获取BeanFactory
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		//看容器中是否有id为messageSource的，类型是MessageSource的组件
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
		    //如果有赋值给messageSource
			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.isDebugEnabled()) {
				logger.debug("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			// 如果没有自己创建一个DelegatingMessageSource；
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			//把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
						"': using default [" + this.messageSource + "]");
			}
		}
	}

• 先获取BeanFactory
• 然后看容器中是否有id为messageSource的，类型是MessageSource的组件
• 如果有赋值给messageSource
• 如果没有自己创建一个DelegatingMessageSource；
• 把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；

2.8 initApplicationEventMulticaster();初始化事件派发器；

protected void initApplicationEventMulticaster() {
       //获取BeanFactory
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		//从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isDebugEnabled()) {
				logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
		//如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			//将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
						APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
						"': using default [" + this.applicationEventMulticaster + "]");
			}
		}
	}

• 获取BeanFactory
• 从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
• 如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
• 将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入

2.9 onRefresh();留给子容器（子类）

protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
	}

• 子类重写这个方法，在容器刷新的时候可以自定义逻辑；

2.10 registerListeners();给容器中将所有项目里面的ApplicationListener注册进来

protected void registerListeners() {
		// 从容器中拿到所有的ApplicationListener
		for (ApplicationListener listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		//将每个监听器添加到事件派发器中；
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// 派发之前步骤产生的事件.
		Set earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

• 从容器中拿到所有的ApplicationListener
• 将每个监听器添加到事件派发器中；
• 派发之前步骤产生的事件:earlyApplicationEvents还记得它吗？忘了可以往上看2.1

2.11 finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean

• 如果说refresh()是IOC核心，那么finishBeanFactoryInitialization(beanFactory)也可以说是refresh()的核心了，这个方法我们要慢慢看：

2.11.1第一步

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		//类型转换，不用管
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		//值解析器，同样不用看
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
				@Override
				public String resolveStringValue(String strVal) {
					return getEnvironment().resolvePlaceholders(strVal);
				}
			});
		}

		// 这是跟AspectJAware有关的不用看
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// 初始化剩下的单实例bean,这一步，重点
		beanFactory.preInstantiateSingletons();
	}

• 第一步中的重点在这行beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean，我们点进去

2.11.2 第二步

public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

		// 获取容器中的所有Bean
		List beanNames = new ArrayList(this.beanDefinitionNames);

		// 依次进行初始化和创建对象
		for (String beanName : beanNames) {
		//获取Bean的定义信息；RootBeanDefinition
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//Bean不是抽象的，是单实例的，不是懒加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			   //判断是不是工厂Bean
				if (isFactoryBean(beanName)) {
					final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
							@Override
							public Boolean run() {
								return ((SmartFactoryBean) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean) factory).isEagerInit());
					}
					if (isEagerInit) {
					 //不是工厂Bean。利用getBean(beanName);创建对象，重点
						getBean(beanName);
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		// 检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged(new PrivilegedAction