Spring源码-refresh方法

Spring容器中最核心的方法就是refresh方法，这个方法涵盖了Spring初始化所需要的一切。

现在，我们就一起探究下这个refresh方法的内部原理吧。

refresh的基础实现是在核心类AbstractApplicionContext中，代码和简单解释如下：

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			//准备资源，验证必需的属性
			prepareRefresh();

			// 创建一个ConfigurableListableBeanFactory作为基本的IOC容器，下面的操作都基于这个beanFactory进行的
            // 这里beanFactory已经把xml中定义的BeanDefinition加载入IOC容器中了。
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			//设置beanFactory的基本属性
			prepareBeanFactory(beanFactory);

			try {
				// 通知子类来配置beanFactory，这里是空实现，不深入分析了
				postProcessBeanFactory(beanFactory);

				//调用所有的BeanFactoryPostProcessor
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册BeanPostProcessor
				registerBeanPostProcessors(beanFactory);

				// 初始化MessageSoruce
				initMessageSource();

				// 初始化 事件分发器
				initApplicationEventMulticaster();

				// 通知子类刷新容器
				onRefresh();

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

				// 初始化单例对象
				finishBeanFactoryInitialization(beanFactory);

				// 收尾
				finishRefresh();
			}
            //出现异常
            catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// 销毁bean
				destroyBeans();

				// 重置 'active' 标志.
				cancelRefresh(ex);

				throw ex;
			}
		}
	}

前两个方法已经在《BeanDefinition资源定位》、《BeanDefinition'资源加载》和《BeanDefinition注册上下篇》的文章中提及了，所以此处不再赘述，我直接从第三个方法开始分析。

prepareBeanFactory(beanFactory);

这个方法用于配置beanFactory的基础属性，比如ClassLoader和一些PostProcessor等。

这个方法主要是给BeanFactory设置一些基本的属性，比如类加载器、表达式解析器、属性编辑器，注册几个单例、添加一些不用注入的接口、添加解析依赖项等。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
      //设置类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
       //设置bean表达式解析器，详解见下文
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
    	//资源编辑注册器
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    	//添加一个BeanPostProcessor：ApplicationContextAwareProcessor，用于向实现类ApplitionContextAware中，调用setApplicationContext方法，并将ApplicationContext作为参数。
		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);
    

		// 注册几个解析依赖项，意思是，当一个Bean需要注入对应的类时，使用下面注册的这些类
    //比如，如果@Autowire 一个BeanFactory，那么这个BeanFactory实际就是在此处注册的一个对象
    //这几项分别是：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
    	//检查是否由LoadTimeWeaver，如果有loadTimeWeaver的bean，就放入一个BeanPostProcessor：LoadTimeWeaverAwareProcessor
		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，注册成单例
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
    	 //注册systemProperties 成单例
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
       //注册 systemEnvironment 成单例
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

StandardBeanExpressionResolver

BeanFactory本身没有表达式解析的能力，所以在ApplicationContext中配置了一个表达式解析器，使得IOC容器具备了spEL解析的能力。

而这个解析者的真身就是StandardBeanExpressionResolver。

首先看下继承关系

StandardBeanExpressionResolver实现了BeanExpressionResolver接口，而BeaExpressionResolver只有一个方法就是evaluate方法，这个方法也是我们解析的入口；

