(一)Spring IoC源码-1.容器的初始化-05默认标签的解析

最新推荐文章于 2022-03-05 10:29:41 发布
原创 最新推荐文章于 2022-03-05 10:29:41 发布 · 364 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Spring #源码 #IOC

本文深入解析Spring中Bean标签的解析过程，包括import、alias、bean和beans四种标签的解析方式及其实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

默认标签的解析是在DefaultBeanDefinitionDocumentReader.parseDefaultElement(Element, BeanDefinitionParserDelegate)方法中处理的。

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)) {
        // recurse
        doRegisterBeanDefinitions(ele);
    }
}

可以看出，此方法可以解析import，alias，bean，beans这四种标签。

import标签的解析

Spring可以通过import标签对多个Spring配置文件进行整合，以此实现配置文件的模块化。

<beans>
    <import resource="transaction.xml"/>
    <import resource="dubbo.xml"/>
</beans>

下面看看Spring是如何解析import标签的。

/**
 * 解析import标签，加载bean到beanFactory中
 */
protected void importBeanDefinitionResource(Element ele) {
    //获取import标签的resource属性
    String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
    //如果resource属性为空，则不做任何处理
    if (!StringUtils.hasText(location)) {
        getReaderContext().error("Resource location must not be empty", ele);
        return;
    }

    // 解析resource属性，如 "${user.dir}"
    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

    Set<Resource> actualResources = new LinkedHashSet<>(4);

    // 判断location是绝对还是相对路径
    boolean absoluteLocation = false;
    try {
        absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
    }
    catch (URISyntaxException ex) {
        // cannot convert to an URI, considering the location relative
        // unless it is the well-known Spring prefix "classpath*:"
    }

    // 如果是绝对路径，根据绝对路径加载resource属性对应的配置文件
    if (absoluteLocation) {
        try {
            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
            }
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error(
                    "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
        }
    }
    else {//如果是相对路径，先尝试根据相对路径获取资源。如果获取失败，则计算出绝度路径，获取资源
        // No URL -> considering resource location as relative to the current file.
        try {
            int importCount;
            //先尝试根据相对路径获取资源
            Resource relativeResource = getReaderContext().getResource().createRelative(location);
            if (relativeResource.exists()) {
                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                actualResources.add(relativeResource);
            }
            else {//如果获取失败，则计算出绝度路径，获取资源
                String baseLocation = getReaderContext().getResource().getURL().toString();
                importCount = getReaderContext().getReader().loadBeanDefinitions(
                        StringUtils.applyRelativePath(baseLocation, location), actualResources);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
            }
        }
        catch (IOException ex) {
            getReaderContext().error("Failed to resolve current resource location", ele, ex);
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
                    ele, ex);
        }
    }
    //将LinkedHashSet形式的资源转化为数组形式
    Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
    //通知监听器，解析完成。
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

将步骤总结如下

  1. 获取import标签的resource属性
  2. 如果resource属性为空，则不做任何处理
  3. 解析resource属性成location，如 “${user.dir}”
  4. 判断location是绝对还是相对路径
  5. 如果是绝对路径，根据绝对路径加载resource属性对应的配置文件
  6. 如果是相对路径，先尝试根据相对路径获取资源。如果获取失败，则计算出绝度路径，根据绝对路径加载配置文件
  7. 通知监听器，解析完成
alias标签的解析

Spirng可以使用alias标签来完成bean别名的定义。如<bean id="testBean" class="com.test"/>，要给这个bean起别名，可以直接使用bean标签中的那么属性：<bean id="testBean" name="testBean,testBean2" class="com.test"/>
Spring还提供了另外一种声明别名的方式：

<bean id="testBean" class="com.test"/>
<alias name="testBean" alias="testBean,testBean2"/>

下面看看Spring是如何解析alias标签的。

protected void processAliasRegistration(Element ele) {
    //获取alias标签的name和alias属性
    String name = ele.getAttribute(NAME_ATTRIBUTE);
    String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
    boolean valid = true;
    //如果name属性为空
    if (!StringUtils.hasText(name)) {
        getReaderContext().error("Name must not be empty", ele);
        valid = false;
    }
    //如果alias属性为空
    if (!StringUtils.hasText(alias)) {
        getReaderContext().error("Alias must not be empty", ele);
        valid = false;
    }
    //如果name和alias属性都不为空
    if (valid) {
        try {
            //注册别名
            getReaderContext().getRegistry().registerAlias(name, alias);
        }
        catch (Exception ex) {
            getReaderContext().error("Failed to register alias '" + alias +
                    "' for bean with name '" + name + "'", ele, ex);
        }
        //注册别名成功后通知监听器做相应处理
        getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
    }
}

