What is the role of the @Scope annotation in Spring?

Table of Contents

• Introduction
• Role of the @Scope Annotation in Spring
  • 1. Singleton Scope (Default)
    • Example:
  • 2. Prototype Scope
    • Example:
    • Practical Example:
  • 3. Request Scope
    • Example:
  • 4. Session Scope
    • Example:
  • 5. Global Session Scope
    • Example:
  • 6. Custom Scopes
• Practical Examples
  • Example 1: Using @Scope for Prototype Beans
  • Example 2: Using @Scope for Request-Specific Data
• Conclusion

Introduction

In Spring Framework, the @Scope annotation plays a crucial role in defining the lifecycle and visibility of beans. By default, Spring beans are singleton-scoped, meaning that only one instance of the bean is created and shared across the entire application. However, using the @Scope annotation, you can customize the scope of a bean to control how and when it is created and managed by the Spring container. This article explains the role of the @Scope annotation and how you can use it to manage Spring bean lifecycles.

Role of the @Scope Annotation in Spring

The @Scope annotation is used to specify the scope of a Spring bean. The scope determines how many instances of the bean will be created and how long the bean will exist within the Spring container. Spring supports several different scopes that can be applied using the @Scope annotation. The most common scopes include:

1. Singleton Scope (Default)

The default scope for Spring beans is singleton. When a bean is defined with the @Scope annotation or if no scope is defined at all, Spring will create only one instance of that bean. This instance will be shared throughout the entire application. It is useful for shared resources like database connections or configuration data.

Example:

In this example, even if multiple components request the SingletonBean, Spring will provide the same instance every time.

2. Prototype Scope

When a bean is defined with the @Scope("prototype") annotation, Spring creates a new instance of the bean each time it is requested. This is useful when you need multiple independent instances of the same bean, such as in cases where the bean has state that must not be shared between invocations.

Example:

Every time PrototypeBean is requested from the Spring context, a new instance will be created.

Practical Example:

In this example, bean1 and bean2 will be different instances because the scope is set to prototype.

3. Request Scope

The request scope is used in web applications where a new instance of the bean is created for each HTTP request. The bean is tied to the lifecycle of a single HTTP request and is destroyed once the request is completed.

Example:

In a web application, each HTTP request will get its own instance of the RequestBean.

4. Session Scope

The session scope is similar to the request scope but lasts for the duration of an HTTP session. A new instance of the bean will be created for each HTTP session, and it will be destroyed when the session ends.

Example:

This scope is particularly useful when you need to maintain state information for each user during their session.

5. Global Session Scope

The globalSession scope is typically used in portlet applications, where a bean is scoped to a global HTTP session rather than a user-specific session. This scope is rarely used in standard Spring applications but is available for portlet-based environments.

Example:

6. Custom Scopes

You can also define custom scopes for your beans by implementing the org.springframework.beans.factory.config.Scope interface and registering it in the Spring container. This is useful for specialized lifecycle management of beans beyond the standard scopes.

Practical Examples

Example 1: Using @Scope for Prototype Beans

If you want to ensure that each user gets their own instance of a service, you can define a service as a prototype-scoped bean. Here's an example where a prototype-scoped bean is injected into a singleton-scoped bean.

Every time PrototypeBean is injected into SingletonBean, it will get a new instance, even though SingletonBean itself is a singleton.

Example 2: Using @Scope for Request-Specific Data

In a web application, you may want to store user-specific information during a request. By defining a request-scoped bean, you can ensure that each HTTP request gets its own instance of the bean.

In a controller, you can inject this request-scoped bean and use it to hold user-specific data during a single request.

Conclusion

The @Scope annotation in Spring plays an important role in controlling the lifecycle and visibility of Spring beans. It allows you to specify the scope of beans, including singleton, prototype, request, session, and custom scopes, to suit different application needs. Understanding and using the @Scope annotation is essential for managing bean lifecycles efficiently, especially in web applications where the scope of a bean can greatly influence performance and memory usage.