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

Summary Table

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.