spring源码深度解析---默认标签解析（下）

最新推荐文章于 2020-08-05 23:42:21 发布
最新推荐文章于 2020-08-05 23:42:21 发布
阅读量352 收藏 2
点赞数
分类专栏： spring源码深度解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uftjtt/article/details/79914421
版权

spring源码深度解析—默认标签解析（下）

在spring源码深度解析—默认标签解析（上）中我们已经完成了从xml配置文件到BeanDefinition的转换，转换后的实例是GenericBeanDefinition的实例。而GenericBeanDefinition是AbstractBeanDefinition的子类，那我们优先看下AbstractBeanDefinition中的属性，代码如下：

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable {
    public static final String SCOPE_DEFAULT = "";
    public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
    public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
    public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
    public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
    @Deprecated
    public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;
    public static final int DEPENDENCY_CHECK_NONE = 0;
    public static final int DEPENDENCY_CHECK_OBJECTS = 1;
    public static final int DEPENDENCY_CHECK_SIMPLE = 2;
    public static final int DEPENDENCY_CHECK_ALL = 3;
    public static final String INFER_METHOD = "(inferred)";
    @Nullable
    private volatile Object beanClass;
    //bean的作用范围，对应了bean的scope属性
    @Nullable
    private String scope = SCOPE_DEFAULT;
    //是否抽象，对应bean的abstract属性
    private boolean abstractFlag = false;
    //是否延迟加载，对应了bean的lazy-inti属性
    private boolean lazyInit = false;
    //对应bean的autowire模式
    private int autowireMode = AUTOWIRE_NO;
    //依赖检查
    private int dependencyCheck = DEPENDENCY_CHECK_NONE;
    //用来表示一个bean的实例化依靠另一个bean先实例化，对应bean属性的depend-on
    @Nullable
    private String[] dependsOn;
    //autowire-candicate属性设置为false，这样容器在查找自动装配对象时将不考虑bean,则它不会被考虑作为其他bean自动装配的候选者，但是该bean本身还是可以使用自动装配来注入其他bean的
    //对应bean属性的autowire-candidate
    private boolean autowireCandidate = true;
    //自动装配时当出现多个bean候选者时，将作为首选者，对应bean属性primary
    private boolean primary = false;
    //用于记录Qualifier,对应子元素qualifier
    private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>(0);
    @Nullable
    private Supplier<?> instanceSupplier;
    //允许访问非公开的构造器和方法，程序设置
    private boolean nonPublicAccessAllowed = true;
    private boolean lenientConstructorResolution = true;
    //对应bean属性的factory-bean
    @Nullable
    private String factoryBeanName;
    //对应bean属性的factory-method
    @Nullable
    private String factoryMethodName;
    //记录构造函数注入属性，对应bean属性constructor-arg
    @Nullable
    private ConstructorArgumentValues constructorArgumentValues;
    //普通属性集合
    @Nullable
    private MutablePropertyValues propertyValues;
    //方法重写的持有者，记录lookup-method  replaced-method元素
    @Nullable
    private MethodOverrides methodOverrides;
    //初始化方法，对应bean属性的init-method
    @Nullable
    private String initMethodName;
    //销毁方法，对应bean属性的deatory-method
    @Nullable
    private String destroyMethodName;
    //是否执行init-method程序设置
    private boolean enforceInitMethod = true;
    //是否执行deatory-method程序设置
    private boolean enforceDestroyMethod = true;
    //是否是用户定义的而不是应用程序本身定义的，创建AOP时候为true，程序设置
    private boolean synthetic = false;
    //定义这个bean的应用，APPLICATION:用户；INFRASTRUCTURE:完全内部使用，与用户无关，SUPPORT：某些复杂配置的一部分
    private int role = BeanDefinition.ROLE_APPLICATION;
    //bean的描述信息
    @Nullable
    private String description;
    //bean定义的资源
    @Nullable
    private Resource resource;

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

在上篇博文中我们已经分析了对于默认标签的解析，我们继续看戏之前的代码，如下图片中有一个方法：delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)
这里写图片描述
这个方法的作用是什么呢？首先我们看下这种场景，如下配置文件：

 <bean id="demo" class="com.yhl.myspring.demo.bean.MyBeanDemo">
     <property name="beanName" value="bean demo1"/>
     <meta key="demo" value="demo"/>
     <mybean:user name="mybean"/>
 </bean>