//参数：
//value 表达式
//BeanExpressionContext 表达式上下文（包含了beanFactory和Scope）
public Object evaluate(String value, BeanExpressionContext evalContext) throws BeansException {
    if (!StringUtils.hasLength(value)) {
        return value;
    }
    
    try {
        //查看表达式缓存
        //为了提高效率，所以Spring把解析过的value和解析后的Expression都放置到了一个Map中
        Expression expr = this.expressionCache.get(value);
        //如果没有解析过，就进行解析
        if (expr == null) {
            //解析表达式，并添加到缓存中
            //使用内部配置的expressionParser来解析表达式，这个expressionParser是一个SpelExpressionParser
            expr = this.expressionParser.parseExpression(value, this.beanExpressionParserContext);
            this.expressionCache.put(value, expr);
        }
        //缓存表达式上下文
        StandardEvaluationContext sec = this.evaluationCache.get(evalContext);
        if (sec == null) {
            sec = new StandardEvaluationContext();
            sec.setRootObject(evalContext);
            sec.addPropertyAccessor(new BeanExpressionContextAccessor());
            sec.addPropertyAccessor(new BeanFactoryAccessor());
            sec.addPropertyAccessor(new MapAccessor());
            sec.addPropertyAccessor(new EnvironmentAccessor());
            sec.setBeanResolver(new BeanFactoryResolver(evalContext.getBeanFactory()));
            sec.setTypeLocator(new StandardTypeLocator(evalContext.getBeanFactory().getBeanClassLoader()));
            ConversionService conversionService = evalContext.getBeanFactory().getConversionService();
            if (conversionService != null) {
                sec.setTypeConverter(new StandardTypeConverter(conversionService));
            }
            customizeEvaluationContext(sec);
            this.evaluationCache.put(evalContext, sec);
        }
        //获取表达式中的值
        return expr.getValue(sec);
    }
    catch (Exception ex) {
        throw new BeanExpressionException("Expression parsing failed", ex);
    }
}

Spring中表达式有3种实现：

LiteralExpression 存储一个简单String

SpelExpression spEL表达式

CompositeStringExpression 复合表达式，内部由多个表达式组成

ResourceEditorRegistrar

这个ResourceEditorRegistrar用于设置的PropertyEditorRegistry的一些默认值，核心方法是：registerCustomEditors

//把Resource、ContextResource、InputStream、InputSource、FileURL注册成这里的baseEditor
//把URI、Class、Class[]注册成这里的classLoader
//如果可以还有Resource[]
public void registerCustomEditors(PropertyEditorRegistry registry) {
    ResourceEditor baseEditor = new ResourceEditor(this.resourceLoader, this.propertyResolver);
    doRegisterEditor(registry, Resource.class, baseEditor);
    doRegisterEditor(registry, ContextResource.class, baseEditor);
    doRegisterEditor(registry, InputStream.class, new InputStreamEditor(baseEditor));
    doRegisterEditor(registry, InputSource.class, new InputSourceEditor(baseEditor));
    doRegisterEditor(registry, File.class, new FileEditor(baseEditor));
    doRegisterEditor(registry, URL.class, new URLEditor(baseEditor));

    ClassLoader classLoader = this.resourceLoader.getClassLoader();
    doRegisterEditor(registry, URI.class, new URIEditor(classLoader));
    doRegisterEditor(registry, Class.class, new ClassEditor(classLoader));
    doRegisterEditor(registry, Class[].class, new ClassArrayEditor(classLoader));

    if (this.resourceLoader instanceof ResourcePatternResolver) {
        doRegisterEditor(registry, Resource[].class,
                         new ResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader, this.propertyResolver));
    }
}

ApplicationContextAwareProcessor

这个类实现了BeanPostProcessor接口，BeanPostProcessor接口用于在bean实例化前和后调用相应的方法来实现一些特殊的功能。
//BeanPostProcessor接口
//实例化之前调用
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
//实例化之后调用
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

ApplicationContextAwareProcessor构造函数，可以看出这里构造时把上级传入的applicationContext保存起来，方便下面注入。

public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
    this.applicationContext = applicationContext;
}

postProcessBeforeInitialization

//重写方法
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
    AccessControlContext acc = null;
	//安全检查和bean实现的接口检查
    if (System.getSecurityManager() != null &&
        (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
         bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
         bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
        acc = this.applicationContext.getBeanFactory().getAccessControlContext();
    }
	//访问控制，不论怎么，最终调用的方法都是invokeAwareInterfaces
    if (acc != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            public Object run() {
                invokeAwareInterfaces(bean);
                return null;
            }
        }, acc);
    }
    else {
        invokeAwareInterfaces(bean);
    }

    return bean;
}
//可以看到ApplicationContextAwareProcessor可以注入的接口类型非常多
//可以注入实现以下接口的类
//1.EnvironmentAware
//2.EmbeddedValueResolverAware
//3.ResourceLoaderAware
//4.ApplicationEventPublisherAware
//5.MessageSourceAware
//6.ApplicationContextAware