将步骤总结如下

  1. 获取alias标签的name和alias属性
  2. 如果name或alias属性为空，则不做任何处理
  3. 注册别名
  4. 注册别名成功后通知监听器做相应处理

下面看看org.springframework.core.SimpleAliasRegistry.registerAlias(String, String)是如何为bean注册别名的。

    @Override
public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    if (alias.equals(name)) {
        this.aliasMap.remove(alias);
    }
    else {
        String registeredName = this.aliasMap.get(alias);
        if (registeredName != null) {
            if (registeredName.equals(name)) {
                // An existing alias - no need to re-register
                return;
            }
            if (!allowAliasOverriding()) {
                throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
                        name + "': It is already registered for name '" + registeredName + "'.");
            }
        }
        checkForAliasCircle(name, alias);
        //以上都是在做检查
        //注册别名，即将别名alias作为key，name作为value放入map中
        this.aliasMap.put(alias, name);
    }
}
bean标签的解析

在这四种标签中，bean标签的解析是最重要也是最复杂的。下面看看DefaultBeanDefinitionDocumentReader.processBeanDefinition(Element, BeanDefinitionParserDelegate)是如何解析bean标签的。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    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));
    }
}

将步骤总结如下：

  1. 解析bean标签。委托BeanDefinitionDelegate类的parseBeanDefinitionElement方法去解析bean标签，返回一个BeanDefinitionHolder类型的bdHolder。bdHolder此时已经包含bean标签的各种属性了。
  2. 解析默认标签中的自定义标签。当返回的bdHolder不为空的情况下，若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析
  3. 注册。解析完成后，委托BeanDefinitionReaderUtils的registerBeanDefinition方法对bdHolder进行注册
  4. 通知监听器bean已经注册完成
解析bean标签

进入BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element)方法

@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}

@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    //获取bean的id属性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    //获取bean的name属性
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    List<String> aliases = new ArrayList<>();
    //如果bean的name属性不为空，根据分隔符分割name属性
    //public static final String MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; ";
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    //如果bean的id属性为空且name属性不为空
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        //将name属性分割后的第一个值作为id，并在日志中打印出来
        beanName = aliases.remove(0);
        if (logger.isDebugEnabled()) {
            logger.debug("No XML 'id' specified - using '" + beanName +
                    "' as bean name and " + aliases + " as aliases");
        }
    }

    //检查id和name在当前beans中有没有重复
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }
    //解析其他属性，封装成AbstractBeanDefinition 
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        //如果beanName依然为空,使用默认的方式生成唯一的beanName
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {

                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    // Register an alias for the plain bean class name, if still possible,
                    // if the generator returned the class name plus a suffix.
                    // This is expected for Spring 1.2/2.0 backwards compatibility.
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null &&
                            beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                            !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                        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;
}

将步骤总结如下：

  1. 获取id和name属性
  2. 默认id属性为beanName，如果id属性值为空，则取name属性的第一个名称；
  3. 判断beanName的唯一性；
  4. 解析其他属性，封装成AbstractBeanDefinition
  5. 如果beanName依然为空，使用默认的方式生成唯一的beanName；
  6. 将获取到的信息封装成BeanDefinitionHolder并返回

第四步需要特别关注

/**
 * 解析bean标签的其他属性
 */
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, @Nullable BeanDefinition containingBean) {

    this.parseState.push(new BeanEntry(beanName));

    String className = null;
    //获取bean标签class属性
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }
    String parent = null;
    //获取bean标签parent属性
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }

    try {
        //创建GenericBeanDefinition，记录className，和parent
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        //将bean的其他属性值都记录到bd中
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        //解析子元素description
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        //解析子元素meta
        parseMetaElements(ele, bd);
        //解析子元素loopup-method
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        //解析子元素replaced-method
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        //解析子元素constructor-arg
        parseConstructorArgElements(ele, bd);
        //解析子元素property
        parsePropertyElements(ele, bd);
        //解析子元素qualifier
        parseQualifierElements(ele, bd);
        //记录Resource
        bd.setResource(this.readerContext.getResource());
        bd.setSource(extractSource(ele));

        return bd;
    }
    catch (ClassNotFoundException ex) {
        error("Bean class [" + className + "] not found", ele, ex);
    }
    catch (NoClassDefFoundError err) {
        error("Class that bean class [" + className + "] depends on not found", ele, err);
    }
    catch (Throwable ex) {
        error("Unexpected failure during bean definition parsing", ele, ex);
    }
    finally {
        this.parseState.pop();
    }

    return null;
}

