(Reference: Spring Docs - Bean Scopes)

🔹 What is a Bean Scope?

💡 Bean Scope determines how long a bean lives and how many instances exist in the application.

💡 Spring provides different scopes to manage beans depending on the use case.

📌 Types of Bean Scopes in Spring

🔥 Spring defines several bean scopes, divided into two categories:

• Singleton & Prototype → Standard scopes (used in ANY Spring app).
• Request, Session, Application, WebSocket → Web-specific scopes.

1️⃣ Singleton Scope (Default)

✅ Only ONE instance exists for the entire application context.

✅ Same instance is returned every time the bean is requested.

✅ Best for stateless, reusable components (e.g., Service classes).

📌 Example:

import org.springframework.stereotype.Component; @Component public class PirateCaptain { public PirateCaptain() { System.out.println("🏴‍☠️ Singleton Pirate Captain Created!"); } } 

🔥 Spring ensures only ONE PirateCaptain instance exists!

2️⃣ Prototype Scope

✅ A NEW instance is created every time the bean is requested.

✅ Used for stateful objects that require separate instances.

✅ Good for expensive objects that should NOT be shared.

📌 Example:

import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; @Component @Scope("prototype") public class TreasureMap { public TreasureMap() { System.out.println("🗺️ New Treasure Map Created!"); } } 

🔥 Each time you getBean(TreasureMap.class), a new instance is returned!

3️⃣ Request Scope (For Web Applications)

✅ One instance per HTTP request (lives as long as the request).

✅ Useful for objects needed only during request processing.

📌 Example:

import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; @Component @Scope("request") public class ShipLog { public ShipLog() { System.out.println("📜 New Ship Log Created for Request!"); } } 

🔥 Every new HTTP request gets a new ShipLog instance!

4️⃣ Session Scope (For Web Applications)

✅ One instance per user session (persists across multiple requests).

✅ Useful for session-based user data.

📌 Example:

import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; @Component @Scope("session") public class PirateSession { public PirateSession() { System.out.println("🏴‍☠️ New Pirate Session Created!"); } } 

🔥 Every user gets their own PirateSession bean across multiple requests.

5️⃣ Application Scope (For Web Applications)

✅ One instance for the ENTIRE application (shared across all requests & users).

✅ Useful for storing global application data.

📌 Example:

import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; @Component @Scope("application") public class GlobalPirateRules { public GlobalPirateRules() { System.out.println("📜 Global Pirate Rules Initialized!"); } } 

🔥 The same instance is shared across all users and requests.

📌 Hands-On Project: Exploring Bean Scopes

💡 Let’s create a simple Spring Boot app to experiment with different bean scopes!

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: Create Beans with Different Scopes

📌 Create a Singleton Bean:

import org.springframework.stereotype.Component; @Component public class SingletonPirate { public SingletonPirate() { System.out.println("🏴‍☠️ Singleton Pirate Created!"); } } 

📌 Create a Prototype Bean:

import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; @Component @Scope("prototype") public class PrototypeTreasure { public PrototypeTreasure() { System.out.println("💎 New Prototype Treasure Created!"); } } 

Step 3: Inject and Test Scopes in a REST Controller

📌 Create a ScopeController to observe bean behavior:

import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/scopes") public class ScopeController { private final SingletonPirate singletonPirate; private final PrototypeTreasure prototypeTreasure; public ScopeController(SingletonPirate singletonPirate, PrototypeTreasure prototypeTreasure) { this.singletonPirate = singletonPirate; this.prototypeTreasure = prototypeTreasure; } @GetMapping("/singleton") public String getSingleton() { return "🏴‍☠️ Singleton Pirate Hash: " + singletonPirate.hashCode(); } @GetMapping("/prototype") public String getPrototype() { return "💎 Prototype Treasure Hash: " + prototypeTreasure.hashCode(); } } 

Step 4: Run the Application & Test

💡 Run the app using:

mvn spring-boot:run 

or

./mvnw spring-boot:run 

📌 Open browser & test the endpoints:
1️⃣ Call Singleton Endpoint:

• http://localhost:8080/scopes/singleton

• Response:
  

   🏴‍☠️ Singleton Pirate Hash: 12345678 

• Same value every time!

2️⃣ Call Prototype Endpoint Multiple Times:

• http://localhost:8080/scopes/prototype

• Response:
  

   💎 Prototype Treasure Hash: 87654321 

• Different value each time!

🔥 Boom! You just witnessed Spring Bean Scopes in action!

📌 Summary of Step 4

✅ Singleton (Default): One instance per application.

✅ Prototype: A new instance every time.

✅ Request: One instance per HTTP request (Web apps only).

✅ Session: One instance per user session (Web apps only).

✅ Application: One instance for the entire app (Web apps only).

📌 Topics Covered in This Section
📜 Spring Bean Scopes (✔️ Covered)

• Singleton (Default scope, one instance per container).
• Prototype (New instance every time).
• Request Scope (New instance per HTTP request).
• Session Scope (New instance per user session).
• Application Scope (Shared instance for the entire application).

🛠️ Spring Boot & Scopes (✔️ Covered)

• Using @scope annotation.
• How singleton vs. prototype works in dependency injection.
• Scope behavior in REST APIs.

🔥 Key Takeaways You Need to Remember:
✅ Singleton is the default scope.
✅ Prototype creates a new bean instance every time.
✅ Web scopes (Request, Session, Application) require Spring Web.
✅ Use @scope("prototype") carefully when injecting into Singleton beans (can cause issues).