Bean Scopes

In Spring, bean scope defines the lifecycle and visibility of a bean in the application context. It determines how many instances of a bean are created and how long they live.

Definition

Bean Scope is the lifecycle and visibility of a Spring bean within the Spring container.

---

What is the Default Bean Scope?

Singleton is the default scope in Spring.

@Component
publicclassUserService { }

Only ONE instance of UserService is created for the entire application.

---

Types of Bean Scopes in Spring

Spring provides two categories of scopes:

Core (Common) Scopes

Used in all Spring applications

1. Singleton
2. Prototype

Web-Aware Scopes

Used in Spring Web / Spring Boot web applications

1. Request
2. Session
3. Application
4. WebSocket

Singleton Scope (Default)

Only one instance of the bean is created per Spring IoC container.

• Created once when the container starts and reused wherever injected.
• Default for all Spring beans; ideal for stateless services or shared utilities.

@Component
@Scope("singleton")// optional, default
publicclassSingletonService { }

Example:

@Autowired
private SingletonService service1;

@Autowired
private SingletonService service2;

// service1 == service2 → true (same instance)

Behavior

ApplicationStart
     ↓
One Bean Created
     ↓
Shared Everywhere

Key Points:

• Default scope
• Best for stateless beans and shared resources
• Not suitable for beans holding user-specific or request-specific data

---

Prototype Scope

A new bean instance is created every time it is requested.

• Container creates a new bean on each injection or lookup, but does NOT manage destruction.
• Stateful beans, temporary objects.

@Component
@Scope("prototype")
publicclassPrototypeService { }

Example:

@Autowired
private PrototypeService p1;

@Autowired
private PrototypeService p2;

// p1 == p2 → false (different instances)

Behavior

Each getBean()call
     ↓
NewObject Created

Key Points:

• Useful for stateful beans
• Cleanup must be handled manually
• Not injected into singleton beans directly unless using @Lookup

---

Request Scope (Web Applications)

One bean instance is created per HTTP request.

• Lifecycle: Bean exists only during the lifecycle of the current HTTP request.
• Annotation: @Scope("request")
• Requirement: Must be used in a web-aware Spring context.

@Component
@Scope("request")
publicclassRequestScopedBean { }

Use Case:

• Suitable for beans that store request-specific data, such as form submissions, request parameters, or temporary processing objects.

Key Points:

• Each HTTP request gets a new instance of the bean.
• Only applicable for web applications.
• Avoid using request-scoped beans in non-web contexts.

---

Session Scope (Web Applications)

One bean instance is created per HTTP session.

• Lifecycle: Exists as long as the user’s session is active.
• Annotation: @Scope("session")
• Requirement: Web-aware Spring context.

@Component
@Scope("session")
publicclassSessionScopedBean { }

Use Case:

• Storing user-specific data throughout the session, such as user preferences or login information.

Key Points:

• Each user session gets its own bean instance.
• Only applicable in web applications.

---

Application Scope (Web Applications)

One bean instance is created per ServletContext.

• Lifecycle: Shared across the entire web application.
• Annotation: @Scope("application")

@Component
@Scope("application")
publicclassAppScopedBean { }

Use Case:

• Managing global data or shared resources, such as caches or application-wide configuration.

Key Points:

• Bean is shared across all users and sessions.
• Only for web applications.

---

WebSocket Scope

One bean instance is created per WebSocket session.

• Lifecycle: Exists for the duration of a WebSocket session.
• Annotation: @Scope("websocket")

@Component
@Scope("websocket")
publicclassWebSocketBean { }

Use Case:

• Maintaining state for individual WebSocket sessions, such as user-specific communication data.

Key Points:

• Requires WebSocket support in Spring.
• Useful for real-time, session-based communication.

---

Why Bean Scope Is Important

Bean scope helps you:

• Control memory usage
• Decide whether a bean should be shared or separate
• Manage stateful vs stateless objects
• Build scalable and efficient applications

---

Thread Safety Warning

Singleton + State = Danger

Wrong:

@Service
publicclassOrderService {
private Order order;// not thread-safe
}

Correct:

@Service
publicclassOrderService {
publicvoidprocess(Order order) { }
}

---

Real-Life Analogy

Scope	Example
Singleton	Electricity meter
Prototype	Disposable cup
Request	Restaurant order
Session	Shopping cart
Application	Mall directory
WebSocket	Live chat

Summary Table

Scope	Instance Per	Lifecycle	Typical Use
Singleton	Spring container	Container lifecycle	Stateless services, utilities
Prototype	Each injection	Caller manages lifecycle	Stateful, temporary objects
Request	HTTP request	Request lifecycle	Request-specific data
Session	HTTP session	Session lifecycle	User session-specific data
Application	ServletContext	Application lifecycle	Shared caches, global resources
WebSocket	WebSocket session	WebSocket session	WebSocket session state

---

Best Practices

• Use singleton beans for stateless services.
• Use prototype beans for stateful or temporary objects.
• Use request/session/application scopes only in web applications.
• Avoid unnecessary custom scopes to maintain predictable lifecycles.
• When injecting prototype beans into singleton beans, use @Lookup, ObjectFactory, or Provider to avoid stale references.