org.springframework.beans.factory.xml

## 类 AbstractBeanDefinitionParser

- java.lang.Object
- - org.springframework.beans.factory.xml.AbstractBeanDefinitionParser

- 所有已实现的接口:
    BeanDefinitionParser
  直接已知子类:
    AbstractSingleBeanDefinitionParser

      public abstract class AbstractBeanDefinitionParser
      extends Object
      implements BeanDefinitionParser

  Abstract `BeanDefinitionParser` implementation providing a number of convenience methods and a `template method` that subclasses must override to provide the actual parsing logic.

  Use this `BeanDefinitionParser` implementation when you want to parse some arbitrarily complex XML into one or more `BeanDefinitions`. If you just want to parse some XML into a single `BeanDefinition`, you may wish to consider the simpler convenience extensions of this class, namely `AbstractSingleBeanDefinitionParser` and `AbstractSimpleBeanDefinitionParser`.

  从以下版本开始:
    2.0
  作者:
    Rob Harrop, Juergen Hoeller, Rick Evans, Dave Syer

- - ### 字段概要

    字段
    限定符和类型 | 字段和说明
    --- | ---
    `static String` | `ID_ATTRIBUTE` Constant for the "id" attribute
    `static String` | `NAME_ATTRIBUTE` Constant for the "name" attribute

  - ### 构造器概要

    构造器
    构造器和说明
    `AbstractBeanDefinitionParser()`

  - ### 方法概要

    所有方法 实例方法 抽象方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `BeanDefinition` | `parse(Element element, ParserContext parserContext)` Parse the specified `Element` and register the resulting `BeanDefinition(s)` with the `BeanDefinitionRegistry` embedded in the supplied `ParserContext`.
    `protected abstract AbstractBeanDefinition` | `parseInternal(Element element, ParserContext parserContext)` Central template method to actually parse the supplied `Element` into one or more `BeanDefinitions`.
    `protected void` | `postProcessComponentDefinition(BeanComponentDefinition componentDefinition)` Hook method called after the primary parsing of a `BeanComponentDefinition` but before the `BeanComponentDefinition` has been registered with a `BeanDefinitionRegistry`.
    `protected void` | `registerBeanDefinition(BeanDefinitionHolder definition, BeanDefinitionRegistry registry)` Register the supplied `bean` with the supplied `registry`.
    `protected String` | `resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext)` Resolve the ID for the supplied `BeanDefinition`.
    `protected boolean` | `shouldFireEvents()` Determine whether this parser is supposed to fire a `BeanComponentDefinition` event after parsing the bean definition.
    `protected boolean` | `shouldGenerateId()` Should an ID be generated instead of read from the passed in `Element`?
    `protected boolean` | `shouldGenerateIdAsFallback()` Should an ID be generated instead if the passed in `Element` does not specify an "id" attribute explicitly?
    `protected boolean` | `shouldParseNameAsAliases()` Determine whether the element's "name" attribute should get parsed as bean definition aliases, i.e. alternative bean definition names.

    - ### 从类继承的方法 java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### 字段详细资料

    - #### ID_ATTRIBUTE

          public static final String ID_ATTRIBUTE

      Constant for the "id" attribute
      另请参阅:
        常量字段值

    - #### NAME_ATTRIBUTE

          public static final String NAME_ATTRIBUTE

      Constant for the "name" attribute
      另请参阅:
        常量字段值

  - ### 构造器详细资料

    - #### AbstractBeanDefinitionParser

          public AbstractBeanDefinitionParser()

  - ### 方法详细资料

    - #### parse

          @Nullable
          public final BeanDefinition parse(Element element,
                                                       ParserContext parserContext)

      从接口复制的说明: `BeanDefinitionParser`
      Parse the specified `Element` and register the resulting `BeanDefinition(s)` with the `BeanDefinitionRegistry` embedded in the supplied `ParserContext`.

      Implementations must return the primary `BeanDefinition` that results from the parse if they will ever be used in a nested fashion (for example as an inner tag in a `<property/>` tag). Implementations may return `null` if they will not be used in a nested fashion.

      指定者:
        `parse` 在接口中 `BeanDefinitionParser`
      参数:
        `element` - the element that is to be parsed into one or more `BeanDefinitions`
        `parserContext` - the object encapsulating the current state of the parsing process; provides access to a `BeanDefinitionRegistry`
      返回:
        the primary `BeanDefinition`

    - #### resolveId

          protected String resolveId(Element element,
                                     AbstractBeanDefinition definition,
                                     ParserContext parserContext)
                              throws BeanDefinitionStoreException

      Resolve the ID for the supplied `BeanDefinition`.

      When using `generation`, a name is generated automatically. Otherwise, the ID is extracted from the "id" attribute, potentially with a `fallback` to a generated id.

      参数:
        `element` - the element that the bean definition has been built from
        `definition` - the bean definition to be registered
        `parserContext` - the object encapsulating the current state of the parsing process; provides access to a `BeanDefinitionRegistry`
      返回:
        the resolved id
      抛出:
        `BeanDefinitionStoreException` - if no unique name could be generated for the given bean definition

    - #### registerBeanDefinition

          protected void registerBeanDefinition(BeanDefinitionHolder definition,
                                                BeanDefinitionRegistry registry)

      Register the supplied `bean` with the supplied `registry`.

      Subclasses can override this method to control whether or not the supplied `bean` is actually even registered, or to register even more beans.

      The default implementation registers the supplied `bean` with the supplied `registry` only if the `isNested` parameter is `false`, because one typically does not want inner beans to be registered as top level beans.

      参数:
        `definition` - the bean definition to be registered
        `registry` - the registry that the bean is to be registered with
      另请参阅:
        `BeanDefinitionReaderUtils.registerBeanDefinition(BeanDefinitionHolder, BeanDefinitionRegistry)`

    - #### parseInternal

          @Nullable
          protected abstract AbstractBeanDefinition parseInternal(Element element,
                                                                             ParserContext parserContext)

      Central template method to actually parse the supplied `Element` into one or more `BeanDefinitions`.
      参数:
        `element` - the element that is to be parsed into one or more `BeanDefinitions`
        `parserContext` - the object encapsulating the current state of the parsing process; provides access to a `BeanDefinitionRegistry`
      返回:
        the primary `BeanDefinition` resulting from the parsing of the supplied `Element`
      另请参阅:
        `parse(org.w3c.dom.Element, ParserContext)`, `postProcessComponentDefinition(org.springframework.beans.factory.parsing.BeanComponentDefinition)`

    - #### shouldGenerateId

          protected boolean shouldGenerateId()

      Should an ID be generated instead of read from the passed in `Element`?

      Disabled by default; subclasses can override this to enable ID generation. Note that this flag is about always generating an ID; the parser won't even check for an "id" attribute in this case.

      返回:
        whether the parser should always generate an id

    - #### shouldGenerateIdAsFallback

          protected boolean shouldGenerateIdAsFallback()

      Should an ID be generated instead if the passed in `Element` does not specify an "id" attribute explicitly?

      Disabled by default; subclasses can override this to enable ID generation as fallback: The parser will first check for an "id" attribute in this case, only falling back to a generated ID if no value was specified.

      返回:
        whether the parser should generate an id if no id was specified

    - #### shouldParseNameAsAliases

          protected boolean shouldParseNameAsAliases()

      Determine whether the element's "name" attribute should get parsed as bean definition aliases, i.e. alternative bean definition names.

      The default implementation returns `true`.

      返回:
        whether the parser should evaluate the "name" attribute as aliases
      从以下版本开始:
        4.1.5

    - #### shouldFireEvents

          protected boolean shouldFireEvents()

      Determine whether this parser is supposed to fire a `BeanComponentDefinition` event after parsing the bean definition.

      This implementation returns `true` by default; that is, an event will be fired when a bean definition has been completely parsed. Override this to return `false` in order to suppress the event.

      返回:
        `true` in order to fire a component registration event after parsing the bean definition; `false` to suppress the event
      另请参阅:
        `postProcessComponentDefinition(org.springframework.beans.factory.parsing.BeanComponentDefinition)`, `ReaderContext.fireComponentRegistered(org.springframework.beans.factory.parsing.ComponentDefinition)`

    - #### postProcessComponentDefinition

          protected void postProcessComponentDefinition(BeanComponentDefinition componentDefinition)

      Hook method called after the primary parsing of a `BeanComponentDefinition` but before the `BeanComponentDefinition` has been registered with a `BeanDefinitionRegistry`.

      Derived classes can override this method to supply any custom logic that is to be executed after all the parsing is finished.

      The default implementation is a no-op.

      参数:
        `componentDefinition` - the `BeanComponentDefinition` that is to be processed