Spring源码阅读系列之obtainFreshBeanFactory()实现

最新推荐文章于 2024-04-17 05:07:42 发布
最新推荐文章于 2024-04-17 05:07:42 发布
阅读量228 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShiLuoHeroKing/article/details/106688294
版权

接着上一篇文章，本篇来接着谈谈 Spring 容器的创建及 bean 定义的解析。Debug 使用的代码和上一篇文章提供的保持一致

本篇文章由于代码调用流程较长，所以先给大家呈现一张调用流程图，方便大家更容易理解调用层次，废话不多说了，先上图一睹为快。

创建BeanFactory及注册BeanDefinition流程

  1. 直接来看下obtainFreshBeanFactory源码实现

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // Step1：创建BeanFactory并注册BeanDefinition定义
    // 通过这个方法可以看出，所有实现是在这个方法里面完成的
    refreshBeanFactory();
    // Step2：获取创建好的BeanFactory对象，并返回
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}

  1. refreshBeanFactory实现其实调用了其子类AbstractRefreshableApplicationContext.refreshBeanFactory()方法。

protected final void refreshBeanFactory() throws BeansException {
    // Step1：判断BeanFactory是否已经创建好，一般情况下第一次初始化Spring容器的时候if是不成立的，因为在此之前没有地方可以创建出BeanFactory对象
    if (hasBeanFactory()) {
      // 如果已经创建好，先将创建好的bean实例，相关缓存，BeanDefinition定义全部清空
      // Spring源码中大量运用了缓存，来提高Spring容器初始化的速度
      destroyBeans();
      // 然后在将BeanFactory置为null
      closeBeanFactory();
    }
    try {
      // Step2：创建一个DefaultListableBeanFactory对象，该对象用于存储Bean实例、相关缓存、BeanDefinition定义等等
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      // Step3：设置是否允许BeanDefinition是否可以被覆盖
      // 设置循环引用
      customizeBeanFactory(beanFactory);
      // Step4：加载BeanDefinition定义，并将其注册到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);
    }
}

  1. loadBeanDefinitions() 实现由AbstractRefreshableApplicationContext子类AbstractXmlApplicationContext.loadBeanDefinitions()方法实现的。

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    // Step1：创建一个XmlBeanDefinitionReader对象，用于读取xml文档
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // Configure the bean definition reader with this context's
    // resource loading environment.
    // Step2：设置环境变量
    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.
    // Step3：初始化BeanDefinitionReader，设置是否启用xml文档校验，默认情况下是需要校验的
    // 说白了就是是否要校验xml文档的合法性，避免错误解析
    initBeanDefinitionReader(beanDefinitionReader);
    // Step4：加载beanDefinitions
    loadBeanDefinitions(beanDefinitionReader);
}

  1. 初始化XmlBeanDefinitionReader对象完成后，开始读取配置文件资源。

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    // Step1：首先读取ClassPathXmlApplicationContext里面存放点的Resource资源
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
      // Step1.1：如果Resource资源不为空，则开始加载Resource资源
      reader.loadBeanDefinitions(configResources);
    }
    // Step2：读取AbstractRefreshableConfigApplicationContext指定配置文件资源
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
      // Step2.1：如果Location资源不为空，则开始加载Location资源
      reader.loadBeanDefinitions(configLocations);
    }
}

  1. 获取到配置文件路径后，开始遍历解析每个配置文件，不管是第一种资源还是第二种资源，最后都统一调用了XmlBeanDefinitionReader类的父类AbstractBeanDefinitionReader的loadBeanDefinitions()方法。

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
    // Step1：获取资源读取器
    ResourceLoader resourceLoader = getResourceLoader();
    if (resourceLoader == null) {
      throw new BeanDefinitionStoreException(
          "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    }
    // Step2：如果当前的资源读取器实现了ResourcePatternResolver接口
    if (resourceLoader instanceof ResourcePatternResolver) {
      // Resource pattern matching available.
      try {
        // Step2.1：获取resource资源
        Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
        // Step2.2：加载所有指定的resource资源里面定义的BeanDefinitions
        int loadCount = loadBeanDefinitions(resources);
        if (actualResources != null) {
          for (Resource resource : resources) {
            actualResources.add(resource);
          }
        }
        if (logger.isDebugEnabled()) {
          logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
        }
        return loadCount;
      }
      catch (IOException ex) {
        throw new BeanDefinitionStoreException(
            "Could not resolve bean definition resource pattern [" + location + "]", ex);
      }
    }
    else {
      // Can only load single resources by absolute URL.
      // Step3：如果没有实现ResourcePatternResolver接口，则根据当前的resourceLoader获取Resource资源
      Resource resource = resourceLoader.getResource(location);
      // Step3.1：加载指定的Resource资源定义的BeanDefinitions
      int loadCount = loadBeanDefinitions(resource);
      if (actualResources != null) {
        actualResources.add(resource);
      }
      if (logger.isDebugEnabled()) {
        logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
      }
      return loadCount;
    }
}

  1. 上面这段代码主要作用是使用不同的BeanDefinitionReader读取器读取不同类型的配置文件。拿我们提供的测试例子，最后其实调用了XmlBeanDefinitioneader.loadBeanDefinitions()方法。在这个方法里面我们看到一个比较特别的方法，叫做doLoadBeanDefinitions()，其实真正加载BeanDefinition是在这个方法里面实现的。

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());
    }
    // Step1：获取当前的Resource对象，刚开始肯定是没有的
    Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    if (currentResources == null) {
      // Step1.1：将当前Resource设置进去
      currentResources = new HashSet<>(4);
      this.resourcesCurrentlyBeingLoaded.set(currentResources);
    }
    // Step2：只有在第一次添加的时候才会返回true，也就意味着如果当前resource已经被设置过了，则出现了重复加载，直接抛出异常
    if (!currentResources.add(encodedResource)) {
      throw new BeanDefinitionStoreException(
          "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    }
    try {
      // Step3：根据resource对象获取对应的InputStream
      InputStream inputStream = encodedResource.getResource().getInputStream();
      try {
        InputSource inputSource = new InputSource(inputStream);
        if (encodedResource.getEncoding() != null) {
          inputSource.setEncoding(encodedResource.getEncoding());
        }
        // Step4：拿到inputSource对象，开始正式读取配置文件，并创建配置文件中定义的BeanDefinition
        return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
      }
      finally {
        // Setp5：关闭输入流
        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();
      }
    }
}

  1. 拿到了InputSource之后，来看看配置文件到底是如何被解析的。

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {
    try {
      // Step1：加载Document对象，其实就是把xml文件解析成一个文档对象返回
      Document doc = doLoadDocument(inputSource, resource);
      // Step2：对Document对象遍历，读取不同的标签名，创建对应的BeanDefinition，并将创建出来的BeanDefinition注册到BeanFactory中去
      return registerBeanDefinitions(doc, resource);
    }
    // 此处为了方便阅读，将各种异常代码用.....代替
    ......
    catch (Throwable ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
          "Unexpected exception parsing XML document from " + resource, ex);
    }
}

  1. 先来看看Document对象是怎么创建出来的。

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
        getValidationModeForResource(resource), isNamespaceAware());
}