private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
        }
        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
                new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
        }
        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
        }
        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
        }
        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
        }
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }
}

invokeBeanFactoryPostProcessors

调用所有的已注册的BeanFactoryPostProcessor。

那BeanFactoryPostProcessor是什么呢？BeanFactoryPostProcessor是一个接口里面只有一个方法,用于配置BeanFactory。
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
这个方法的调用时机就在此invokeBeanFactoryPostProcessors内，同时这个BeanFactoryPostProcessor还有一个子接口

BeanDefinitionRegistryPostProcessor，继承图：

Spring调用的基本逻辑是：

调用内部配置的 BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法

调用IOC中的 BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法

调用内部配置的 BeanDefinitionRegistryPostProcessor中的postProcessBeanFactory方法

调用 IOC中的BeanDefinitionRegistryPostProcessor 中的postProcessBeanFactory方法

调用内部配置的BeanFactoryPostProcessor 中的postProcessBeanFactory方法

调用IOC中的实现PriorityOrdered的BeanFactoryPostProcessor 的postProcessBeanFactory方法

调用IOC中的实现Ordered的BeanFactoryPostProcessor 的postProcessBeanFactory方法

调用IOC中的普通的BeanFactoryPostProcessor 的postProcessBeanFactory方法

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    
    //用于存放已处理过的Bean
    Set<String> processedBeans = new HashSet<String>();
    
    //如果IOC容器是一个BeanDefinitionRegistry，有了注册BeanDefinition的能力，就可以执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
    if (beanFactory instanceof BeanDefinitionRegistry) {
        
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        
        //regularPostProcessors用于存放普通的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> 
            regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
        
        //registryPostProcessors用于存放 BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> 
            registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
        
        //查询通过addBeanFactoryPostProcessor等方法设置进来的的BeanFactoryPostProcessor（不是注册到IOC容器的中）
        for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
            
            //如果是 BeanDefinitionRegistryPostProcessor  ，
            //就先执行它的postProcessBeanDefinitionRegistry，用于向IOC中注册一些BeanDefinition，
            //然后添加到registryPostProcessors队列中
          if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryPostProcessor =
                    (BeanDefinitionRegistryPostProcessor) postProcessor;
				  
            	registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                registryPostProcessors.add(registryPostProcessor);
            }
            else {
                //如果是普通的BeanFactoryPostProcessor，就添加到regularPostProcessors队列中
                regularPostProcessors.add(postProcessor);
            }
        }
        
        //获取IOC容器中注册的BeanDefinitionRegistryPostProcessor，
        //放入到registryPostProcessorBeans中，
        //并按照Order排序
        Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
            beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
        
        List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =
            new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());
       
        OrderComparator.sort(registryPostProcessorBeans);
        
        //先调用registryPostProcessorBeans中的所有postProcessBeanDefinitionRegistry方法
        for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
        //先调用 registryPostProcessors中的postProcessBeanFactory方法
        //再调用 registryPostProcessorBeans中的postProcessBeanFactory方法
        //最后调用 regularPostProcessors中的postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        
        //对于IOC容器中注册的BeanDefinitionRegistryPostProcessor来说，还要放置到processedBeans中，放置重复调用
        processedBeans.addAll(beanMap.keySet());
    }
    else {
        //如果IOC就是一个普通的BeanFacotry，就直接从context中取出所有的BeanFactoryPostProcessor，并调用他们的postProcessBeanFactory方法
        // Invoke factory processors registered with the context instance.
        invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
    }
	
    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // 查询IOC容器中所有的BeanFactoryPostProcessor，有可能上面的BeanDefinitionRegistryPostProcessor刚刚向IOC容器中注册了一些BeanFactoryPostProcessor，所以要在此处全部查出来。
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 按照 这些BeanFactoryPostProcessor实现的排序接口（ PriorityOrdered 和 Ordered）分成3组
    //第一组 实现了PriorityOrdered  --- priorityOrderedPostProcessors
    //第二组 实现了Ordered          --- orderedPostProcessorNames
    //第三组 没有实现排序接口         --- nonOrderedPostProcessorNames
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    
    for (String ppName : postProcessorNames) {
        //如果已经处理了，就跳过
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
         //实现PriorityOrdered 接口的
        else if (isTypeMatch(ppName, PriorityOrdered.class)) {
           
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        // 实现Ordered 接口的
        else if (isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        //普通的
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
      //然后先执行priorityOrderedPostProcessors中的，再执行orderedPostProcessorNames的，最后执行nonOrderedPostProcessorNames
	
    //排序并执行priorityOrderedPostProcessors的
    OrderComparator.sort(priorityOrderedPostProcessors);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 排序并执行orderedPostProcessors的
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    OrderComparator.sort(orderedPostProcessors);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 最后执行普通的BeanFactoryPostProcessor的
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}

registerBeanPostProcessors

BeanPostProcessor是一个非常重要的接口，这个BeanPostProcessor在所有Bean初始化前或初始化后被调用。Spring的很多特性都是通过这个接口实现的。

接口如下：
public interface BeanPostProcessor {
	//Bean初始化前调用
	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
   //Bean初始化后调用
	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
``

注册逻辑分析

注册BeanPostProcessor，并且按照实现PriorityOrdered、Ordered分成3种。

然后按照PriorityOrdered>Ordered>普通的顺序注册到IOC容器种。但是要注意到一个特殊的internalPostProcessors，这个用来放置实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor。

同时这个方法会在所有的BeanPostProcessor注册前注册一个BeanPostProcessorChecker，在所有的BeanPostProcessor注册后注册一个ApplicationListenerDetector。

此方法的注册逻辑如下：

注册一个BeanPostProcessorChecker

注册实现PriorityOrdered的BeanPostProcessor

注册实现Ordered的BeanPostProcessor

注册普通的BeanPostProcessor

注册实现了PriorityOrdered和MergedBeanDefinitionPostProcessor的BeanPostProcessor

注册实现了Ordered和MergedBeanDefinitionPostProcessor的BeanPostProcessor

注册实现了MergedBeanDefinitionPostProcessor的BeanPostProcessor

注册一个ApplicationListenerDetector

一个注意点：

在方法prepareBeanFactory中，注册了一个ApplicationContextAwareProcessor，所以这个ApplicationContextAwareProcessor是第一个BeanPostProcessor，下面代码中注册的BeanPostProcessor都在它的后面。

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 获取IOC中注册的 BeanPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // BeanPostProcessorChecker 也是一个 BeanPostProcessor，用于检查一个Bean应该经过的BeanPostProcessor和
    
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    //按照排序接口分类。
    //这里需要注意的是，priorityOrderedPostProcessors里面装的是BeanPostProcessor
    //而orderedPostProcessorNames和nonOrderedPostProcessorNames里面装的是BeanPostProcessor的name
    //原因是：实例化BeanPostProcessor实现类的时候，也需要调用IOC中已有的BeanPostProcessor，所以Spring这里没有提前实例化Orderd接口和普通的BeanPostProcessor。
    //因此，这里有一个有趣的现象，示例化Orderd接口的BeanProcessor的时候，会使用PriorityOrdered的BeanPostProcessor进行处理
    //实例化普通的BeanProcessor时，会先后经过PriorityOrdered和Orderd接口的BeanPostProcessor的处理
    
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
    
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    
    //分类
    for (String ppName : postProcessorNames) {
        //PriorityOrdered接口的，先行实例化，并把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中
        if (isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            //
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        //Ordered接口的，这里只是把name记录下来。
        else if (isTypeMatch(ppName, Ordered.class)) {
            //
            orderedPostProcessorNames.add(ppName);
        }
        //普通的，这里只是把name记录下来。
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    //排序并注册PriorityOrdered接口的BeanPostProcessor
    OrderComparator.sort(priorityOrderedPostProcessors);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    //排序并注册Ordered接口的BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : orderedPostProcessorNames) {
        //这里才进行实例化，所以会使用实现了PriorityOrdered接口的BeanPostProcessor进行处理
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        //把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    OrderComparator.sort(orderedPostProcessors);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // 注册普通的BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : nonOrderedPostProcessorNames) {
       //这里才进行实例化，所以会使用实现了PriorityOrdered接口或Orderd的BeanPostProcessor进行处理
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
         //把 MergedBeanDefinitionPostProcessor 放入到internalPostProcessors中
        //同时注意到，即使在internalPostProcessors中
        //BeanPostProcessor的顺序也是按照 PriorityOrderd > Orderd > 普通 的顺序进入的。
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    //注册所有的MergedBeanDefinitionPostProcessor
    OrderComparator.sort(internalPostProcessors);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
	
    //最后，在末尾添加一个ApplicationListenerDetector
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
}

IOC容器的BeanPostProcessor注册图示：

注意点

有些同学可能会产生疑问，如果一个BeanPostProcessor是MergedBeanDefinitionPostProcessor的话，是不是在IOC中的BeanPostProcessor队列有两份呢，因为是先注册了PriorityOrdered、Ordered和普通的，最后又注册了MergedBeanDefinitionPostProcessor的。

这个问题非常好，说明同学进行了思考，Spring也想到了这一点，所以它在注册BeanPostProcessor时进行了去重，实现的代码在AbstractBeanFactory的addBeanPostProcessor中，具体如下：
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
		Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    	// 这里先删除已有的beanPostProceWssor
		this.beanPostProcessors.remove(beanPostProcessor);
       //再注册beanPostProcessor，就可以避免一个队列中有相同的元素了。
		this.beanPostProcessors.add(beanPostProcessor);
		if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
			this.hasInstantiationAwareBeanPostProcessors = true;
		}
		if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
			this.hasDestructionAwareBeanPostProcessors = true;
		}
	}

initMessageSource

初始化MessageSource

Messagesource用于处理国际化消息，关于它的详细分析，我会另写一文《MessageSource探究》。

这里只讲解它的初始化逻辑。

protected void initMessageSource() {
    //如果已经注册了 messageSource 
    //并且 messageSource是HierarchicalMessageSource
    //并且 messageSource没有parent
    //并且 此IOC有parent 
    //就设置此messagesSoure的parent，
   
    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.isDebugEnabled()) {
            logger.debug("Using MessageSource [" + this.messageSource + "]");
        }
    }
    //如果没有注册messageSource，就创建一个DelegatingMessageSource
    //并注册到IOC中
    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.isDebugEnabled()) {
            logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                         "': using default [" + this.messageSource + "]");
        }
    }
}

