Java Spring的refresh方法你知道吗-eolink官网

Java Spring的refresh方法你知道吗

目录spring的refresh方法前置知识创建 Bean 容器前的准备工作创建 Bean 容器，加载并注册 Bean总结

spring的refresh方法

前置知识

方法入口

// org.springframework.context.support.AbstractApplicationContext#refresh

类的结构图

BeanDefinition 接口定义

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

// 我们可以看到，默认只提供 sington 和 prototype 两种，

// 很多读者可能知道还有 request, session, globalSession, application, websocket 这几种，

// 不过，它们属于基于 web 的扩展。

String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

// 比较不重要，直接跳过吧

int ROLE_APPLICATION = 0;

int ROLE_SUPPORT = 1;

int ROLE_INFRASTRUCTURE = 2;

// 设置父 Bean，这里涉及到 bean 继承，不是 java 继承。请参见附录的详细介绍

// 一句话就是：继承父 Bean 的配置信息而已

void setParentName(String parentName);

// 获取父 Bean

String getParentName();

// 设置 Bean 的类名称，将来是要通过反射来生成实例的

void setBeanClassName(String beanClassName);

// 获取 Bean 的类名称

String getBeanClassName();

// 设置 bean 的 scope

void setScope(String scope);

String getScope();

// 设置是否懒加载

void setLazyInit(boolean lazyInit);

boolean isLazyInit();

// 设置该 Bean 依赖的所有的 Bean，注意，这里的依赖不是指属性依赖(如 @Autowire 标记的)，

// 是 depends-on="" 属性设置的值。

void setDependsOn(String... dependsOn);

// 返回该 Bean 的所有依赖

String[] getDependsOn();

// 设置该 Bean 是否可以注入到其他 Bean 中，只对根据类型注入有效，

// 如果根据名称注入，即使这边设置了 false，也是可以的

void setAutowireCandidate(boolean autowireCandidate);

// 该 Bean 是否可以注入到其他 Bean 中

boolean isAutowireCandidate();

// 主要的。同一接口的多个实现，如果不指定名字的话，Spring 会优先选择设置 primary 为 true 的 bean

void setPrimary(boolean primary);

// 是否是 primary 的

boolean isPrimary();

// 如果该 Bean 采用工厂方法生成，指定工厂名称。对工厂不熟悉的读者，请参加附录

// 一句话就是：有些实例不是用反射生成的，而是用工厂模式生成的

void setFactoryBeanName(String factoryBeanName);

// 获取工厂名称

String getFactoryBeanName();

// 指定工厂类中的工厂方法名称

void setFactoryMethodName(String factoryMethodName);

// 获取工厂类中的工厂方法名称

String getFactoryMethodName();

// 构造器参数

ConstructorArgumentValues getConstructorArgumentValues();

// Bean 中的属性值，后面给 bean 注入属性值的时候会说到

MutablePropertyValues getPropertyValues();

// 是否 singleton

boolean isSingleton();

// 是否 prototype

boolean isPrototype();

// 如果这个 Bean 是被设置为 abstract，那么不能实例化，

// 常用于作为父bean 用于继承，其实也很少用......

boolean isAbstract();

int getRole();

String getDescription();

String getResourceDescription();

BeanDefinition getOriginatingBeanDefinition();

}

refresh 这里简单说下为什么是 refresh()，而不是 init() 这种名字的方法。因为 ApplicationContext 建立起来以后，其实我们是可以通过调用 refresh() 这个方法重建的，refresh() 会将原来的 ApplicationContext 销毁，然后再重新执行一次初始化操作。

@Override

