Spring Bean Definition Inheritance

Just like the OOPS concept of inheritance is used in object oriented language where child class can inherit attributes and methods of a parent class same way in Spring framework child bean can inherit configuration data from a parent definition. In this post we’ll see how bean definition inheritance works in Spring.

Bean definition inheritance in Spring

A bean definition can contain a lot of configuration information, including constructor arguments, property values, and container-specific information, such as the initialization method, a static factory method name, and so on. A child bean definition can inherit that configuration information from a parent bean rather than defining everything again. The child definition can override some values or add others as needed.

How does bean definition inheritance work

Parent bean definition that is inherited in the child bean definition is specified using parent attribute of the <bean> element. For example in the following configuration parent bean definition is inherited by empBean using the parent attribute and it inherits the property company from parent bean definition and adds name property of its own.

<bean id="baseEmpBean" class="com.knpcode.Employee">
	<property name="company" value="XYZ"/>
</bean> 
    
<bean id="empBean" parent="baseEmpBean">
	<property name="name" value="Jack" />
</bean>

In the configuration you can see that the child bean definition doesn’t specify a bean class.
A child bean definition doesn’t need to specify a bean class it can use the bean class from the parent definition. Though child bean definition can also override bean class, if it does then the child bean class must be compatible with the parent (that is, it must accept the parent’s property values). For example-

<bean id="parentBean" class="com.knpcode.TestBean">
	<property name="name" value="parent"/>
	<property name="mode" value="inherit"/>
</bean>

<bean id="childBean" class="org.springframework.beans.DerivedTestBean" parent="inheritedTestBean" >
	<property name="name" value="override"/>
	<!--  mode property value will be inherited from parent -->
</bean>

Spring Bean definition inheritance Example

In the example there is a bean class Employee with properties empId, empName, company, dept. In the parent definition value for company property is assigned which is inherited by the child bean definition.

public class Employee {
	int empId;
	String empName;
	String company;
	String dept;
	public int getEmpId() {
		return empId;
	}
	public void setEmpId(int empId) {
		this.empId = empId;
	}
	public String getEmpName() {
		return empName;
	}
	public void setEmpName(String empName) {
		this.empName = empName;
	}
	public String getDept() {
		return dept;
	}
	public void setDept(String dept) {
		this.dept = dept;
	}
	public String getCompany() {
		return company;
	}
	public void setCompany(String company) {
		this.company = company;
	}
	
	@Override
	public String toString() {
		return "Id= " + getEmpId() + " Name= " + 
	           getEmpName() + " Dept= "+ getDept()
	           + " Company= " + getCompany();
	}
}

Configuration

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd">
    
	<bean id="baseEmpBean" class="com.knpcode.springproject.model.Employee">
		<property name="company" value="XYZ"/>
	</bean> 
	<bean id="empBean" parent="baseEmpBean">
		<property name="empId" value="1" />
		<property name="empName" value="Jack" />
		<property name="dept" value="HR" />
	</bean>
</beans>

You can use the following class with main method to read the configuration and access the beans.

public class App {
  public static void main( String[] args ){
    // create context using configuration
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("appcontext.xml");
    Employee emp =  context.getBean("empBean", Employee.class);
    System.out.println(emp);
    context.close();
  }
}

Output

20:09:24.009 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'baseEmpBean'
20:09:24.140 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'empBean'
Id= 1 Name= Jack Dept= HR Company= XYZ

Abstract attribute in Spring Bean definition inheritance

If you want to restrict instantiation of parent bean then you can mark it as abstract=”true” to do that.

Abstract attribute in Spring bean definition

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:context="http://www.springframework.org/schema/context"
      xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
  <!-- acts as a template -->
  <bean id="baseEmpBean" abstract="true" class="com.knpcode.springproject.model.Employee">
    <property name="company" value="XYZ"/>
  </bean> 
  <bean id="empBean" parent="baseEmpBean" >
    <property name="empId" value="1" />
    <property name="empName" value="Jack" />
    <property name="dept" value="HR" />
  </bean>
</beans>

With parent marked as abstract trying to access parent bean results in an error.

Exception in thread "main" org.springframework.beans.factory.BeanIsAbstractException: Error creating bean with name 'baseEmpBean': Bean definition is abstract
	at org.springframework.beans.factory.support.AbstractBeanFactory.checkMergedBeanDefinition(AbstractBeanFactory.java:1335)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:295)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:204)
	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1111)
	at com.knpcode.springproject.App.main(App.java:14)

Parent bean as Template in Spring bean inheritance

By marking parent bean definition as abstract=”true” and not specifying a class too you can use parent only as a pure template bean definition that serves as a parent definition for child definitions.

Note that if the parent definition does not specify a class, explicitly marking the parent bean definition as abstract is required.

Template bean definition example

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- acts as a template -->
	<bean id="baseEmpBean" abstract="true">
		<property name="company" value="XYZ"/>
	</bean> 
	<bean id="empBean" parent="baseEmpBean" class="com.knpcode.springproject.model.Employee">
		<property name="empId" value="1" />
		<property name="empName" value="Jack" />
		<property name="dept" value="HR" />
	</bean>
</beans>

Related Posts

That’s all for the topic Spring Bean Definition Inheritance. If something is missing or you have something to share about the topic please write a comment.


You may also like

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.