Understanding Spring Beans and Their Scopes

Explain Spring Beans and their scopes.

In the Spring Framework, a Spring Bean is an object that is instantiated, assembled, and managed by the Spring IoC (Inversion of Control) container. Beans are the backbone of a Spring application, and they are created based on the configuration provided in the Spring context, which can be defined using XML, Java annotations, or Java configuration classes.

Key Characteristics of Spring Beans:

1. Managed by Spring: Beans are created and managed by the Spring container, which takes care of their lifecycle, including instantiation, dependency injection, and destruction.
2. Configuration: Beans can be configured using XML files, Java annotations, or Java-based configuration classes.
3. Dependency Injection: Spring supports various types of dependency injection (constructor-based, setter-based, and method-based) to manage the dependencies between beans.

Bean Scopes

The scope of a Spring bean defines the lifecycle and visibility of that bean within the Spring container. Spring provides several scopes for beans, which can be categorized based on the context in which they are used:

1. Singleton (Default Scope):

   • Description: A single instance of the bean is created and shared across the entire Spring container. All requests for that bean will return the same instance.
   • Use Case: Suitable for stateless beans or shared resources.
   • Configuration:

     @Bean
     @Scope("singleton")
     public MyBean myBean() {
         return new MyBean();
     }
     

2. Prototype:

   • Description: A new instance of the bean is created each time it is requested from the container. This means that every call to the bean will return a different instance.
   • Use Case: Suitable for stateful beans or when a new instance is required for each use.
   • Configuration:

     @Bean
     @Scope("prototype")
     public MyBean myBean() {
         return new MyBean();
     }
     

3. Request (Web Application Context):

   • Description: A new instance of the bean is created for each HTTP request. This scope is only valid in the context of a web application.
   • Use Case: Suitable for beans that are specific to a single HTTP request.
   • Configuration:

     @Bean
     @Scope("request")
     public MyBean myBean() {
         return new MyBean();
     }
     

4. Session (Web Application Context):

   • Description: A new instance of the bean is created for each HTTP session. This scope is also valid only in the context of a web application.
   • Use Case: Suitable for beans that need to maintain state across multiple requests within a single session.
   • Configuration:

     @Bean
     @Scope("session")
     public MyBean myBean() {
         return new MyBean();
     }
     

5. Global Session (Web Application Context):

   • Description: A new instance of the bean is created for each global HTTP session. This scope is typically used in portlet-based web applications.
   • Use Case: Suitable for beans that need to maintain state across multiple portlet sessions.
   • Configuration:

     @Bean
     @Scope("globalSession")
     public MyBean myBean() {
         return new MyBean();
     }
     

6. Application (Spring Application Context):

   • Description: A single instance of the bean is created for the entire application context. This is similar to the singleton scope but is used in the context of a Spring application.
   • Use Case: Suitable for beans that need to be shared across the entire application.
   • Configuration:

     @Bean
     @Scope("application")
     public MyBean myBean() {
         return new MyBean();
     }
     

Summary

Spring Beans are essential components of a Spring application, and their scopes determine how they are instantiated and managed within the application context. Understanding these scopes helps developers design applications that are efficient, maintainable, and aligned with the intended use of each bean.