SPRING FRAMEWORK(1) BEANDEFINITION REGISTRATION

快来打我* 2022-05-31 23:25 145阅读 0赞

Spring的简单性、可测试性和松耦合都是其可以成为主流框架的基础。  
![这里写图片描述][SouthEast]  
spring框架是一个分层架构，它包含一系列的功能要素，并被分为大约20个模块，如上图所示。  
见名知意，我所说的见名知意并不是说看见名字你就能够了解它的本质，但是基本的含义却是能够看懂的。下面我将对这些模块进行简单的叙述。  
（1）Core Container(核心容器):包含了spring-core 、spring-beans、spring-context、spring-el。其中的core和beans是框架的基础部份。core模块主要包含Spring框架基本的核心工具类，spring的其他组件都要用到这个包里的类，以后你也可以在自己的应用系统中使用这些工具类。beans模块是所有应用都要用到的，包含了访问配置文件，创建和管理bean以及进行Inversion of Control（IoC）/Dependency Injection（DI）操作相关的所有类。beans的基础概念是BeanFactory。context模块构建于core和beans模块基础之上  
，提供了一种类似于JDNI注册器的框架式的对象访问方法，ApplicationContext接口是Context模块的关键。el模块提供了一个强大的表达式语言用于在运行时查询和操作对象。  
（2）Data Access/Integration：在这个模块中包含有JDBC、ORM、OXM、JMS和Transactions模块，这一部分功能是进行数据库操作的。JDBC模块提供了一个JDBC的抽象层，他可以消除冗长的JDBC编码和解析数据库厂商特有的错误代码。这个模块包含了Spring对JDBC数据访问进行封装的所有类。ORM（Object Relation Mapper对象关系映射）模块在Hibernate，iBatis（MyBatis）等，提供了一个交互层，利用ORM封装包，可以混合使用所有Spring提供的特性进行O/R映射。OXM模块提供了一个对Object/XML映射实现的抽象层。JMS模块主要包含了一些制造消费信息的特性。Transactions模块支持编码和声明性的事务管理，这些事物类必须实现特定的接口，并且对所有的POJO（简单的java对象）都适用。  
（3）Web：简单理解SpringMVC。  
（4）AOP：AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现，它可以让你定义例如方法拦截器和切点，从而将代码分开，降低他们之间的耦合性。Aspects模块：提供了对AspectJ的集成支持。Instrumentation模块：提供了class instrumentation支持和classloader实现，使得可以在特定的应用服务器上使用。  
（5）test:Test模块支持使用JUnit和TestNG对Spring组件进行测试。

# 重要类介绍： #

## DefaultListableBeanFactory ##

![这里写图片描述][SouthEast 1]  
DefaultListableBeanFactory是整个bean加载的核心部分，是Spring注册及加载bean的默认实现，DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory并实现了ConfigURableListableBeanFactory以及BeanDefinitionRegistry接口。

### BeanDefinitionRegistry ###

定义对BeanDefinition的各种增删改操作

public interface BeanDefinitionRegistry extends AliasRegistry { 
        void registerBeanDefinition(String var1, BeanDefinition var2);
        void removeBeanDefinition(String var1) throws NoSuchBeanDefinitionException;
        BeanDefinition getBeanDefinition(String var1) throws NoSuchBeanDefinitionException;
        boolean containsBeanDefinition(String var1);

### BeanFactory ###

定义获取bean及bean的各种属性

public interface BeanFactory { 
        String FACTORY_BEAN_PREFIX = "&";
        <T> T getBean(Class<T> var1) throws BeansException;
        boolean containsBean(String var1);
        boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
        boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
        Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
        String[] getAliases(String var1);
    }

### DefaultSingletonBeanRegistry ###

对接口SingletonBeanRegistry各函数的实现

public interface SingletonBeanRegistry {
        void registerSingleton(String var1, Object var2);
        Object getSingleton(String var1);
        boolean containsSingleton(String var1);

### FactoryBeanRegistrySupport ###

在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理功能

### AutowireCapableBeanFactory ###

提供创建bean、自动注入、初始化以及应用bean的后处理器

public interface AutowireCapableBeanFactory extends BeanFactory { 
        <T> T createBean(Class<T> var1) throws BeansException;
        void autowireBean(Object var1) throws BeansException;
        Object configureBean(Object var1, String var2) throws BeansException;
        void autowireBeanProperties(Object var1, int var2, boolean var3) throws BeansException;
        Object initializeBean(Object var1, String var2) throws BeansException;
        void destroyBean(Object var1);
        Object resolveDependency(DependencyDescriptor var1, String var2) throws BeansException;
    }

### AbstractAutowireCapableBeanFactory ###

综合AbstractBeanFactory并对接口AutowireCapableBeanFactory进行实现

## XmlBeanDefinitionReader ##

XmlBeanDefinitionReader对资源文件读取、解析及注册  
![这里写图片描述][SouthEast 2]  
通过类路径加载xml文件，转换为beanDefinition。  
细节：  
\- (1)通过继承自AbstractBeanDefinitionReader中的方法，来使用ResourceLoader将资源文件路径转换为对应的Resource文件  
\- (2)通过DocumentLoader对Resource文件进行转换，将Resource文件转换为Document文件  
\- (3)通过实现接口BeanDefinitionDocumentReader的DefaultBeanDefinitionDocumentReader类对Document进行解析，并使用BeanDefinitionParserDelegate对Element进行解析。

protected void doRegisterBeanDefinitions(Element root) {
            this.preProcessXml(root);
            this.parseBeanDefinitions(root, this.delegate);
            this.postProcessXml(root);
            this.delegate = parent;
    }
    
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
            if (delegate.isDefaultNamespace(root)) {
                parseDefaultElement(ele, delegate);
            }else {
                delegate.parseCustomElement(ele);
            }       
    }
    
