Spring - Inheriting Bean

In Spring, bean inheritance allows for reusing configuration from a parent bean and customizing it in child beans. This feature helps in reducing redundancy and managing configurations more efficiently. Unlike Java class inheritance, Spring bean inheritance is more about configuration inheritance rather than code inheritance.

Constructor arguments, property values, and container-specific information like initialization method, static factory method name, and so on may all be found in a bean definition. A parent definition's configuration data is passed down to a child bean definition. The child definition can override or add values as needed.

Although Spring Bean's definition of inheritance differs from Java class inheritance, the inheritance notion is the same. A parent bean definition can be used as a template, and other child beans can inherit the required configuration from it. When utilizing XML-based configuration metadata, the parent attribute is used to identify a child bean definition, with the parent bean as the value of this attribute.

We've previously seen one of the benefits of inheritance in Java: reusability. That is, if the base class has some attributes, the child class will inherit those properties and their values. In the Child class, we may also override those values. We can inherit the bean's attributes and values in Spring, and we can also override them.

Implementation of Bean Inheritance in Spring

Let us consider an arbitrarily class called Customer, so do the project structure is as follows: 

Step 1: Creation of Customer class 

Customer.java:

// Java Program to Illustrate Customer Class

package com.geeksforgeeks.beans.inheritance;

// Class
public class Customer {

    // Class data members
    private String name;
    private String email;
    private String country;

    // Getters and setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email)
    {
        // this keyword refers to current instance itself
        this.email = email;
    }

    // Method
    public String getCountry() { return country; }

    // Setter
    public void setCountry(String country)
    {
        this.country = country;
    }

    // Method
    // To show message
    @Override public String toString()
    {
        // Print corresponding customer attributes
        return " Name:" + name + "\n Email:" + email
            + "\n Country:" + country;
    }
}

 
Step 2: Create a spring beans.xml file that demonstrates how to inherit the bean.

beans.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <!-- Parent Bean Definition -->
    <bean id="baseCustomer" abstract="true">
        <property name="country" value="India"/>
    </bean>

    <!-- Child Bean Definition -->
    <bean id="customer" parent="baseCustomer" class="com.geeksforgeeks.beans.inheritance.Customer">
        <property name="name" value="Admin"/>
        <property name="email" value="[email protected]"/>
    </bean>
</beans>

• Parent Bean: baseCustomer defines the country property and is marked as abstract. It serves as a template for other beans.
• Child Bean: customer inherits the country property from baseCustomer and adds name and email properties.

Step 3: Create a class that loads these two beans and displays the output with the inherited value.

BeanInheritanceTest.java:

// Java Program to Illustrate Bean Inheritance

package com.geeksforgeeks.beans.inheritance;

// Importing required classes
import org.springframework.context.support.ClassPathXmlApplicationContext;

// Class
public class BeanInheritanceTest {

    // Main driver method
    public static void main(String[] args)
    {

        // Inheriting Bean by customer
        ClassPathXmlApplicationContext applicationContext
            = new ClassPathXmlApplicationContext(
                "beans.xml");

        Customer customer
            = (Customer)applicationContext.getBean(
                "customer");

        // Printing the customer info
        System.out.println(customer.toString());
    }
}

Step 4: Run the Application

Only the Country attribute of the parent bean has value. Even though we only introduced two attributes to Child, it contains values for all three properties. As a result, the Country property has been effectively passed from the Parent bean to our Child bean.

Output:

Conclusion 

The example demonstrates Spring bean inheritance effectively:

• Parent Bean: Defines common properties.
• Child Bean: Inherits properties from the parent and can add or override specific properties.

This approach helps in managing bean configurations efficiently and promoting reuse. The customer bean inherits the country property from baseCustomer and adds its own properties, demonstrating how Spring bean inheritance works in practice.