initApplicationEventMulticaster

初始化事件分发器

如果注册了applicationEventMulticaster，就设置成此IOC的事件分发器

如果没有注册applicationEventMulticaster，就创建并注册一个SimpleApplicationEventMulticaster

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //如果有applicationEventMulticaster，就设置成本IOC的事件分发器
    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 + "]");
        }
    }
    //如果没有applicationEventMulticaster，就设置一个SimpleApplicationEventMulticaster
    else {
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(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 + "]");
        }
    }
}

onRefresh

通知子类进行容器刷新，此处没有实现

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

registerListeners

注册监听器

注册监听器分为两部分，

向事件分发器注册硬编码设置的applicationListener

向事件分发器注册一个IOC中的事件监听器（并不实例化）

protected void registerListeners() {
    // 查出所有通过addApplicationListener方法添加的ApplicationListener
    // 然后注册到事件分发器上
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 查出ioc容器中的所有ApplicationListener，只把他们注册到事件分发器的ApplicationListenerBean上，
    // 待使用时再进行实例化
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
}

finishBeanFactoryInitialization

收尾工作

注册和实例化一些单例

清理临时classLoader

给beanDefinitionName做快照

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    
    //如果IOC中有conversionService的话，就实例化并设置到IOC中
    //conversionService用于类型转换
    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));
    }

    // 如果有LoadTimeWeaverAware，就实例化
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // 清理临时的classLoader
    beanFactory.setTempClassLoader(null);

    // 缓存所有beanDefinition的name，以备不时之需
    beanFactory.freezeConfiguration();

    // 实例化所有非non-lazy-init的单例
    beanFactory.preInstantiateSingletons();
}