public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
      ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
    // Step1：创建Document工厂，这里面其实就是设置配置文件的文件头
    // 比如applicationContext.xml文件里面最开始，beans标签里面指定的 .xsd。了解即可
    DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
    if (logger.isDebugEnabled()) {
      logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
    }
    // Step2：利用Document工厂，创建对应的DocumentBuilder。
    DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
    // Step3：利用builder去解析输入流，从而构建出Document对象
    return builder.parse(inputSource);
}

// 这个方法就是文档的一些解析处理，了解一下
public Document parse(InputSource is) throws SAXException, IOException {
        if (is == null) {
            throw new IllegalArgumentException(
                DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN,
                "jaxp-null-input-source", null));
        }
        if (fSchemaValidator != null) {
            if (fSchemaValidationManager != null) {
                fSchemaValidationManager.reset();
                fUnparsedEntityHandler.reset();
            }
            resetSchemaValidator();
        }
        domParser.parse(is);
        Document doc = domParser.getDocument();
        domParser.dropDocumentReferences();
        return doc;
}

  1. 到现在，已经将 xml 文件解析成Document对象了，接下来看看根据Document对象如何创建BeanDefinition对象并注册到BeanFactory里面。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    int countBefore = getRegistry().getBeanDefinitionCount();
    // 这里我们只关注如何把Document对象注册到BeanFactory里面
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

