📌 spring-note-005: Customizing the Nature of a Bean

(Reference: Spring Docs - Customizing Beans)

---

🔹 Why Customize Beans?

💡 Spring allows us to modify how beans behave using annotations and configurations.

💡 Customization gives us control over bean instantiation, dependency resolution, and initialization.

---

📌 Key Customization Features

🔥 Spring provides several ways to customize beans:

1️⃣ Lazy vs. Eager Initialization (@Lazy)

2️⃣ Defining Primary Beans (@Primary)

3️⃣ Using Qualifiers for Specific Bean Selection (@Qualifier)

4️⃣ Conditional Beans (@Conditional)

---

1️⃣ Lazy vs. Eager Initialization (@Lazy)

🔥 By default, Singleton Beans are created at startup.

🔥 With @Lazy, Spring delays bean creation until it is actually needed.

📌 Example:

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@Lazy
public class Kraken {
    public Kraken() {
        System.out.println("🦑 Kraken is awakening lazily...");
    }
}

Test with a REST Controller:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/lazy")
public class LazyController {
    private final Kraken kraken;

    public LazyController(Kraken kraken) {
        this.kraken = kraken;
    }

    @GetMapping
    public String awakenKraken() {
        return "⚓ Kraken is now awake!";
    }
}

💡 Bean is NOT created at startup! It is only created when /lazy endpoint is called.

---

2️⃣ Defining Primary Beans (@Primary)

🔥 If multiple beans of the same type exist, Spring needs to know which one to use by default.

🔥 @Primary marks a bean as the default choice unless explicitly overridden.

📌 Example:

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
@Primary
public class MainCaptain implements Captain {
    @Override
    public String command() {
        return "🏴‍☠️ Main Captain: Full speed ahead!";
    }
}

@Component
public class BackupCaptain implements Captain {
    @Override
    public String command() {
        return "⚓ Backup Captain: Ready if needed!";
    }
}

💡 When injecting Captain, MainCaptain is used by default.

---

3️⃣ Using Qualifiers for Specific Bean Selection (@Qualifier)

🔥 When multiple beans exist, we can use @Qualifier to specify which one to inject.

📌 Example:

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class Ship {
    private final Captain captain;

    public Ship(@Qualifier("backupCaptain") Captain captain) {
        this.captain = captain;
    }

    public String sail() {
        return captain.command();
    }
}

💡 Now BackupCaptain is explicitly used instead of MainCaptain.

---

4️⃣ Conditional Beans (@Conditional)

🔥 @Conditional allows us to register beans based on runtime conditions.

🔥 Useful for feature toggles, environment-based configurations, or platform-specific beans.

📌 Example: Load a bean only if a certain property is set.

import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;

@Component
@Conditional(StormyWeatherCondition.class)
public class StormySail {
    public StormySail() {
        System.out.println("⛈️ Storm detected! Adjusting sails...");
    }
}

📌 Custom Condition Class:

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class StormyWeatherCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return "stormy".equals(context.getEnvironment().getProperty("weather.mode"));
    }
}

💡 If weather.mode=stormy is set in application.properties, StormySail bean will be loaded.

---

📌 Hands-On Project: Testing Bean Customization

💡 Let’s modify our Spring Boot app to test these customizations!

---

Step 1: Create a Spring Boot Project

1️⃣ Go to Spring Initializr

2️⃣ Select:

• Spring Boot Version: Latest stable
• Dependencies: Spring Web
• Packaging: Jar 3️⃣ Click Generate and extract the zip file.

---

Step 2: Define Beans with Custom Behavior

📌 Lazy Bean:

@Component
@Lazy
public class Kraken {
    public Kraken() {
        System.out.println("🦑 Kraken is awakening lazily...");
    }
}

📌 Primary & Alternative Beans:

@Component
@Primary
public class MainCaptain implements Captain {
    @Override
    public String command() {
        return "🏴‍☠️ Main Captain: Full speed ahead!";
    }
}

@Component
public class BackupCaptain implements Captain {
    @Override
    public String command() {
        return "⚓ Backup Captain: Ready if needed!";
    }
}

📌 Conditional Bean:

@Component
@Conditional(StormyWeatherCondition.class)
public class StormySail {
    public StormySail() {
        System.out.println("⛈️ Storm detected! Adjusting sails...");
    }
}

---

Step 3: Create a REST Controller to Test Beans

📌 Lazy Bean Activation:

@RestController
@RequestMapping("/lazy")
public class LazyController {
    private final Kraken kraken;

    public LazyController(Kraken kraken) {
        this.kraken = kraken;
    }

    @GetMapping
    public String awakenKraken() {
        return "⚓ Kraken is now awake!";
    }
}

📌 Check which Captain is Injected:

@RestController
@RequestMapping("/captain")
public class CaptainController {
    private final Captain captain;

    public CaptainController(Captain captain) {
        this.captain = captain;
    }

    @GetMapping
    public String getCaptain() {
        return captain.command();
    }
}

---

Step 4: Run the Application & Test

💡 Run the app using:

mvn spring-boot:run

or

./mvnw spring-boot:run

📌 Test Lazy Initialization:

• Open browser and visit: http://localhost:8080/lazy
• You should see: "⚓ Kraken is now awake!"
• And in logs: "🦑 Kraken is awakening lazily..."

📌 Test Default vs. Qualified Bean Injection:

• Open browser and visit: http://localhost:8080/captain
• If @Primary is used → "🏴‍☠️ Main Captain: Full speed ahead!"
• If @Qualifier("backupCaptain") is used → "⚓ Backup Captain: Ready if needed!"

---

📌 Summary

✅ @Lazy delays bean creation until needed.

✅ @Primary sets the default bean when multiple exist.

✅ @Qualifier allows precise bean selection.

✅ @Conditional loads beans based on runtime conditions.

---

📌 Topics Covered in This Section
📜 Customizing Beans in Spring (✔️ Covered)

• Lazy vs. Eager Initialization (@lazy).
• Setting Default Beans with @primary.
• Overriding with @Qualifier when multiple beans exist.
• Conditional Beans (@Conditional) for dynamic configurations.

🛠️ Spring Boot & Customization (✔️ Covered)

• When to use lazy initialization for performance optimization.
• How @primary works in multi-bean scenarios.
• Using @Conditional to load beans based on environment properties.

🔥 Key Takeaways You Need to Remember:
✅ @lazy prevents beans from being created at startup.
✅ @primary sets the default bean when multiple exist.
✅ @Qualifier ensures the correct bean is injected.
✅ @Conditional allows runtime-based bean loading.