public void refresh() throws BeansException, IllegalStateException {

// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛

synchronized (this.startupShutdownMonitor) {

// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符

prepareRefresh();

// 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，

// 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，

// 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean

// 这块待会会展开说

prepareBeanFactory(beanFactory);

try {

// 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，

// 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】

// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化

// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事

postProcessBeanFactory(beanFactory);

// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法

invokeBeanFactoryPostProcessors(beanFactory);

// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别

// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization

// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化

registerBeanPostProcessors(beanFactory);

// 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了

initMessageSource();

// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了

initApplicationEventMulticaster();

// 从方法名就可以知道，典型的模板方法(钩子方法)，

// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）

onRefresh();

// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过

registerListeners();

// 重点，重点，重点

// 初始化所有的 singleton beans

//（lazy-init 的除外）

finishBeanFactoryInitialization(beanFactory);

// 最后，广播事件，ApplicationContext 初始化完成

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.

// 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源

destroyBeans();

// Reset 'active' flag.

cancelRefresh(ex);

// 把异常往外抛

throw ex;

}

finally {

// Reset common introspection caches in Spring's core, since we

// might not ever need metadata for singleton beans anymore...

resetCommonCaches();

}

创建 Bean 容器前的准备工作

// 准备工作

protected void prepareRefresh() {

// 记录启动时间，

// 将 active 属性设置为 true，closed 属性设置为 false，它们都是 AtomicBoolean 类型

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 初始化上下文环境中的任何占位符属性源。

initPropertySources();

// 校验 xml 配置文件

getEnvironment().validateRequiredProperties();

// 初始化事件集合

this.earlyApplicationEvents = new LinkedHashSet();

}

创建 Bean 容器，加载并注册 Bean

// 最重要的方法之一，这里将会初始化 BeanFactory、加载 Bean、注册 Bean 等等。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

// 关闭旧的 BeanFactory (如果有)，创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等

refreshBeanFactory();

// 返回刚刚创建的 BeanFactory

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isDebugEnabled()) {

logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

}

return beanFactory;

}

// refreshBeanFactory

@Override

protected final void refreshBeanFactory() throws BeansException {

// 如果 ApplicationContext 中已经加载过 BeanFactory 了，销毁所有 Bean，关闭 BeanFactory

// 注意，应用中 BeanFactory 本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前

// ApplicationContext 是否有 BeanFactory

if (hasBeanFactory()) {

destroyBeans();

closeBeanFactory();

}

try {

// 初始化一个 DefaultListableBeanFactory，为什么用这个，我们马上说。

DefaultListableBeanFactory beanFactory = createBeanFactory();

// 用于 BeanFactory 的序列化，我想大部分人应该都用不到

beanFactory.setSerializationId(getId());

// 下面这两个方法很重要，别跟丢了，具体细节之后说

// 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用

customizeBeanFactory(beanFactory);

// 加载 Bean 到 BeanFactory 中

loadBeanDefinitions(beanFactory);

synchronized (this.beanFactoryMonitor) {

this.beanFactory = beanFactory;

}

catch (IOException ex) {

throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

}

// customizeBeanFactory 配置是否允许 BeanDefinition 覆盖、是否允许循环引用。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {

if (this.allowBeanDefinitionOverriding != null) {

// 是否允许 Bean 定义覆盖在配置文件中定义 bean 时使用了相同的 id 或 name，默认情况下，allowBeanDefinitionOverriding 属性为 null，如果在同一配置文件中重复了，会抛错，但是如果不是同一配置文件中，会发生覆盖。

beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

}

if (this.allowCircularReferences != null) {

// 是否允许 Bean 间的循环依赖如:A 依赖 B，而 B 依赖 A。或 A 依赖 B，B 依赖 C，而 C 依赖 A。

beanFactory.setAllowCircularReferences(this.allowCircularReferences);

}

// loadBeanDefinitions 加载bean,放入 BeanFactory 中 org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

/** 我们可以看到，此方法将通过一个 XmlBeanDefinitionReader 实例来加载各个 Bean。*/

@Override

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

// 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReader

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));

// 初始化 BeanDefinitionReader，其实这个是提供给子类覆写的，

// 我看了一下，没有类覆写这个方法，我们姑且当做不重要吧

initBeanDefinitionReader(beanDefinitionReader);

// 重点来了，继续往下

loadBeanDefinitions(beanDefinitionReader);

}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

Resource[] configResources = getConfigResources();

if (configResources != null) {

// 往下看

reader.loadBeanDefinitions(configResources);

}

String[] configLocations = getConfigLocations();

if (configLocations != null) {

// 2

reader.loadBeanDefinitions(configLocations);

}

// 上面虽然有两个分支，不过第二个分支很快通过解析路径转换为 Resource 以后也会进到这里

@Override

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {

Assert.notNull(resources, "Resource array must not be null");

int counter = 0;

// 注意这里是个 for 循环，也就是每个文件是一个 resource

for (Resource resource : resources) {

// 继续往下看

counter += loadBeanDefinitions(resource);

}

// 最后返回 counter，表示总共加载了多少的 BeanDefinition

return counter;

}

// XmlBeanDefinitionReadehttp://r 303

@Override

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

return loadBeanDefinitions(new EncodedResource(resource));

}

// XmlBeanDefinitionReader 314

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

Assert.notNull(encodedResource, "EncodedResource must not be null");

if (logger.isInfoEnabled()) {

logger.info("Loading XML bean definitions from " + encodedResource.getResource());

}

// 用一个 ThreadLocal 来存放配置文件资源