    //默认标签的解析
    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
            //解析各种标签
            if (delegate.nodeNameEquals(ele, "import")) { 
                this.importBeanDefinitionResource(ele);
            } else if (delegate.nodeNameEquals(ele, "alias")) {
                this.processAliasRegistration(ele);
            } else if (delegate.nodeNameEquals(ele, "bean")) {
                this.processBeanDefinition(ele, delegate); //1
            } else if (delegate.nodeNameEquals(ele, "beans")) {
                this.doRegisterBeanDefinitions(ele);//2
            }
    }
    //自定义标签解析
    public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
            String namespaceUri = getNamespaceURI(ele);
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if (handler == null) return null;
            return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    }

### BeanDefinition ###

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { 
        void setParentName(String parentName);
        void setBeanClassName(String beanClassName);
        void setScope(String scope);
        void setLazyInit(boolean lazyInit);
        void setDependsOn(String... dependsOn);
        //是否被设置为被自动注入
        void setAutowireCandidate(boolean autowireCandidate);
        //是否为首选bean
        void setPrimary(boolean primary);
        //factoryBean name
        void setFactoryBeanName(String factoryBeanName);
        ConstructorArgumentValues getConstructorArgumentValues();
        MutablePropertyValues getPropertyValues();
        boolean isSingleton();
        boolean isPrototype();
        boolean isAbstract();
        String getDescription();
        /** * Return the originating BeanDefinition, or {@code null} if none. */
        BeanDefinition getOriginatingBeanDefinition();
    
    }

*  BeanDefinition是一个接口，在Spring中存在三种实现：RootBeanDefinition、ChildBeanDefinition以及GenericBeanDefinition。三种实现均继承了AbstractBeanDefinition，其中BeanDefinition是配置文件元素标签在容器中的内部表示形式。元素标签拥有class、scope、lazy-init等配置属性，BeanDefinition则提供了相应的beanClass、scope、lazyInit属性，BeanDefinition和中的属性是一一对应的。其中RootBeanDefinition是最常用的实现类，它对应一般性的元素标签。
 *  在配置文件中可以定义父和子，父用RootBeanDefinition表示，而子用ChildBeanDefinition表示，而没有父的就使用RootBeanDefinition表示，AbstractBeanDefinition对两者共同的类信息进行抽象
 *  Spring通过BeanDefinition将配置文件中的配置信息转换为容器的内部表示，并将这些BeanDefinition注册到BeanDefinitionRegistry中。Spring容器中的BeanDefinitionRegistry就像是Spring配置信息的内存数据库，主要是以map的形式保存，后续操作直接从BeanDefinitionRegistry中读取配置信息，它们之间的关系如图所示

![这里写图片描述][SouthEast 3]

### BeanDefinitionHolder ###

public class BeanDefinitionHolder implements BeanMetadataElement { 
        private final BeanDefinition beanDefinition;
        private final String beanName;
        private final String[] aliases;

### 默认标签的解析 ###

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //首先委托BeanDefinitionDelegate类的parseBeanDefinitionElement方法进行元素解析，返回BeanDefinitionHolder类型的实例bdHolder，经过这个方法后，bdHolder实例已经包含我们配置文件中配置的各种属性了，例如class、name、id、alias之类的属性
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if(bdHolder != null) {
        //当返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对元素内的自定义子元素进行解析
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        //解析完成后，对解析后bdHolder进行注册，其实就是一个hashmap 
        BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
        //最后发出响应事件，通知相关的监听器，这个bean已经加载完成
        this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    
    }
    
