Package 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
Modifier and Type
Field
Description
`static final String`
`ID_ATTRIBUTE`
Constant for the "id" attribute.
`static final String`
`NAME_ATTRIBUTE`
Constant for the "name" attribute.

## Constructor Summary

Constructors
Constructor
Description
`AbstractBeanDefinitionParser()`

## Method Summary

Modifier and Type
Method
Description
`final 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.

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

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

## Field Details

### 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 Details

### AbstractBeanDefinitionParser

public AbstractBeanDefinitionParser()

## Method Details

### parse

@Nullable 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 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

@Nullable 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

### 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`.

Returns:
  whether the parser should evaluate the "name" attribute as aliases
Since:
  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.

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