(Reference: Spring Docs - Bean Definition Inheritance)
🔹 What is Bean Definition Inheritance?
💡 Spring allows one bean to inherit properties from another bean.
💡 Useful for reusing common configurations across multiple beans.
💡 Implemented via XML (parent attribute) or Java-based configuration (@Bean inheritance).
📌 How to Implement Bean Definition Inheritance
1️⃣ XML-Based Bean Inheritance (Legacy)
✔ In traditional XML configuration, you can define a parent bean with common properties and let child beans inherit them.
📌 Example (XML Configuration - Not Recommended for Modern Apps)
<bean id="baseShip" abstract="true">
<property name="captain" value="Blackbeard"/>
<property name="crewSize" value="100"/>
</bean>
<bean id="pirateShip" parent="baseShip">
<property name="shipName" value="The Black Pearl"/>
</bean>
<bean id="navyShip" parent="baseShip">
<property name="shipName" value="The Royal Fortune"/>
</bean>
🔥 Both pirateShip and navyShip inherit properties from baseShip!
2️⃣ Java-Based Bean Inheritance
✔ Modern Spring applications use Java-based configuration instead of XML.
✔ Use inheritance in Java classes to achieve the same effect.
📌 Example: Abstract Parent Bean
public abstract class BaseShip {
protected String captain = "Blackbeard";
protected int crewSize = 100;
public String getCaptain() {
return captain;
}
public int getCrewSize() {
return crewSize;
}
}
📌 Child Beans Inheriting Properties
import org.springframework.stereotype.Component;
@Component
public class PirateShip extends BaseShip {
private String shipName = "The Black Pearl";
public String getShipName() {
return shipName;
}
}
@Component
public class NavyShip extends BaseShip {
private String shipName = "The Royal Fortune";
public String getShipName() {
return shipName;
}
}
🔥 Both PirateShip and NavyShip automatically inherit captain & crew size from BaseShip!
3️⃣ Using @Bean Methods for Inheritance
✔ You can also define beans using @Configuration and have them inherit properties.
📌 Example: Java Config with @Bean Inheritance
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ShipConfig {
@Bean
public BaseShip baseShip() {
return new BaseShip();
}
@Bean
public PirateShip pirateShip() {
PirateShip ship = new PirateShip();
ship.captain = baseShip().getCaptain();
ship.crewSize = baseShip().getCrewSize();
return ship;
}
@Bean
public NavyShip navyShip() {
NavyShip ship = new NavyShip();
ship.captain = baseShip().getCaptain();
ship.crewSize = baseShip().getCrewSize();
return ship;
}
}
🔥 This approach ensures that all ships share common properties while allowing modifications!
📌 Hands-On Project: Testing Bean Inheritance
💡 Let’s modify our Spring Boot app to test bean inheritance!
Step 1: Create Parent and Child Beans
📌 BaseShip.java
public abstract class BaseShip {
protected String captain = "Blackbeard";
protected int crewSize = 100;
public String getCaptain() {
return captain;
}
public int getCrewSize() {
return crewSize;
}
}
📌 PirateShip.java
import org.springframework.stereotype.Component;
@Component
public class PirateShip extends BaseShip {
private String shipName = "The Black Pearl";
public String getShipName() {
return shipName;
}
}
📌 NavyShip.java
import org.springframework.stereotype.Component;
@Component
public class NavyShip extends BaseShip {
private String shipName = "The Royal Fortune";
public String getShipName() {
return shipName;
}
}
Step 2: Create a REST Controller to Test Inheritance
📌 ShipController.java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/ships")
public class ShipController {
private final PirateShip pirateShip;
private final NavyShip navyShip;
public ShipController(PirateShip pirateShip, NavyShip navyShip) {
this.pirateShip = pirateShip;
this.navyShip = navyShip;
}
@GetMapping("/pirate")
public String getPirateShip() {
return "🏴☠️ Pirate Ship: " + pirateShip.getShipName() +
", Captain: " + pirateShip.getCaptain() +
", Crew: " + pirateShip.getCrewSize();
}
@GetMapping("/navy")
public String getNavyShip() {
return "⚓ Navy Ship: " + navyShip.getShipName() +
", Captain: " + navyShip.getCaptain() +
", Crew: " + navyShip.getCrewSize();
}
}
Step 3: Run the Application & Test
💡 Run the app using:
mvn spring-boot:run
or
./mvnw spring-boot:run
📌 Test Bean Inheritance in Browser:
1️⃣ Check the Pirate Ship:
http://localhost:8080/ships/pirate-
Response:
🏴☠️ Pirate Ship: The Black Pearl, Captain: Blackbeard, Crew: 100
2️⃣ Check the Navy Ship:
http://localhost:8080/ships/navy-
Response:
⚓ Navy Ship: The Royal Fortune, Captain: Blackbeard, Crew: 100
🔥 Boom! You just witnessed Bean Definition Inheritance in action!
📌 Summary of Step 6
✅ Bean Definition Inheritance allows reusing common bean configurations.
✅ Implemented via XML (parent attribute) or Java-based configuration (@Bean).
✅ Java-based inheritance is preferred for modern Spring Boot applications.
✅ Best practice: Use abstract base classes for shared properties & behavior.
📌 Topics Covered in This Section
📜 Bean Definition Inheritance (✔️ Covered)
- XML-based inheritance (parent attribute) – for legacy projects.
- Java-based inheritance (extending base class) – recommended modern approach.
- Using @bean configuration for inheritance.
🛠️ Spring Boot & Bean Inheritance (✔️ Covered)
- Best practices for using inheritance in real-world applications.
- How to share properties across multiple bean definitions.
- Differences between XML-based and Java-based configurations.
🔥 Key Takeaways You Need to Remember:
✅ Bean Definition Inheritance allows reusing properties in multiple beans.
✅ XML-based inheritance (parent) is for legacy projects; modern apps use Java-based.
✅ Best practice: Use abstract base classes to share logic across beans.
✅ Use @bean methods for more flexibility when defining bean inheritance.
Top comments (0)