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管理等没有细致解析的地方，我都会进行详尽的解析。
谢谢大家的观阅，有问题请留言。