    public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
         String className = ele.getAttribute("class").trim();
         String  ex = ele.getAttribute("parent");
         //创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition
         AbstractBeanDefinition bd = this.createBeanDefinition(className, ex);
         //**硬编码解析默认bean的各种属性**
         this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
         //提取description
         bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));
         //解析元数据
         this.parseMetaElements(ele, bd);
         //解析lookup-method属性
         this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
         //解析replaced-method属性
         this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
         //解析构造函数参数
         this.parseConstructorArgElements(ele, bd);
         //解析property子元素
         this.parsePropertyElements(ele, bd);
         //解析qualifier子元素
         this.parseQualifierElements(ele, bd);
         bd.setResource(this.readerContext.getResource());
         bd.setSource(this.extractSource(ele));
         return bd;
    }
    
    //**硬编码解析默认bean的各种属性**
    public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, BeanDefinition containingBean, AbstractBeanDefinition bd) {
        //解析scope属性
        if(ele.hasAttribute("scope")) {
        //解析singleton属性
        } else if(ele.hasAttribute("singleton")) {
        } else if(containingBean != null) {
            //在嵌入BeanDefinition情况下且没有单独指定scope属性则使用父类默认的属性
            bd.setScope(containingBean.getScope());
        }
        //解析abstract属性
        if(ele.hasAttribute("abstract")) {}
        //解析lazy-init属性
        String lazyInit = ele.getAttribute("lazy-init");
        //若没有设置或设置成其他字符都被会设置为false
        bd.setLazyInit("true".equals(lazyInit));
        //解析autowire属性
        String autowire = ele.getAttribute("autowire");
        bd.setAutowireMode(this.getAutowireMode(autowire));
        //解析dependency-check属性
        String dependencyCheck = ele.getAttribute("dependency-check");
        bd.setDependencyCheck(this.getDependencyCheck(dependencyCheck));
        String autowireCandidate;
        //解析depends-on属性
        if(ele.hasAttribute("depends-on")) {}
        //解析autowire-candidate
        autowireCandidate = ele.getAttribute("autowire-candidate");
        //解析primary属性
        if(ele.hasAttribute("primary")) {}
        //解析init-method属性
        if(ele.hasAttribute("init-method")) {} 
        //解析destroy-method属性
        if(ele.hasAttribute("destroy-method")) {}
        //解析factory-method属性
        if(ele.hasAttribute("factory-method")) {}
        //解析factory-bean属性
        if(ele.hasAttribute("factory-bean")) {}
        return bd;
    }
    
    public static AbstractBeanDefinition createBeanDefinition(String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
        GenericBeanDefinition bd = new GenericBeanDefinition();
        //parentName可能为空
        bd.setParentName(parentName);
        if(className != null) {
            if(classLoader != null) {
               //如果ClassLoader不为空，则使用以传入ClassLoader同一虚拟机加载类对象，否则只是记录className
                bd.setBeanClass(ClassUtils.forName(className, classLoader));
            } else {
                bd.setBeanClassName(className);
            }
        }
        return bd;
    }

### 默认标签内的自定义元素进行解析 ###

当Spring中的bean使用的是默认标签配置，但是其中的子元素却使用了自定义的配置时，这句代码就会起作用，如下场景:

if (bdHolder != null) {
          //对自定义的标签进行修饰
          bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    }
    
    public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {
        BeanDefinitionHolder finalDefinition = definitionHolder;
        NamedNodeMap attributes = ele.getAttributes();
        //遍历所有的属性，看看是否有需要自定义解析的属性
        for(int children = 0; children < attributes.getLength(); ++children) {
            Node i = attributes.item(children);
            finalDefinition = this.decorateIfRequired(i, finalDefinition, containingBd);
        }
        NodeList var9 = ele.getChildNodes();
        //遍历所有的子节点，看看是否有适用于修饰的子元素
        for(int var10 = 0; var10 < var9.getLength(); ++var10) {
            Node node = var9.item(var10);
            if(node.getNodeType() == 1) {
                finalDefinition = this.decorateIfRequired(node, finalDefinition, containingBd);
            }
        }
        return finalDefinition;
    }
    
    private BeanDefinitionHolder decorateIfRequired(Node node, BeanDefinitionHolder originalDef, BeanDefinition containingBd) {
        //获取自定义标签的命名空间
        String namespaceUri = this.getNamespaceURI(node);
        //对于非默认标签进行修饰
        if(!this.isDefaultNamespace(namespaceUri)) {
            //根据命名空间找到对应的处理器
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if(handler != null) {
                //进行修饰
                return handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
            }
        }
        return originalDef;
    }