protected void doRegisterBeanDefinitions(Element root) {
    // Any nested <beans> elements will cause recursion in this method. In
    // order to propagate and preserve <beans> default-* attributes correctly,
    // keep track of the current (parent) delegate, which may be null. Create
    // the new (child) delegate with a reference to the parent for fallback purposes,
    // then ultimately reset this.delegate back to its original (parent) reference.
    // this behavior emulates a stack of delegates without actually necessitating one.
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);
    // Step1：以beans开始，是否可以取到 “profile”标签，我们没有在xml文件里面指定，所以这个地方可以忽略
    if (this.delegate.isDefaultNamespace(root)) {
      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;
        }
      }
    }
    // Step2：解析前工作，默认没有实现，留出来扩展
    preProcessXml(root);
    // Step3：开始解析Document
    parseBeanDefinitions(root, this.delegate);
    // Step4：解析后工作，默认没有实现，留出来扩展
    postProcessXml(root);

    this.delegate = parent;
}

  1. 重点来了，我们在 xml 文件里面配置的Bean标签就是在这个里面被转化成一个个BeanDefinition对象的。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // Step1：如果是默认的命名空间，使用默认的解析逻辑
    if (delegate.isDefaultNamespace(root)) {
      // Step1.1：获取所有子节点
      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;
          // Step1.2：如果子节点是 “import”、“alias”、“bean”、“beans”等等的
          // 则走默认的标签解析处理逻辑
          if (delegate.isDefaultNamespace(ele)) {
            parseDefaultElement(ele, delegate);
          }
          else {
            // Step1.3：如果不是上面指定的这些标签的话，则走特殊的标签解析逻辑
            delegate.parseCustomElement(ele);
          }
        }
      }
    }
    // Step2：不是默认的命名空间，则走自己的解析逻辑
    else {
      delegate.parseCustomElement(root);
    }
}

总结

从本篇文章不难看出，obtainFreshBeanFactory 就是创建了一个 BeanFactory 对象，然后把 xml 配置文件解析成 Document 对象，然后对 Document 对象遍历，创建出相应的 BeanDefinition 定义，并把 BeanDefinition 对象注册到 BeanFactory 里面。

到这里我们拿到了 xml 配置的 bean 标签。限于文章篇幅过长，我在下一篇文章中来继续解释，bean 标签是如何被解析的，比如 id，class，scope 等等属性。

欢迎关注我，共同学习