这个配置文件中有个自定义的标签，decorateBeanDefinitionIfRequired方法就是用来处理这种情况的，其中的null是用来传递父级BeanDefinition的，我们进入到其方法体：

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.
    NamedNodeMap attributes = ele.getAttributes();
    for (int i = 0; i < attributes.getLength(); i++) {
        Node node = attributes.item(i);
        finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
    }

    // Decorate based on custom nested elements.
    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;
}

我们看到上面的代码有两个遍历操作，一个是用于对所有的属性进行遍历处理，另一个是对所有的子节点进行处理，两个遍历操作都用到了decorateIfRequired(node, finalDefinition, containingBd);方法，我们继续跟踪代码，进入方法体：

public BeanDefinitionHolder decorateIfRequired(
        Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

    String namespaceUri = getNamespaceURI(node);
    if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler != null) {
            BeanDefinitionHolder decorated =
                    handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
            if (decorated != null) {
                return decorated;
            }
        }
        else if (namespaceUri.startsWith("http://www.springframework.org/")) {
            error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
        }
        else {
            // A custom namespace, not to be handled by Spring - maybe "xml:...".
            if (logger.isDebugEnabled()) {
                logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
            }
        }
    }
    return originalDef;
}

2. 注册解析的BeanDefinition

对于配置文件，解析和装饰完成之后，对于得到的beanDefinition已经可以满足后续的使用要求了，还剩下注册，也就是processBeanDefinition函数中的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,getReaderContext().getRegistry())代码的解析了。进入方法体：

public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {
    // Register bean definition under primary name.
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

从上面的代码我们看到是用了beanName作为唯一标示进行注册的，然后注册了所有的别名aliase。而beanDefinition最终都是注册到BeanDefinitionRegistry中，接下来我们具体看下注册流程。

3. 通过beanName注册BeanDefinition

在spring中除了使用beanName作为key将BeanDefinition放入Map中还做了其他一些事情，我们看下方法registerBeanDefinition代码，BeanDefinitionRegistry是一个接口，他有三个实现类，DefaultListableBeanFactory、SimpleBeanDefinitionRegistry、GenericApplicationContext，其中SimpleBeanDefinitionRegistry非常简单，而GenericApplicationContext最终也是使用的DefaultListableBeanFactory中的实现方法，我们看下代码：

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    BeanDefinition oldBeanDefinition;

    oldBeanDefinition = this.beanDefinitionMap.get(beanName);
    if (oldBeanDefinition != null) {
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                    "': There is already [" + oldBeanDefinition + "] bound.");
        }
        else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        oldBeanDefinition + "] with [" + beanDefinition + "]");
            }
        }
        else if (!beanDefinition.equals(oldBeanDefinition)) {
            if (this.logger.isInfoEnabled()) {
                this.logger.info("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + oldBeanDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + oldBeanDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    else {
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        }
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (oldBeanDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

分析上面代码我们简单总结下对于beanDefinition的注册的处理步骤：
（1）对AbstractBeanDefinition的校验，在解析XML文件的时候我们提过校验，但是此校验非彼校验，之前的校验是针对于XML格式的校验，而此时的校验是针对AbstractBeanDefinition的methodOverrides属性的。
（2）对beanName已经注册的情况的处理，如果设置了不允许bean的覆盖，则需要抛出异常，否陈直接覆盖
（3）加入map缓存
（4）清除解析之前留下的对应beanName的缓存

4. 通过别名注册BeanDefinition

通过别名注册BeanDefinition最终是在SimpleBeanDefinitionRegistry中实现的，我们看下代码：

public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    synchronized (this.aliasMap) {
        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);
            this.aliasMap.put(alias, name);
        }
    }
}