*  程序首先获取属性或者子元素的命名空间，以此来判断该元素或者属性是否适用于自定义标签的解析条件，找出自定义类型所对应的NamespaceHandler并进行进一步解析,  
    这个NamespaceHandler在很多第三方jar中有实现，也是为第三方bean被spring管理的关键。
 *  在decorateBeanDefinitionIfRequired中对于程序默认的标签的处理其实是直接略过的，默认的标签到这里已经被处理完了，这里只对自定义的标签进行处理

### 注册BeanDefinition ###

//解析完成后，对解析后bdHolder进行注册，其实就是一个hashmap 
        BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());

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) {
           ...

从上面的代码可以看出，解析的BeanDefinition都会被注册到BeanDefinitionRegistry类型的实例registry中，而对于BeanDefinition的注册分成了两部分：通过beanName的注册以及通过别名的注册,这里的register就是DefaultListableBeanFactory。

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
             ...
            //注册BeanDefinition
            this.beanDefinitionMap.put(beanName, beanDefinition);
            //重置所有beanName对应的缓存
            this.resetBeanDefinition(beanName);
        }
    }

### import标签的解析 ###

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE beans PUBLIC "-//Spring//DTD BEAN//EN" "http://www.Springframework.org/dtd/Spring-beans.dtd">
        <import resource="customerContext.xml" />
        <import resource="systemContext.xml" />
        ...
    
    </beans>

使用import的方式导入有模块配置文件，以后若有新模块的加入，可以简单修改这个文件，这样大大简化了配置后期维护的复杂度，并使配置模块化，易于管理

### beans标签的解析 ###

解析xmlns ，xsi的命名空间  
解析bean

## 自定义标签的解析 ##

doRegisterBeanDefinitions(){
        this.preProcessXml(root);
        this.parseBeanDefinitions(root, this.delegate);
        this.postProcessXml(root);
        this.delegate = parent;
     }
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
            if (delegate.isDefaultNamespace(root)) {
                parseDefaultElement(ele, delegate);
            }else {
                delegate.parseCustomElement(ele);
            }   
        }

### 自定义标签的使用 ###

Spring提供了可扩展Schema的支持，扩展Spring自定义标签配置大致需要以下几个步骤：

*  创建一个普通的POJO
 *  定义一个XSD文件描述组件内容
 *  创建一个类，实现BeanDefinitionParser接口，用来解析XSD文件中的定义和组件定义
 *  创建一个Handler类，扩展自NamespaceHandlerSupport，目的是将组件注册到Spring容器
 *  编写Spring.handlers和Spring.schemas文件，放在工程的/META-INF/文件夹下  
    自定义的配置就结束了，而Spring加载自定义的大致流程是遇到自定义标签后就去Spring.handlers和Spring.schemas中去找对应的handler和XSD，默认位置是/META-INF/下，进而有找到对应的handler以及解析元素的Parser，从而完成了整个自定义元素的解析，也就是说自定义与Spring中默认的标准配置不同在于Spring将自定义标签解析的工作委托给了用户去实现。  
    –>在后续的dubbo的spi中有更多的讲解。  
    使用：

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        //获取对应的命名空间
        String namespaceUri = this.getNamespaceURI(ele);
        //根据命名空间找到对应的NamespaceHandler
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if(handler == null) {
            this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        } else {
            //调用自定义的NamespaceHandler进行解析
            return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
        }
    }

Spring会根据在Spring.handlers文件中配置的命名空间与命名空间处理器的映射关系找到匹配的处理器，而寻找匹配的处理器就是在上面函数中实现的，当获取到自定义的NamespaceHandler之后就可以进行处理器初始化并解析了。

当得到自定义命名空间处理后会马上执行namespaceHandler.init()来进行自定义BeanDefinitionParser的注册：

public class MyNamespaceHandler extends NamespaceHandlerSupport { 
        public void init(){
            registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
        }
    }

注册后，命名空间处理器就可以根据标签的不同来调用不同的解析器进行解析

### 标签解析 ###

得到了解析器以及要分析的元素后，Spring就可以将解析工作委托给自定义解析器去解析，parse方法是在父类NamespaceHandlerSupport中实现的，代码如下:

public BeanDefinition parse(Element element, ParserContext parserContext) {
        return this.findParserForElement(element, parserContext).parse(element, parserContext);
    }
    
    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
        //获取元素名称，也就是<myname:user中的user，若在示例中，此时localName为user
        String localName = parserContext.getDelegate().getLocalName(element);
        //根据user找到对应的解析器，也就是在registerBeanDefinitionParser("user", new UserBeanDefinitionParser());注册的解析器
        BeanDefinitionParser parser = (BeanDefinitionParser)this.parsers.get(localName);
        if(parser == null) {
            parserContext.getReaderContext().fatal("Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
        }
        return parser;
    }

parse方法的处理,在AbstractBeanDefinitionParser定义：

public final BeanDefinition parse(Element element, ParserContext parserContext) {
        AbstractBeanDefinition definition = this.parseInternal(element, parserContext);
        if(definition != null && !parserContext.isNested()) {
            try {
                String ex = this.resolveId(element, definition, parserContext);
                if(!StringUtils.hasText(ex)) {
                    parserContext.getReaderContext().error("Id is required for element \'" + parserContext.getDelegate().getLocalName(element) + "\' when used as a top-level tag", element);
                }
    
                String[] aliases = new String[0];
                String name = element.getAttribute("name");
                if(StringUtils.hasLength(name)) {
                    aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
                }
                //将AbstractBeanDefinition转换为BeanDefinitionHolder并注册
                BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, ex, aliases);
                this.registerBeanDefinition(holder, parserContext.getRegistry());
                if(this.shouldFireEvents()) {
                    //需要通知监听器进行处理
                    BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
                    this.postProcessComponentDefinition(componentDefinition);
                    parserContext.registerComponent(componentDefinition);
                }
            } catch (BeanDefinitionStoreException var9) {
                parserContext.getReaderContext().error(var9.getMessage(), element);
                return null;
            }
        }
    
        return definition;
    }

在这个函数中大部分的代码是用来处理将解析后的AbstractBeanDefinition转化为BeanDefinitionHolder并注册的功能，而真正去做解析的事情委托给了函数parseInternal，正是这句代码调用了我们自定义的解析函数

public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser { 
        //Element对应的类
        protected class getBeanClass(Element element){ 
            return User.class;
        }
        //从element中解析并提取对应的元素
        protected void doParse(Element element, BeanDefinitionBuilder bean){
            String userName = element.getAttribute("userName");
            String email = element.getAttribute("email");
            //将提取的数据放入到BeanDefinitionBuilder中，待到完成所有bean的解析后统一注册到BeanFactory中
            if(StringUtils.hasText(userName)){
                bean.addPropertyValue("userName", userName);
            }
            if(StringUtils.hasText(email)){
                bean.addPropertyValue("email", email);
            }
        }
    }

在parseInternal中并不是直接调用自定义的doParse函数，而是进行了一系列的数据准备，包括对beanClass、scope、lazyInit等属性的准备,  
在AbstractSingleBeanDefinitionParser中：

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
        String parentName = this.getParentName(element);
        if(parentName != null) {
            builder.getRawBeanDefinition().setParentName(parentName);
        }
        //获取自定义标签中的class，此时会调用自定义解析器如UserBeanDefinitionParser中的getBeanClass方法
        Class beanClass = this.getBeanClass(element);
        if(beanClass != null) {
            builder.getRawBeanDefinition().setBeanClass(beanClass);
        } else {
            //若子类没有重写getBeanClass方法则尝试检查子类是否重写getBeanClassName方法
            String beanClassName = this.getBeanClassName(element);
            if(beanClassName != null) {
               builder.getRawBeanDefinition().setBeanClassName(beanClassName);
            }
        }
     builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
        if(parserContext.isNested()) {
            //若存在父类则使用父类的scope属性 builder.setScope(parserContext.getContainingBeanDefinition().getScope());
        }
        if(parserContext.isDefaultLazyInit()) {
            //配置延迟加载
            builder.setLazyInit(true);
        }
    
        //调用子类重写的doParse方法进行解析
        this.doParse(element, parserContext, builder);
        return builder.getBeanDefinition();
    }

自定义标签的处理过程同样是按照Spring中默认标签的处理方式进行，包括创建BeanDefinition以及进行相应默认属性的设置，对于这些工作Spring都默默地帮我们实现了，只是暴露出一些接口来供用户实现个性化的业务。

[SouthEast]: /images/20220601/252566f797294bc5b2d0ea245a29b270.png
[SouthEast 1]: /images/20220601/313482454db54efbb9df077ead33d809.png
[SouthEast 2]: /images/20220601/c96d6ac7c8dc437fa0a0d2352eed453e.png
[SouthEast 3]: /images/20220601/7919e39f7ced4818a7e0c372a83c4765.png