java.lang.Object | |||
↳ | org.springframework.beans.factory.xml.AbstractBeanDefinitionParser | ||
↳ | org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser | ||
↳ | org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser |
Convenient base class for when there exists a one-to-one mapping between attribute names on the element that is to be parsed and the property names on the Class being configured.
Extend this parser class when you want to create a single
bean definition from a relatively simple custom XML element. The
resulting BeanDefinition
will be automatically
registered with the relevant
BeanDefinitionRegistry
.
An example will hopefully make the use of this particular parser class immediately clear. Consider the following class definition:
public class SimpleCache implements Cache { public void setName(String name) {...} public void setTimeout(int timeout) {...} public void setEvictionPolicy(EvictionPolicy policy) {...} // remaining class definition elided for clarity... }
Then let us assume the following XML tag has been defined to permit the easy configuration of instances of the above class;
<caching:cache name="..." timeout="..." eviction-policy="..."/>
All that is required of the Java developer tasked with writing
the parser to parse the above XML tag into an actual
SimpleCache
bean definition is the following:
public class SimpleCacheBeanDefinitionParser extends AbstractSimpleBeanDefinitionParser { protected Class getBeanClass(Element element) { return SimpleCache.class; } }
Please note that the AbstractSimpleBeanDefinitionParser
is limited to populating the created bean definition with property values.
if you want to parse constructor arguments and nested elements from the
supplied XML element, then you will have to implement the
postProcess(org.springframework.beans.factory.support.BeanDefinitionBuilder, org.w3c.dom.Element)
method and do such parsing yourself, or (more likely) subclass the
AbstractSingleBeanDefinitionParser
or AbstractBeanDefinitionParser
classes directly.
The process of actually registering the
SimpleCacheBeanDefinitionParser
with the Spring XML parsing
infrastructure is described in the Spring Framework reference documentation
(in one of the appendices).
For an example of this parser in action (so to speak), do look at
the source code for the
org.springframework.beans.factory.xml.UtilNamespaceHandler.PropertiesBeanDefinitionParser;
the observant (and even not so observant) reader will immediately notice that
there is next to no code in the implementation. The
PropertiesBeanDefinitionParser
populates a
PropertiesFactoryBean
from an XML element that looks like this:
<util:properties location="jdbc.properties"/>
The observant reader will notice that the sole attribute on the
<util:properties/>
element matches the
setLocation(org.springframework.core.io.Resource)
method name on the PropertiesFactoryBean
(the general
usage thus illustrated holds true for any number of attributes).
All that the PropertiesBeanDefinitionParser
needs
actually do is supply an implementation of the
getBeanClass(org.w3c.dom.Element)
method to return the
PropertiesFactoryBean
type.
[Expand]
Inherited Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
org.springframework.beans.factory.xml.AbstractBeanDefinitionParser
|
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Protected Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parse the supplied
Element and populate the supplied
BeanDefinitionBuilder as required. | |||||||||||
Extract a JavaBean property name from the supplied attribute name.
| |||||||||||
This method is deprecated.
in favour of
isEligibleAttribute(org.w3c.dom.Attr, ParserContext)
| |||||||||||
Determine whether the given attribute is eligible for being
turned into a corresponding bean property value.
| |||||||||||
Determine whether the given attribute is eligible for being
turned into a corresponding bean property value.
| |||||||||||
Hook method that derived classes can implement to inspect/change a
bean definition after parsing is complete.
|
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser
| |||||||||||
From class
org.springframework.beans.factory.xml.AbstractBeanDefinitionParser
| |||||||||||
From class
java.lang.Object
| |||||||||||
From interface
org.springframework.beans.factory.xml.BeanDefinitionParser
|
Parse the supplied Element
and populate the supplied
BeanDefinitionBuilder
as required.
This implementation maps any attributes present on the
supplied element to PropertyValue
instances, and
adds them
to the
builder
.
The extractPropertyName(String)
method is used to
reconcile the name of an attribute with the name of a JavaBean
property.
element | the XML element being parsed |
---|---|
parserContext | the object encapsulating the current state of the parsing process |
builder | used to define the BeanDefinition |
Extract a JavaBean property name from the supplied attribute name.
The default implementation uses the
attributeNameToPropertyName(String)
method to perform the extraction.
The name returned must obey the standard JavaBean property name
conventions. For example for a class with a setter method
'setBingoHallFavourite(String)
', the name returned had
better be 'bingoHallFavourite
' (with that exact casing).
attributeName | the attribute name taken straight from the
XML element being parsed (never null ) |
---|
null
)
This method is deprecated.
in favour of isEligibleAttribute(org.w3c.dom.Attr, ParserContext)
Determine whether the given attribute is eligible for being turned into a corresponding bean property value.
The default implementation considers any attribute as eligible, except for the "id" attribute and namespace declaration attributes.
attribute | the XML attribute to check |
---|
Determine whether the given attribute is eligible for being turned into a corresponding bean property value.
The default implementation considers any attribute as eligible, except for the "id" attribute.
attributeName | the attribute name taken straight from the
XML element being parsed (never null )
|
---|
Determine whether the given attribute is eligible for being turned into a corresponding bean property value.
The default implementation considers any attribute as eligible, except for the "id" attribute and namespace declaration attributes.
attribute | the XML attribute to check |
---|---|
parserContext | the ParserContext |
Hook method that derived classes can implement to inspect/change a bean definition after parsing is complete.
The default implementation does nothing.
beanDefinition | the parsed (and probably totally defined) bean definition being built |
---|---|
element | the XML element that was the source of the bean definition's metadata |