上述代码的流程总结如下：
（1）alias与beanName相同情况处理，若alias与beanName并名称相同则不需要处理并删除原有的alias
（2）alias覆盖处理。若aliasName已经使用并已经指向了另一beanName则需要用户的设置进行处理
（3）alias循环检查，当A->B存在时，若再次出现A->C->B时候则会抛出异常。

5. 注册完成后通知监听器Bean注册完成

这里写图片描述
从上图中我们看到在注册完bean后使用getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder))方法通知监听器bean注册完成。

6. alias标签的解析

对应bean标签的解析是最核心的功能，对于alias、import、beans标签的解析都是基于bean标签解析的，接下来我就分析下alias标签的解析。我们回到 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法，继续看下方法体，如下图所示：
这里写图片描述
对bean进行定义时，除了用id来 指定名称外，为了提供多个名称，可以使用alias标签来指定。而所有这些名称都指向同一个bean。在XML配置文件中，可用单独的元素来完成bean别名的定义。如配置文件中定义了一个javaBean: 

<bean id="demo" class="com.yhl.myspring.demo.bean.MyBeanDemo">
        <property name="beanName" value="bean demo1"/>
    </bean>

要给这个javaBean增加别名，以方便不同的对象来调用。我们可以直接使用bean标签中的name属性，如下：

    <bean id="demo" class="com.yhl.myspring.demo.bean.MyBeanDemo" name="demo1,demo2">
        <property name="beanName" value="bean demo1"/>
    </bean>

在Spring还有另外一种声明别名的方式：
我们具体看下alias标签的解析过程，解析使用的方法processAliasRegistration(ele)，方法体如下：

protected void processAliasRegistration(Element ele) {
    String name = ele.getAttribute(NAME_ATTRIBUTE);
    String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
    boolean valid = true;
    if (!StringUtils.hasText(name)) {
        getReaderContext().error("Name must not be empty", ele);
        valid = false;
    }
    if (!StringUtils.hasText(alias)) {
        getReaderContext().error("Alias must not be empty", ele);
        valid = false;
    }
    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));
    }
}

通过代码可以发现解析流程与bean中的alias解析大同小异，都是讲beanName与别名alias组成一对注册到registry中。跟踪代码最终使用了SimpleAliasRegistry中的registerAlias(String name, String alias)方法，方法体如下：

public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    synchronized (this.aliasMap) {
        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);
            this.aliasMap.put(alias, name);
        }
    }
}

7. import标签的解析

对于Spring配置文件的编写，经历过大型项目的人都知道，里面有太多的配置文件了。基本采用的方式都是分模块，分模块的方式很多，使用import就是其中一种，例如我们可以构造这样的Spring配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="demo" class="com.yhl.myspring.demo.bean.MyBeanDemo" name="demo1,demo2">
        <property name="beanName" value="bean demo1"/>
    </bean>
    <import resource="lookup-method.xml"/>
    <import resource="replaced-method.xml"/>
</beans>

applicationContext.xml文件中使用import方式导入有模块配置文件，以后若有新模块的加入，那就可以简单修改这个文件了。这样大大简化了配置后期维护的复杂度，并使配置模块化，易于管理。我们来看看Spring是如何解析import配置文件的呢。解析import标签使用的是importBeanDefinitionResource(ele)，进入方法体：

protected void importBeanDefinitionResource(Element ele) {
    //获取resource属性，如果不存在则不处理
    String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
    if (!StringUtils.hasText(location)) {
        getReaderContext().error("Resource location must not be empty", ele);
        return;
    }
    //解析系统属性，格式如：${user.dir}
    // Resolve system properties: e.g. "${user.dir}"
    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

    Set<Resource> actualResources = new LinkedHashSet<>(4);
    //判断location是绝对URL还是相对URI
    // Discover whether the location is an absolute or relative URI
    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*:"
    }
    //如果是绝对URL则根据地址直接加载文件
    // Absolute or relative?
    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);
        }
    }
    Resource[] actResArray = actualResources.toArray(new Resource[0]);
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

