日期：2019-03-22
（一）refresh主流程
/**
* @see AbstractApplicationContext#refresh()
*/
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//准备此上下文以进行刷新
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
//这里是在子类中启动refreshBeanFactort()的地方
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 准备bean工厂以在此上下文中使用。
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 允许在上下文子类中对bean工厂进行后处理。
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
//调用beanFactory的后处理器，这些后处理器是在bean定义中向容器注册的
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 注册bean的后处理器，在bean创建过程中调用
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
//对上下文中的消息源进行初始化
initMessageSource();
// Initialize event multicaster for this context.
//初始化上下文中的事件机制
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
//初始化其他的特殊bean
onRefresh();
// Check for listener beans and register them.
//检查监听bean并且将这些bean向容器注册
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//实例化所有的(non-lazy-init)单利
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
//发布容器事件，结束refresh过程
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...
/**
* 重置Spring核心中的常见内省缓存，
* 从此我们开始可能再也不需要单例bean的元数据
*/
resetCommonCaches();
}
}
}
（二）refresh分步解析
1）prepareRefresh()
准备此上下文以进行刷新，设置其启动日期和活动标志以及执行属性源的任何初始化。
/**
* Prepare this context for refreshing, setting its startup date and
* active flag as well as performing any initialization of property sources.
* 准备此上下文以进行刷新，设置其启动日期和活动标志以及执行属性源的任何初始化。
*/
protected void prepareRefresh() {
//启动时间
this.startupDate = System.currentTimeMillis();
//关闭与激活状态
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// Initialize any placeholder property sources in the context environment
// 在上下文环境中初始化任何占位符属性源
//用户可以自定义，继承 对应的ApplicationContext,重写initPropertySources()方法
initPropertySources();
// Validate that all properties marked as required are resolvable
// see ConfigurablePropertyResolver#setRequiredProperties
// 验证标记为必需的所有属性是否可解析
//如果设置的property为空，则会报错
getEnvironment().validateRequiredProperties();
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
// 允许收集早期的ApplicationEvents，
// 一旦多功能车可用就会发布......
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
initPropertySources()：
初始化配置文件，默认不做任何操作。有些AbstractApplicationContext的子类，做了一些初始化的操作。比如：AbstractRefreshableWebApplicationContext#initPropertySources()
protected void initPropertySources() {
// For subclasses: do nothing by default.
// 对于子类：默认情况下不执行任何操作。
}
// AbstractRefreshableWebApplicationContext#initPropertySources()
protected void initPropertySources() {
ConfigurableEnvironment env = getEnvironment();
if (env instanceof ConfigurableWebEnvironment) {
((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, this.servletConfig);
}
}
//((ConfigurableWebEnvironment) env).initPropertySources会调用到WebApplicationContextUtils#initServletPropertySources，主要是替换了property中的servletContextInitParams参数和servletConfigInitParams参数。
public static void initServletPropertySources(
MutablePropertySources propertySources, ServletContext servletContext, ServletConfig servletConfig) {
Assert.notNull(propertySources, "'propertySources' must not be null");
if (servletContext != null && propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME) &&
propertySources.get(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME) instanceof StubPropertySource) {
propertySources.replace(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME,
new ServletContextPropertySource(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME, servletContext));
}
if (servletConfig != null && propertySources.contains(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME) &&
propertySources.get(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME) instanceof StubPropertySource) {
propertySources.replace(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME,
new ServletConfigPropertySource(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME, servletConfig));
}
}
getEnvironment().validateRequiredProperties()：
验证标记为必需的所有属性是否可解析，如果设置的property为空，则会报错；最后调用到org.springframework.core.env.AbstractPropertyResolver#validateRequiredProperties();
主要是一个非空检验。相当于，StringUtils.isEmpty()的操作。
@Override
public void validateRequiredProperties() {
MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
for (String key : this.requiredProperties) {
if (this.getProperty(key) == null) {
ex.addMissingRequiredProperty(key);
}
}
if (!ex.getMissingRequiredProperties().isEmpty()) {
throw ex;
}
}
2）obtainFreshBeanFactory()
准备此上下文以进行刷新，设置其启动日期和活动标志以及执行属性源的任何初始化。
/**
* Tell the subclass to refresh the internal bean factory.
* 告诉子类刷新内部bean工厂。
* @return the fresh BeanFactory instance
* @see #refreshBeanFactory()
* @see #getBeanFactory()
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//此实现执行此上下文的基础bean工厂的实际刷新，关闭先前的bean工厂（如果有），并初始化上一个生命周期的下一阶段的新bean工厂。
refreshBeanFactory();
//获取刷新后的 beanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
BeanFactory 是spring中最常见的接口之一，很多容器都继承了 这个接口，容易让初学者混淆。但是记住，BeanFactory只是一个规范，这个规范主要规定了获取 bean的口。ApplicationContext也继承了这个接口，不是有时候，并不是为了能够作为一个bean工厂，产生bean，而是方便获取到bean而已。很多继承这个接口的类，并没有具体实现它，而是将实现逻辑交给了org.springframework.beans.factory.support.DefaultListableBeanFactory这样的真正的工厂类。再比如：dubbo中的ReferenceBean，也实现了BeanFatory接口，是为了给调用方提供接口实例。
refreshBeanFactory()：
刷新工厂实例。为什么不直接返回，beanfactory实例，而是在使用getBeanFactory()方法去获取。高度封装，让属性的set和get只有一个入口，使得调用方都保持统一，维护和改变都很容易，是值得借鉴的。
/**
* This implementation performs an actual refresh of this context's underlying
* bean factory, shutting down the previous bean factory (if any) and
* initializing a fresh bean factory for the next phase of the context's lifecycle.
* 此实现执行此上下文的基础bean工厂的实际刷新，关闭先前的bean工厂（如果有），并初始化上一个生命周期的下一阶段的新bean工厂。
*/
@Override
protected final void refreshBeanFactory() throws BeansException {
// 这里判断是否已经建立了beanFactory，如果存在就销毁并关闭
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 默认使用DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
//设置ID标识
beanFactory.setSerializationId(getId());
//定制bean factory，设置创建beanFactory的许可条件，准入门槛
customizeBeanFactory(beanFactory);
//org.springframework.context.support.AbstractXmlApplicationContext
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
//创建beanFactory，使用的是DefaultListableBeanFactory
protected DefaultListableBeanFactory createBeanFactory() {
/**
*getInternalParentBeanFactory（），parent对象是在创建ApplicationContext对象时，传入的
* @see ClassPathXmlApplicationContext#ClassPathXmlApplicationContext(String[], ApplicationContext)
* 第二个参数，就是parent对象
*/
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
//定制beanFactory
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
//是否允许使用相同名称重新注册不同的定义，默认为true
if (this.allowBeanDefinitionOverriding != null) {
beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
// 是否允许循环引用,默认为true
if (this.allowCircularReferences != null) {
beanFactory.setAllowCircularReferences(this.allowCircularReferences);
}
}
关于循环引用，在单例中是默认是可以进行循环引用的，而在多例中，循环引用是会报错的。
-
loadBeanDefinitions(beanFactory):
解析xml文件，将解析出来的beanDefinition注册到 DefaultListableBeanFactory.beanDefinitionMap中。
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
// beanFactory的xml文件读取包装类
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
initBeanDefinitionReader(beanDefinitionReader);
//重点方法：调用此方法解析xml，获取beanDefinitionHolder
loadBeanDefinitions(beanDefinitionReader);
}
网友评论