这里只是对此方法做简单介绍。至此，我们已经完成了从bean标签到GenericBeanDefinition的转换，bean标签中的属性都可以在GenericBeanDefinition实例中找到。

解析默认标签中的自定义标签

上面用了大量的篇幅介绍BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);，下面将介绍bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);。

当Spring中的bean使用的是默认标签的配置，但其中的子元素使用的确实自定义标签的配置，这个方法就会执行。

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
    return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
}

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
        Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {

    BeanDefinitionHolder finalDefinition = definitionHolder;

    // Decorate based on custom attributes first.
    //获取bean标签的所有属性
    NamedNodeMap attributes = ele.getAttributes();
    //遍历所有的属性，如果有自定义属性，则对BeanDefinitionHolder进行装饰
    for (int i = 0; i < attributes.getLength(); i++) {
        Node node = attributes.item(i);
        finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
    }

    // Decorate based on custom nested elements.
    //遍历所有的子节点，如果有自定义节点，则对BeanDefinitionHolder进行装饰
    NodeList children = ele.getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        Node node = children.item(i);
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        }
    }
    return finalDefinition;
}
注册

在上面已经对BeanDefinitionHolder实例进行了初始化和装饰，接下来就可以注册了。

/**
 * 将给定的BeanDefinitionHolder注册到BeanDefinitionHolder中。
 */
public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

    // 使用beanName 作为注册时的唯一标识
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // 注册别名
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}
通知监听器

在注册完成后，如果需要对注册事件进行监听，可以通过注册监听器的方式将处理逻辑写入监听器中。

beans标签的解析
/**
 * 递归调用beans的解析方法
 */
protected void doRegisterBeanDefinitions(Element root) {
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);

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

    preProcessXml(root);
    parseBeanDefinitions(root, this.delegate);
    postProcessXml(root);

    this.delegate = parent;
}

没什么好讲的，非常类似于import标签提供的功能。

本文已收录于Spring源码札记专栏。