Set currentResources = this.resourcesCurrentlyBeingLoaded.get();

if (currentResources == null) {

currentResources = new HashSet(4);

this.resourcesCurrentlyBeingLoaded.set(currentResources);

}

if (!currentResources.add(encodedResource)) {

throw new BeanDefinitionStoreException(

"Detected cyclic loading of " + encodedResource + " - check your import definitions!");

}

try {

InputStream inputStream = encodedResource.getResource().getInputStream();

try {

InputSource inputSource = new InputSource(inputStream);

if (encodedResource.getEncoding() != null) {

inputSource.setEncoding(encodedResource.getEncoding());

}

// 核心部分是这里，往下面看

return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

}

finally {

inputStream.close();

}

catch (IOException ex) {

throw new BeanDefinitionStoreException(

"IOException parsing XML document from " + encodedResource.getResource(), ex);

}

finally {

currentResources.remove(encodedResource);

if (currentResources.isEmpty()) {

this.resourcesCurrentlyBeingLoaded.remove();

}

// 还在这个文件中，第 388 行

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

throws BeanDefinitionStoreException {

try {

// 这里就不看了，将 xml 文件转换为 Document 对象

Document doc = doLoadDocument(inputSource, resource);

// 继续

return registerBeanDefinitions(doc, resource);

}

catch (...

}

// 还在这个文件中，第 505 行

// 返回值：返回从当前配置文件加载了多少数量的 Bean

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

int countBefore = getRegistry().getBeanDefinitionCount();

// 这里

documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

return getRegistry().getBeanDefinitionCount() - countBefore;

}

// DefaultBeanDefinitionDocumentReader 90

@Override

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

this.readerContext = readerContext;

logger.debug("Loading bean definitions");

Element root = doc.getDocumentElement();

// 从 xml 根节点开始解析文件

doRegisterBeanDefinitions(root);

}

// doRegisterBeanDefinitions 经过漫长的链路，一个配置文件终于转换为一颗 DOM 树了，注意，这里指的是其中一个配置文件，不是所有的，读者可以看到上面有个 for 循环的。下面开始从根节点开始解析：

// DefaultBeanDefinitionDocumentReader 116

protected void doRegisterBeanDefinitions(Element root) {

// 我们看名字就知道，BeanDefinitionParserDelegate 必定是一个重要的类，它负责解析 Bean 定义，

// 这里为什么要定义一个 parent? 看到后面就知道了，是递归问题，

// 因为内部是可以定义的，所以这个方法的 root 其实不一定就是 xml 的根节点，也可以是嵌套在里面的节点，从源码分析的角度，我们当做根节点就好了

BeanDefinitionParserDelegate parent = this.delegate;

this.delegate = createDelegate(getReaderContext(), root, parent);

if (this.delegate.isDefaultNamespace(root)) {

// 这块说的是根节点中的 profile 是否是当前环境需要的，

// 如果当前环境配置的 profile 不包含此 profile，那就直接 return 了，不对此解析

// 不熟悉 profile 为何物，不熟悉怎么配置 profile 读者的请移步附录区

String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);

if (StringUtils.hasText(profileSpec)) {

String[] specifiedProfiles = StringUtils.tokenizeToStringArray(

profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);

if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {

if (logger.isInfoEnabled()) {

logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +

"] not matching: " + getReaderContext().getResource());

}

return;

}

preProcessXml(root); // 钩子 preProcessXml(root) 和 postProcessXml(root) 是给子类用的钩子方法，鉴于没有被使用到，也不是我们的重点，我们直接跳过。

// 往下看

parseBeanDefinitions(root, this.delegate);

postProcessXml(root); // 钩子

this.delegate = parent;

}

// default namespace 涉及到的就四个标签、、和，

// 其他的属于 custom 的

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

if (delegate.isDefaultNamespace(root)) {

NodeList nl = root.getChildNodes();

for (int i = 0; i < nl.getLength(); i++) {

Node node = nl.item(i);

if (node instanceof Element) {

Element ele = (Element) node;

if (delegate.isDefaultNamespace(ele)) {

// 解析 default namespace 下面的几个元素

parseDefaultElement(ele, delegate);

}

else {

// 解析其他 namespace 的元素

delegate.parseCustomElement(ele);

}

else {

delegate.parseCustomElement(root);

}

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {

if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {

// 处理标签

importBeanDefinitionResource(ele);

}

else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {

// 处理标签定义

processAliasRegistration(ele);

}

else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {

// 处理标签定义，这也算是我们的重点吧

processBeanDefinition(ele, delegate);

}

else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {

// 如果碰到的是嵌套的标签，需要递归

doRegisterBeanDefinitions(ele);

}

// DefaultBeanDefinitionDocumentReader 298

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

// 将节点中的信息提取出来，然后封装到一个 BeanDefinitionHolder 中，细节往下看

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

// 下面的几行先不要看，跳过先，跳过先，跳过先，后面会继续说的

if (bdHolder != null) {

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

try {

// Register the final decorated instance.

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

}

catch (BeanDefinitionStoreException ex) {

getReaderContext().error("Failed to register bean definition with name '" +

bdHolder.getBeanName() + "'", ele, ex);

}

// Send registration event.

getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

}

// BeanDefinitionParserDelegate 428

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {

return parseBeanDefinitionElement(ele, null);

}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {

String id = ele.getAttribute(ID_ATTRIBUTE);

String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

List aliases = new ArrayList();

// 将 name 属性的定义按照 “逗号、分号、空格” 切分，形成一个别名列表数组，

// 当然，如果你不定义 name 属性的话，就是空的了

// 我在附录中简单介绍了一下 id 和 name 的配置，大家可以看一眼，有个20秒就可以了

if (StringUtils.hasLength(nameAttr)) {

String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

aliases.addAll(Arrays.asList(nameArr));

}

String beanName = id;

// 如果没有指定id, 那么用别名列表的第一个名字作为beanName

if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {

beanName = aliases.remove(0);

if (logger.isDebugEnabled()) {

logger.debug("No XML 'id' specified - using '" + beanName +

"' as bean name and " + aliases + " as aliases");

}

if (containingBean == null) {

checkNameUniqueness(beanName, aliases, ele);

}

// 根据 ... 中的配置创建 BeanDefinition，然后把配置中的信息都设置到实例中,

// 细节后面细说，先知道下面这行结束后，一个 BeanDefinition 实例就出来了。

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

// 到这里，整个标签就算解析结束了，一个 BeanDefinition 就形成了。

if (beanDefinition != null) {

// 如果都没有设置 id 和 name，那么此时的 beanName 就会为 null，进入下面这块代码产生

// 如果读者不感兴趣的话，我觉得不需要关心这块代码，对本文源码分析来说，这些东西不重要

if (!StringUtils.hasText(beanName)) {

try {

if (containingBean != null) {// 按照我们的思路，这里 containingBean 是 null 的

beanName = BeanDefinitionReaderUtils.generateBeanName(

beanDefinition, this.readerContext.getRegistry(), true);

}

else {

// 如果我们不定义 id 和 name，那么我们引言里的那个例子：

// 1. beanName 为：com.javadoop.example.MessageServiceImpl#0

// 2. beanClassName 为：com.javadoop.example.MessageServiceImpl

beanName = this.readerContext.generateBeanName(beanDefinition);

String beanClassName = beanDefinition.getBeanClassName();

if (beanClassName != null &&

beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&

!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

// 把 beanClassName 设置为 Bean 的别名

aliases.add(beanClassName);

}

if (logger.isDebugEnabled()) {

logger.debug("Neither XML 'id' nor 'name' specified - " +

"using generated bean name [" + beanName + "]");

}

catch (Exception ex) {

error(ex.getMessage(), ele);

return null;

}

String[] aliasesArray = StringUtils.toStringArray(aliases);

// 返回 BeanDefinitionHolder

return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

}

return null;

}

看到这里的时候，我觉得读者就应该站在高处看 ApplicationContext 了，ApplicationContext 继承自 BeanFactory，但是它不应该被理解为 BeanFactory 的实现类，而是说其内部持有一个实例化的 BeanFactory（DefaultListableBeanFactory）。以后所有的 BeanFactory 相关的操作其实是委托给这个实例来处理的。

我们说说为什么选择实例化 DefaultListableBeanFactory ？前面我们说了有个很重要的接口 ConfigurableListableBeanFactory，它实现了 BeanFactory 下面一层的所有三个接口，我把之前的继承图再拿过来大家再仔细看一下：

我们可以看到 ConfigurableListableBeanFactory 只有一个实现类DefaultListableBeanFactory，而且实现类 DefaultListableBeanFactory 还通过实现右边的 AbstractAutowireCapableBeanFactory 通吃了右路。所以结论就是，最底下这个家伙 DefaultListableBeanFactory 基本上是最牛的 BeanFactory 了，这也是为什么这边会使用这个类来实例化的原因。

循环依赖

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!

</head>

Java Spring的refresh方法你知道吗

Java查询时间段(startTime

mybatis where 标签使用