(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).
Top comments (0)