org.springframework.beans.factory.xml

## Class AbstractBeanDefinitionParser

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

All Implemented Interfaces:
  BeanDefinitionParser

Direct Known Subclasses:
  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`.

Since:
  2.0
Author:
  Rob Harrop, Juergen Hoeller, Rick Evans, Dave Syer

### Field Summary

Fields
`static String` `ID_ATTRIBUTE` Constant for the id attribute
`static String` `NAME_ATTRIBUTE` Constant for the name attribute

### Constructor Summary

Constructors
Constructor and Description
`AbstractBeanDefinitionParser()`

### Method Summary

Methods
`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()` Controls 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?

### Methods inherited from class java.lang.Object

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

### Field Detail

#### ID_ATTRIBUTE

    public static final String ID_ATTRIBUTE

Constant for the id attribute

See Also:
  Constant Field Values

#### NAME_ATTRIBUTE

    public static final String NAME_ATTRIBUTE

Constant for the name attribute

See Also:
  Constant Field Values

### Constructor Detail

#### AbstractBeanDefinitionParser

    public AbstractBeanDefinitionParser()

### Method Detail

#### parse

    public final BeanDefinition parse(Element element,
                       ParserContext parserContext)

Description copied from interface: `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.

Specified by:
  `parse` in interface `BeanDefinitionParser`
Parameters:
  `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`
Returns:
  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.

Parameters:
  `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`
Returns:
  the resolved id
Throws:
  `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.

Parameters:
  `definition` - the bean definition to be registered
  `registry` - the registry that the bean is to be registered with
See Also:
  `BeanDefinitionReaderUtils.registerBeanDefinition(BeanDefinitionHolder, BeanDefinitionRegistry)`

#### parseInternal

    protected abstract AbstractBeanDefinition parseInternal(Element element,
                                       ParserContext parserContext)

Central template method to actually parse the supplied `Element` into one or more `BeanDefinitions`.

Parameters:
  `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`
Returns:
  the primary `BeanDefinition` resulting from the parsing of the supplied `Element`
See Also:
  `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.

Returns:
  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.

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

#### shouldFireEvents

    protected boolean shouldFireEvents()

Controls 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.

Returns:
  `true` in order to fire a component registration event after parsing the bean definition; `false` to suppress the event
See Also:
  `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.

Parameters:
  `componentDefinition` - the `BeanComponentDefinition` that is to be processed