Java|Java Spring的refresh方法你知道吗 JavaSpring的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); // 获取父 BeanString getParentName(); // 设置 Bean 的类名称，将来是要通过反射来生成实例的void setBeanClassName(String beanClassName); // 获取 Bean 的类名称String getBeanClassName(); // 设置 bean 的 scopevoid 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 的 beanvoid 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(); // 是否 singletonboolean isSingleton(); // 是否 prototypeboolean isPrototype(); // 如果这个 Bean 是被设置为 abstract，那么不能实例化，// 常用于作为父bean 用于继承，其实也很少用......boolean isAbstract(); int getRole(); String getDescription(); String getResourceDescription(); BeanDefinition getOriginatingBeanDefinition(); }

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

@Overridepublic 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(); // 返回刚刚创建的 BeanFactoryConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (logger.isDebugEnabled()) {logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory); }return beanFactory; }// refreshBeanFactory@Overrideprotected final void refreshBeanFactory() throws BeansException {// 如果 ApplicationContext 中已经加载过 BeanFactory 了，销毁所有 Bean，关闭 BeanFactory// 注意，应用中 BeanFactory 本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前// ApplicationContext 是否有 BeanFactoryif (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。*/@Overrideprotected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {// 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReaderXmlBeanDefinitionReader 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) {// 2reader.loadBeanDefinitions(configLocations); }}// 上面虽然有两个分支，不过第二个分支很快通过解析路径转换为 Resource 以后也会进到这里@Overridepublic int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {Assert.notNull(resources, "Resource array must not be null"); int counter = 0; // 注意这里是个 for 循环，也就是每个文件是一个 resourcefor (Resource resource : resources) {// 继续往下看counter += loadBeanDefinitions(resource); }// 最后返回 counter，表示总共加载了多少的 BeanDefinitionreturn counter; }// XmlBeanDefinitionReader 303@Overridepublic int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {return loadBeanDefinitions(new EncodedResource(resource)); }// XmlBeanDefinitionReader 314public 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 行// 返回值：返回从当前配置文件加载了多少数量的 Beanpublic 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@Overridepublic 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 116protected 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 298protected 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 428public 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, 那么用别名列表的第一个名字作为beanNameif (!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.MessageServiceImplbeanName = 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); // 返回 BeanDefinitionHolderreturn new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); }return null; }

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

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

文章图片

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