Spring源码解析（二）：加载Bean过程
我的博客
07-17 334
加载Bean时序图 doLoadBeanDefinitions源码 /** * org.springframework.beans.factory.xml.XmlBeanDefinitionReader */ protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { Document doc = d
Spring启动流程（二）——获取BeanFactory
weixin_38910645的博客
10-29 1322
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { refreshBeanFactory(); ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (logger.isDebugEnabled()) { logger.debug("Bean factory for " + getDisplayName(
Spring源码解析十
qq_35873436的博客
03-05 385
Spring Bean标签的初步解析
Spring源码深度解析总结（4）—— 配置文件的读取和Bean的加载（二）
vergil小童鞋的博客
05-30 1227
上一篇文章讲到了Spring对于Bean的解析分为默认声明解析和自定义声明解析，这两种声明的解析差别还是很大的，所以我们分开来说。按照常理，默认的总是简单的，所以我们先看一看默认声明的解析是实现。    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { //对import...
StringUtils.tokenizeToStringArray()
扛麻袋的少年的博客
03-15 2387
读Spring源码的时候，遇到这么个东西，记录一下 BeanDefinitionParserDelegate /** * Parses the supplied {@code <bean>} element. May return {@code null} * if there were errors during parse. Errors are reported to the * {@link org.springframework.beans.factory.parsing.Pro
官方源码 spring-framework-5.3.2.zip
01-14
此外，还增强了Bean生命周期管理，如条件化 Bean 的创建和初始化。 6. **安全性的提升** Spring Security 5.3.2为认证和授权提供了更强大的功能，包括支持OAuth2.0、JWT等现代身份验证机制。此外，还增强了对CSRF...
官方原版源码spring-framework-5.1.0.RELEASE.zip
09-22
2. **Spring Beans**：实现了IoC容器，通过XML或注解方式配置bean，并负责bean的初始化、装配和销毁。 3. **Spring AOP**：面向切面编程模块，允许定义方法拦截器和切入点，实现代码的解耦和模块化。 4. **Spring ...
官方原版源码 spring-framework-5.1.15.RELEASE.zip
05-06
Spring Core负责基础的IoC（Inversion of Control）容器，Spring Beans则实现了Bean的生命周期管理和配置，Spring Context则是基于Core之上构建的，提供了一个应用上下文，可以管理Bean并与其他Spring模块集成。...
spring-framework-5.1.8.RELEASE:Spring源码包-源码包
03-24
- **Bean的生命周期**：从Bean的实例化、初始化、属性设置到销毁，Spring如何管理Bean的全生命周期。 - **AOP实现**：了解Spring如何通过代理模式实现切面，以及通知（advice）和切入点（pointcut）的定义。 - **...
官方原版完整包 spring-framework-5.1.18.RELEASE.zip
09-17
虽然不直接包含在5.1.18.RELEASE包中，但Spring Boot简化了Spring应用的初始化和配置，而Spring Cloud则为微服务架构提供了服务发现、配置中心、负载均衡等功能。 总的来说，Spring Framework 5.1.18.RELEASE是一...
Spring源代码解析之二（默认标签的解析）
fengziyu523的博客
12-10 418
默认标签解析 概述：本节重点详细分析默认标签的解析过程。接上一篇文章讲到parseBeanDefinitions(root, delegate); /** * Parse the elements at the root level in the document: * "import", "alias", "bean". * @param root the DOM root e...
32、深入解析spring技术$2
nickfover的专栏
10-03 125
DefaultListableBeanFactory：从上章的第3张图片中可以看出，几个实现类都引用了这个类，XmlBeanFactory继承了这个类，我们来看下这个DefaultListableBeanFactory类：它实现了BeanDefinitionRegistry、ConfigurableListableBeanFactory、AbstractAutowireCapableBeanF...
SpringBoot源码分析之加载配置文件
weixin_34278190的博客
05-05 659
上一篇从使用角度介绍了如何在 springboot 启动时对 yml 文件进行配置，这一篇尝试从源码角度去探讨其加载配置文件的机制。 我们回到 springboot 初始启动时的 run 方法，为了突出主干逻辑，对代码做了一些精简： public ConfigurableApplicationContext run(String... args) { //省略其他代码 ... Co...
spring源码分析之默认标签解析
热门推荐
liushangzaibeijing的博客
04-28 5万+
本篇博文通过对spring的xml配置的相关默认标签进行介绍，主要讲述spring默认标签的相关解析过程，包含四种默认标签 import标签，alias标签，bean标签，beans标签，其中重点讲解了bean标签的相关属性。希望对大家学习spring源码有所帮助
spring源码阅读（七）之bean解析
柳清风的专栏
11-15 5062
spring源码阅读（七）之bean解析
Spring--默认标签的解析
BtWangZhi的博客
01-19 413
1 在DefaultBeanDefinitionDocumentReader的方法parseBeanDefinitions中对于标签的解析分为默认标签的解析和自定义标签的解析。而默认标签与自定义标签的的区分是根据命名空间来进行判断的。具体代码如下 BeanDefinitionParserDelegate类 public static final String BEANS_NAMESPACE_UR
spring源码（4）Register the bean definitions（3）
Programming is an art form.
07-27 737
spring源码（4）Register the bean definitions（3）本节介绍bean标签的其他属性的解析 public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, BeanDefinition containingBean, AbstractB
Gateway + Consul 报错：Consul service ids must not be empty, must start with a letter, end with a lette
Masli的博客
08-09 4105
感悟：没有用到的Jar包就不要加进去了 使用Spring Cloud Gateway作为服务网关，搭配Consul作为注册中心，由于一开始没有使用Consul，但是引入Consul的Jar的包，所以虽然没有使用Consul，但是还是会默认去寻找跟Consul有关的配置信息，所以就会报错 org.springframework.beans.factory.UnsatisfiedDependencyE...
Spring源码解析：Web容器中IoC容器的初始化与层次结构
总结来说，Spring在Web容器中的启动涉及到上下文的初始化、配置文件的解析以及与Servlet容器的集成，形成一个高度可扩展且易于维护的架构。理解这些细节对于深入学习Spring框架和Web开发至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值