ShiLuoHeroKing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring:spring源码阅读-spring源码阅读
03-24
Spring Framework源码阅读 一，环境建设与代码编译 1.在github上克隆代码。 2.打开import-into-idea.md按照该文件中步骤操作。 1.新建一个模块命名spring-src-read 2.在其中测试spring环境是否建成完毕 注意在...
Spring容器刷新—02—obtainFreshBeanFactory
xxxzzzqqq_的博客
03-20 133
看的名字就能知道，这个系列的实现是支持多次刷新操作的(不像上面说的这种只支持刷新一次)。内部也维护着一个, 值得注意的是这个是被volatile修饰的(涉及到多次刷新，频繁修改的引用指向)。对销毁之前可能存在的旧的: 销毁中所有单例(毕竟此时都要销毁了,中的单例肯定要顺带给销毁掉): 实际上就是新建一个并做一些必要的初始化: 重新创建一个实例: 设置id实际上就是给和赋值给新创建的中加载这一步是抽象方法，不同子类的实现不同但基本上都是委托各种各样的给新创建的中添加。新创建的temp上位。
Spring源码解析二 obtainFreshBeanFactory
小tu豆的博客
06-15 201
我们接着上次的说，上次还剩下AnnotationConfigApplicationContex这个类的构造方法里调用的refresh();没有说，我们今天来看看这个重点方法：refresh();
深入理解Spring源码（二）之obtainFreshBeanFactory()方法
spring_live_in的博客
09-20 1470
这边我们将分析obtainFreshBeanFactory() BeanFactory的创建以及相关的准备工作！ //这一步主要作用是将配置文件定义解析成beanDefine 注册到beanFactory中 //但是这里的bean并没有初始化出来 只是提取配置信息 定义相关的属性 //将这些信息保存到beanDefine...
Spring ApplicationContext容器启动refresh方法简单分析
simba_1986的专栏
02-07 3618
ApplicationContext容器启动过程代码分析 @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing
spring源码系列三-obtainFreshBeanFactory()
一个喜欢诗和远方的程序媛
04-02 419
1.spring源码中refresh()方法包含的13个主要的方法。obtainFreshBeanFactory()方法为其中之一显得尤为重要。2.obtainFreshBeanFactory()方法主要作用：是创建BeanFactory对象，并解析xml封装成BeanDefinition对象。3.obtainFreshBeanFactory()内部方法调用链比较长，如下：行文中均以比较重要的方法代码片段为例，有些次要方法没有详细展开。
Spring源码学习加注释，方便学习.zip
05-11
spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文...
spring源码雷神spring源码雷神
08-06
spring源码雷神spring源码雷神
教你阅读Spring源码资源.zip
04-30
调试代码+Spring包+jdk包，调试代码简单易懂且通过一些例子进行说明源码主要功能。Spring包中不需要的可以不用导入项目，
spring源码16: @Autowired实现原理
12-22
在阅读本篇之前，如果对后置处理器还不够熟悉的先参考下spring BeanPostProcessor 生命周期 @Autowired使用 构造函数注入 public Class Outer { private Inner inner; @Autowired public Outer(Inner inner) { ...
4、obtainFreshBeanFactory流程.vsdx
08-13
本文档清晰明了的讲解了refresh()核心之obtainFreshBeanFactory()的流程图
5.2、spring-refresh-obtainFreshBeanFactory-parseDefaultElement加载解析bean.vsdx
08-10
本次为spring解析配置文件中spring.xml的过程，并且根据解析的spring.xml中的<bean>节点加载bean到map中。
obtainFreshBeanFactory()详解
xizhuyuan1676的博客
05-12 145
obtainFreshBeanFactory()详解
Spring源码讲解之 obtainFreshBeanFactory 方法
misterhou的专栏
08-07 109
obtainFreshBeanFactory 方法的会在 org.springframework.context.support.AbstractApplicationContext.refresh() 方法中被调用，该方法调用没有参数，返回值类型 org.springframework.beans.factory.config.ConfigurableListableBeanFactory，实现功能是创建一个 bean 工厂并将其返回。 源码 protected ConfigurableListableB
obtainFreshBeanFactory 详解（二）
Jay的博客
08-04 1033
前言 上文 Spring IoC：ApplicationContext 刷新前的配置 介绍了 refresh 方法前的环境准备操作，接下来正式进入 refresh 方法。prepareRefresh 是refresh 里的第一个方法，主要是一些准备工作，比较简单的方法，看一下就了解了。接下来是 obtainFreshBeanFactory 方法，该方法用于获得一个新的 BeanFactory，本文将详细介绍该方法。 提醒读者的一点，本节了解即可，主要对于配置，BeanFactory有个印象即可，本章对于sp
Spring之启动过程obtainFreshBeanFactory()
thewindkee的博客
01-20 1813
1.refresh流程 我们知道refresh是spring启动的关键方法，refresh启动过程中，先要得到beanFactory 以及 需要交给beanFactory管理的bean。 在refresh时，prepareRefresh后，马上就调用了obtainFreshBeanFactory创建beanFactory以及扫描bean信息(beanDefinition)，并通过BeanDefin...
Spring IoC源码学习：obtainFreshBeanFactory 详解
最新发布
2401_84048225的博客
04-17 700
Override// 1.为指定BeanFactory创建XmlBeanDefinitionReader// 2.使用此上下文的资源加载环境配置 XmlBeanDefinitionReader// resourceLoader赋值为XmlWebApplicationContext// 3.加载 bean 定义3.加载 bean 定义，。代码块3：loadBeanDefinitions// 1.获取配置文件路径= null) {// 2.根据配置文件路径加载 bean 定义。
spirng源码中关于方法refreshBeanFactory委派模式的理解
onlyonexhj的专栏
08-08 583
今天在查看spring源码时在AbstractApplicationContext类中看到了如下代码 跟进refreshBeanFactory()方法后发现是一个抽象方法，如下： protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException; 而正在实现方法的是她的子...
refreshBeanFactory
ray1205的专栏
09-21 1271
org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory() 首先，hasBeanFactory，判断context目前是否持有bean factory，如果有：先执行一个模版方法，销毁这个context管理的所有bean，默认实现销毁所有context中的单例缓存，调
spring源码阅读的最佳方法
06-08
阅读Spring源码的最佳方法包括以下几个步骤： 1. 确定阅读版本：Spring的发展迅速，不同版本之间可能会有较大的差异，因此需要确定要阅读的版本。 2. 学习Spring的核心概念：在阅读源码之前，需要先掌握Spring的核心概念，包括IoC、AOP、Bean、容器等。 3. 熟悉源码结构：阅读源码之前，需要熟悉Spring的源码结构，包括各个模块的作用和关系。 4. 选择入口类：选择一个入口类作为阅读的起点，例如ApplicationContext、BeanFactory等。 5. 调试源码：借助调试工具，可以更好地理解Spring的执行流程和实现细节。 6. 阅读源码注释：Spring的源码注释非常详细，阅读源码时可以结合注释进行理解。 7. 参考资料：阅读Spring源码需要有一定的Java基础和相关技术的知识储备，建议阅读前先学习相关的书籍或文档。 总之，阅读Spring源码需要耐心和毅力，需要通过不断的实践和思考才能获得更深入的理解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值