finishRefresh

完成刷新

调用LifecycleProcessor的onRefresh()方法

发布ContextRefreshedEvent方法

protected void finishRefresh() {
    // 实例化或初始化lifecycleProcessor
    initLifecycleProcessor();

    // 调用lifecycleProcessor的刷新方法
    getLifecycleProcessor().onRefresh();

    //发布一个ContextRefreshedEvent事件
    publishEvent(new ContextRefreshedEvent(this));

    // 注册MBean，用于JMX管理
    LiveBeansView.registerApplicationContext(this);
}

initLifecycleProcessor

初始化 LifecycleProcessor

如果有就设置成IOC的LifecycleProcessor，如果没有，就创建并注册一个新的DefaultLifecycleProcessor

protected void initLifecycleProcessor() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //如果有lifecycleProcessor，就实例化并设置到IOC中
    if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
        this.lifecycleProcessor =
            beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
        }
    }
    else {
        //创建一个新的DefaultLifecycleProcessor，并设置
        DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
        defaultProcessor.setBeanFactory(beanFactory);
        this.lifecycleProcessor = defaultProcessor;
        beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate LifecycleProcessor with name '" +
                         LIFECYCLE_PROCESSOR_BEAN_NAME +
                         "': using default [" + this.lifecycleProcessor + "]");
        }
    }
}

