A bean definition potentially contains a large amount of configuration information, including container specific information (for example initialization method, static factory method name, and so forth) and constructor arguments and property values. A child bean definition is a bean definition that inherits configuration data from a parent definition. It is then able to override some values, or add others, as needed. Using parent and child bean definitions can potentially save a lot of typing. Effectively, this is a form of templating.
When working with a
programmatically, child bean definitions are represented by the
ChildBeanDefinition class. Most users will never
work with them on this level, instead configuring bean definitions
declaratively in something like the
When using XML-based configuration metadata a child bean definition is
indicated simply by using the
specifying the parent bean as the value of this attribute.
<bean id="inheritedTestBean" abstract="true" class="org.springframework.beans.TestBean"> <property name="name" value="parent"/> <property name="age" value="1"/> </bean> <bean id="inheritsWithDifferentClass" class="org.springframework.beans.DerivedTestBean" parent="inheritedTestBean" init-method="initialize"> <property name="name" value="override"/> <!-- the age property value of 1 will be inherited from parent --> </bean>
A child bean definition will use the bean class from the parent definition if none is specified, but can also override it. In the latter case, the child bean class must be compatible with the parent, that is it must accept the parent's property values.
A child bean definition will inherit constructor argument values,
property values and method overrides from the parent, with the option to
add new values. If any init-method, destroy-method and/or
static factory method settings are specified, they will
override the corresponding parent settings.
The remaining settings will always be taken from the child definition: depends on, autowire mode, dependency check, singleton, scope, lazy init.
Note that in the example above, we have explicitly marked the parent
bean definition as abstract by using the
attribute. In the case that the parent definition does not specify a
class, and so explicitly marking the parent bean definition as
abstract is required:
<bean id="inheritedTestBeanWithoutClass" abstract="true"> <property name="name" value="parent"/> <property name="age" value="1"/> </bean> <bean id="inheritsWithClass" class="org.springframework.beans.DerivedTestBean" parent="inheritedTestBeanWithoutClass" init-method="initialize"> <property name="name" value="override"/> <!-- age will inherit the value of 1 from the parent bean definition--> </bean>
The parent bean cannot get instantiated on its own since it is
incomplete, and it is also explicitly marked as
abstract. When a definition is defined to be
abstract like this, it is usable only as a pure
template bean definition that will serve as a parent definition for child
definitions. Trying to use such an
abstract parent bean
on its own (by referring to it as a ref property of another bean, or doing
getBean() call with the parent bean
id), will result in an error. Similarly, the container's internal
preInstantiateSingletons() method will completely
ignore bean definitions which are defined as abstract.