Spring Bean Scope: Exploring Components with Different Life Cycles
The bean scope in the Spring framework determines the life cycle of the bean instance and its degree of sharing in the application. Understanding the characteristics and usage scenarios of different scopes can help you write high-performance, scalable applications. This article will discuss in detail the various scopes of Spring Bean and their application scenarios.
1. Singleton (single case)
Singleton is the default scope of Spring Bean. Under this scope, the Spring container will create one and only one instance for each container. All requests for the bean will get the same instance. Singleton Bean is only created once in the entire application life cycle, so it can reduce resource consumption and improve performance.
To define a bean as Singleton scoped, use the @Scope("singleton") annotation as follows:
javaCopy code@Component@Scope("singleton")publicclassSingletonBean {
// ...
}
Application scenario : Singleton scope is suitable for stateless, thread-safe components, such as service classes, data access objects (DAO), etc.
2. Prototype
Under the Prototype scope, the Spring container creates a new instance every time a bean is requested. Unlike Singleton scope, the number of Prototype Bean instances depends on the number of requests. This enables Bean with Prototype scope to store stateful information, but correspondingly, resource consumption and performance overhead will also increase.
To define a Bean as Prototype scoped, use the @Scope("prototype") annotation, as follows:
javaCopy code@Component@Scope("prototype")publicclassPrototypeBean {
// ...
}
Application scenarios : Prototype scope is suitable for stateful, thread-unsafe components, such as business logic classes with temporary state information.
3. Request
Request scope limits the lifecycle of a bean to a single HTTP request. Under this scope, for each HTTP request, the Spring container will create a new Bean instance. This allows Request-scoped beans to store request-related state information, but it should be noted that this will increase the resource consumption of each request.
To define a Bean as Request scope, use the @Scope("request") annotation
Application scenario : Request scope is suitable for scenarios that need to maintain state information in an HTTP request, such as storing user session information.
4. Session
Session scope limits the bean's life cycle to the user session. Under this scope, for each user session, the Spring container will create a new Bean instance. A session-scoped bean can store user-related state information across multiple requests.
Application scenario : Session scope is suitable for scenarios that need to maintain state information during the entire user session, such as user authentication, shopping cart, etc.
5. Application
Application scope limits the bean's lifecycle to the entire application. This means that the Spring container creates the bean instance when the application starts and destroys the instance when the application shuts down. Application-scoped beans are shared throughout the application, so make sure they are stateless and thread-safe.
Application scenario : Application scope is suitable for scenarios that need to be shared throughout the application, such as global configuration information, cache, etc.
6. WebSocket (Socket)
A WebSocket scope limits the bean's lifecycle to the WebSocket session. Under this scope, for each WebSocket session, the Spring container will create a new Bean instance. A WebSocket-scoped bean can store state information related to a particular WebSocket session.
Application scenarios : WebSocket scope is suitable for scenarios that need to maintain state information during a WebSocket session, such as real-time chat applications, online games, etc.
Summarize
Understanding the various scopes of Spring Beans and their characteristics and usage scenarios is the key to building high-performance, scalable applications. Selecting the appropriate scope according to the characteristics and requirements of the component can effectively improve the performance, maintainability and scalability of the application.