DefaultLifecycleProcessor.onRefresh

生命周期处理器的刷新方法

实例化IOC中的Lifecycle

按照phase分成不同的组

按照phase从小到大的顺序一起调用组成Lifecycle的start方法

public void onRefresh() {
    //
    startBeans(true);
    //设置状态
    this.running = true;
}
private void startBeans(boolean autoStartupOnly) {
    //获取IOC中的所有的LiftCycle实例，注意这里会把lifecycleProcessor这个单例排除掉
    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
    
    //LifeCycle分组，按照阶段分组
    Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
    
    for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
        Lifecycle bean = entry.getValue();
        //如果autoStartupOnly为false（DefaultLifeProcessor默认是true） 
        //或者 bean是一个SmartLifecycle同时支持AutoStartup
        if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
            //获取lifeCycle的phase，默认为0
            int phase = getPhase(bean);
            
            //放入到相应的LifeCycleGroup中（没有就先创建一个分组）
            LifecycleGroup group = phases.get(phase);
            if (group == null) {
                group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                phases.put(phase, group);
            }
            //放入到分组中
            group.add(entry.getKey(), bean);
        }
    }
    //如果phase有lifeCycleGroup，就调用面lifeCycle的start方法
    if (phases.size() > 0) {
        List<Integer> keys = new ArrayList<Integer>(phases.keySet());
        //按照phase排序
        Collections.sort(keys);
        for (Integer key : keys) {
            //依次调用LifeCycleGroup的start方法
            //然后LifeCycleGroup调用组内的LifeCycle的start方法
            phases.get(key).start();
        }
    }
}

总结

至此，refresh方法就已经分析完毕了。

但是其中有些许的地方，讲解的不透彻或者不清楚的，我会另外写一些番外篇单独解析，比如文中提到的《MessageSource探究》。

除此之外，还有一些内容比如事件分发与处理、JMX管理等没有细致解析的地方，我都会进行详尽的解析。

谢谢大家的观阅，有问题请留言。