方法的流程总结如下：
（1）获取resource属性所表示的路径
（2）解析路径中的系统属性
（3）判断location是绝对路径还是相对路径
（4）如果是绝对路径则递归调用bean的解析过程，进行另一次解析
（5）如果是相对路径则计算出绝对路径进行解析
（6）通知监听器，解析完成

8. 嵌入式beans标签解析

对于嵌入式的beans,解析与单独配置文件的解析没有太大却别，无非是调用beans的解析过程

小潭渔
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring源码（4）之解析默认命名空间
weixin_33953384的博客
12-09 280
spring源码之解析默认命名空间 上篇博文讨论了spring解析配置文件applicationContext.xml的document对象的大致流程：大体分为默认命名空间和非默认命名空间的解析。默认命名空间为bean标签，alias标签和import标签，而非默认空间主要为aop标签 和管理事务的标签。 if(delegate.isDefaultNamespac...
七种 BeanDefinition，各显其能！
最新发布
LoveSummer
09-06 542
AbstractBeanDefinition 是一个抽象类，它根据 BeanDefinition 中定义的接口提供了相应的属性，并实现了 BeanDefinition 中定义的一部分方法。BeanDefinition 中原本只是定义了一系列的 get/set 方法，并没有提供对应的属性，在 AbstractBeanDefinition 中将所有的属性定义出来了。后面其他的实现类也基本上都是在 AbstractBeanDefinition 的基础上完成的。
Spring IOC源码笔记-BeanDefinition的加载与注册
chengpangba1883的博客
03-05 140
BeanDefinition的加载与注册 BeanDefinition的加载 在开篇中我们介绍过spring ioc容器管理bean主要分为两个步骤 第一：加载bean的配置文件，从而在内存中生成BeanDefinition对象，并将BeanDefinition对象在BeanDefi...
（四）BeanDefinition（上）
开心就好
07-30 6202
Spring官网阅读（四）BeanDefinition（上） 前面几篇文章已经学习了官网中的1.2,1.3,1.4三小结，主要是容器，Bean的实例化及Bean之间的依赖关系等。这篇文章，我们继续官网的学习，主要是BeanDefinition的相关知识，这是Spring中非常基础的一块内容，也是我们阅读源码的基石。本文主要涉及到官网中的1.3及1.5中的一些补充知识。同时为我们1.7小节中BeanDefinition的合并做一些铺垫 BeanDefinition是什么？ 我们先看官网上是怎么解释的：
Spring源码学习--Bean注入解析结果BeanDefinition
井底之蛙
06-22 3530
BeanDefinition描述了一个bean实例，拥有属性值、构造参数值和具体实现的其他信息，其是一个bean的元数据，xml中配置的bean元素会被解析成BeanDefinition对象。BeanDefinition的接口的结构类图：ChildBeanDefinition  可以让子Bean定义拥有从父母哪里继承配置的能力。相应的，子Bean定义有一个固定的依赖--他们的父bean定义。  一
SpringCloud源码深度解析
01-27
SpringCloud是目前广泛应用的微服务框架，其源码解析对于开发者深入理解微服务架构和优化实践至关重要。在SpringCloud中，Eureka作为注册中心，它的功能和工作机制是整个微服务架构的关键。 Eureka的主要职责是管理...
SpringSourceDeeplyAnalyze_HaoJia:Spring原始深度解析-赫佳
03-24
《SpringSourceDeeplyAnalyze_HaoJia》是由赫佳提供的深入分析Spring框架的资源，主要聚焦于Spring的源码解析，旨在帮助开发者更全面、深入地理解Spring的工作原理和设计思想。作为一款广泛应用于企业级Java开发的...
官方原版源码spring-framework-5.1.1.RELEASE.zip
10-16
《Spring Framework 5.1.1.RELEASE源码解析与深度探索》 Spring Framework作为Java领域最广泛应用的轻量级框架之一，其5.1.1.RELEASE版本的官方源码为我们提供了深入理解其工作原理的宝贵资源。本文将围绕Spring ...
狂神SpringBoot源码--分享
04-30
《狂神SpringBoot源码深度解析与实践》 SpringBoot是由Pivotal团队开发的一款用于简化Spring应用初始搭建以及开发过程的框架。它基于Spring框架，致力于“开箱即用”和“零配置”，旨在让开发者能快速创建稳定、...
spring-framework-5.0.8.RELEASE:Spring-5.0.8源码阅读-spring源码阅读
03-24
《Spring框架5.0.8源码深度解析》 Spring框架是Java开发中不可或缺的一部分，其5.0.8版本的发布为开发者提供了更稳定、更高效的服务。本篇文章将深入探讨Spring 5.0.8的核心特性，通过源码分析，揭示其背后的运行...
Spring 源码之 BeanDefinition阅读
灵小帝的博客
07-01 1万+
Spring容器启动的过程中，会将Bean解析成Spring内部的BeanDefinition结构
深入理解Spring系列之二：BeanDefinition解析
热门推荐
JavaQ
10-30 1万+
《深入理解Spring系列之一：开篇》中提到在Spring容器启动的过程中，会将Bean解析成Spring内部的BeanDefinition结构，本篇将深入分析这个BeanDefinition的内部结构。 直接看BeanDefinition源码， public interface BeanDefinition extends AttributeAccessor, BeanM
spring bean的生命周期回调和容器的生命周期
Resee_Z的博客
08-05 210
有关Spring的生命周期回调在官网https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-lifecycle有详细讲解。spring的生命周期回调分为Bean的生命周期回调和容器的生命周期回调。 1 Bean的生命周期回调 1.1 Bean的生命周期初始化回调 1.1.1 @PostConstruct注解 @Component @Scope(Configu
bean标签的解析及注册——BeanDefinitionHolder
JAVA圈的博客
06-08 3106
1、默认标签的解析在parseBeanDefinitions(root, this.delegate)，主要对import、alias、bean、beans进行不同的处理2、bean标签解析bean解析最为复杂2.1、解析通过BeanDefinitionParserDelegate的parseBeanDefinitionElement进行元素解析，并返回BeanDefinitionHolder，通...
BeanDefinition相关类
RainSun
06-07 942
方法
spring的BeanDefinition学习总结
weixin_38068301的博客
10-28 268
1.BeanDefinition类结构图及属性图如下 1.1 类关系图 ...
《spring设计思想》8-BeanDefinition中的beanClass从String转换为Class
David_lou的专栏
06-26 1062
上一节梳理了一下BeanDefinition的合并过程，而且讲到BeanDefinition中的基本属性 @Nullable private volatile Object beanClass; beanClass属性描述的是Bean的类型，而且很特殊的设置为Object类型，java中万物皆是对象，但是我们在读取xml或者propeties时，赋值的是什么类型呢，断点调试发现是Sting类型的对象， 但是在执行过getBean方法之后，会调用上一节的mergeBeanDefinition
4.2 spring-import 标签的解析;
weixin_34387284的博客
04-07 59
　　对于spring配置文件的编写，我想，对于经历过庞大项目的人，都有那种恐惧的心理，太多的配置文件。不过，分模块都是大多数人能想到的方法，但是，怎么分模块，那就是仁者见仁，智者见智了。我的策略是使用import。基本代码格式如下 web.xml &lt;?xml version="1.0" encoding="gb2312"?&gt; &lt;!DOCTYPE beans PUBLIC ...
Spring源码解析（一）
Starrk的盗梦空间
04-04 635
Spring spring是一个装载bean，调度bean的容器 （一）spring的xml加载 这部分是spring载入了resource中的xml配置，并使用了对应的解析器，然后开始进行默认部分标签解析部分的源码。 简单说一下xml，个人理解为一种通过标签格式化表示结构层次的方式，有两种格式，DTD和XSD，不深究，区分很好区分 这种头TM是DTD &lt;!DOCTY...
Spring源码深度解析：BeanDefinition与自定义注解
在深入学习Spring框架源码的过程中，"Spring源码学习"这一主题主要关注Spring IoC容器内部的核心机制，特别是BeanDefinition（Bean定义）的概念和处理流程。BeanDefinition是Spring用来描述和配置Bean的关键结构，它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值