Defining Bean Scope in Spring Framework: A Comprehensive Guide

How to Define the Scope of a Bean?

Defining the scope of a bean is an important aspect of managing the lifecycle and visibility of beans in a dependency injection framework, such as Spring. The scope determines how long a bean will live and how it will be shared within the application. Here are the common scopes available in Spring and how to define them:

Common Bean Scopes in Spring

1. Singleton (default scope):

   • Definition: A single instance of the bean is created and shared across the entire Spring container.
   • Usage: Use this scope when you want to ensure that only one instance of the bean exists throughout the application.
   • Definition:

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

2. Prototype:

   • Definition: A new instance of the bean is created each time it is requested from the container.
   • Usage: Use this scope when you need a new instance for each request.
   • Definition:

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

3. Request (web-aware scope):

   • Definition: A new instance of the bean is created for each HTTP request. This scope is only available in a web application context.
   • Usage: Use this scope for beans that are specific to a single HTTP request.
   • Definition:

     @Bean
     @Scope(value = WebApplicationContext.SCOPE_REQUEST)
     public MyBean myBean() {
         return new MyBean();
     }
     

4. Session (web-aware scope):

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

     @Bean
     @Scope(value = WebApplicationContext.SCOPE_SESSION)
     public MyBean myBean() {
         return new MyBean();
     }
     

5. Global Session (web-aware scope):

   • Definition: A new instance of the bean is created for each global HTTP session (used in portlet applications).
   • Usage: Rarely used, but applicable in specific scenarios involving portlet applications.
   • Definition:

     @Bean
     @Scope(value = WebApplicationContext.SCOPE_GLOBAL_SESSION)
     public MyBean myBean() {
         return new MyBean();
     }
     

How to Define the Scope

1. Using Annotations:

   • You can define the scope of a bean using the @Scope annotation in combination with the @Component, @Service, @Repository, or @Controller annotations.
   • Example:

     @Component
     @Scope("prototype")
     public class MyPrototypeBean {
         // Bean implementation
     }
     

2. Using XML Configuration:

   • If you are using XML-based configuration, you can define the scope in the XML file.
   • Example:

     <bean id="myBean" class="com.example.MyBean" scope="prototype"/>
     

3. Programmatic Configuration:

   • You can also define the scope programmatically using the ConfigurableBeanFactory interface.
   • Example:

     @Configuration
     public class AppConfig {
         @Bean
         public MyBean myBean() {
             return new MyBean();
         }
     
         @Bean
         public void configureBeanFactory(ConfigurableBeanFactory factory) {
             factory.registerScope("prototype", new PrototypeScope());
         }
     }
     

Conclusion

Defining the scope of a bean is crucial for managing its lifecycle and ensuring that it behaves as expected in your application. Choose the appropriate scope based on your application's requirements, and use the appropriate method (annotations, XML, or programmatic configuration) to define it.