Spring Bean Scope

What is Bean Scope in Spring?

In the Spring Framework, a bean scope defines the lifecycle of a bean (i.e., how many instances of a bean should be created and how Spring manages them). The scope dictates whether a new instance of a bean should be created with each request, or if the same instance should be shared across multiple requests.

Types of Bean Scopes

• Singleton (Default): Only one instance of the bean is created and shared across the application context.
• Prototype: A new instance of the bean is created every time it is requested.
• Request (Web applications only): A new bean instance is created for each HTTP request.
• Session (Web applications only): A new bean instance is created for each HTTP session.
• Global Session (Portlet environments): A new bean instance is created for each global session.

1. Singleton Bean Scope

The singleton scope is the default bean scope in Spring. It ensures that only one instance of the bean is created and is shared across all requests.

• Instance sharing: All components that need the bean will receive the same instance.
• Thread safety: Singleton beans are not inherently thread-safe, meaning you have to handle concurrency issues like race conditions if the bean is accessed by multiple threads.
• Application-wide state: Singleton beans can hold state that is shared across the entire application.

Race Condition in Singleton Beans

A race condition occurs when two or more threads access shared data and try to change it simultaneously. In the case of a singleton bean, multiple threads could access the same bean instance, leading to inconsistent data if not properly synchronized.

To prevent race conditions, you can use techniques such as:

• Using the synchronized keyword on critical sections.
• Utilizing thread-safe classes (e.g., ConcurrentHashMap).

Use Case of Singleton Scope

Singleton beans are useful when you want to share data or configuration across multiple components in your application.

Example Code: Singleton Bean in Spring

        import org.springframework.context.annotation.Scope;
        import org.springframework.stereotype.Service;
        
        @Service
        @Scope("singleton")  // By default, it's singleton, but we explicitly define it here
        public class LoggingService {
            public void log(String message) {
                System.out.println("Logging message: " + message);
            }
        }
            

Eager vs Lazy Instantiation of Singleton Scope

Eager Instantiation (Default Behavior)

• Definition: In Spring, by default, singleton beans are eagerly instantiated, meaning they are created as soon as the application context is loaded, regardless of whether they are used or not.
• Benefit: Faster access to the bean when needed, as the instance is already created.
• Drawback: Unused beans still consume memory, which may impact the startup time of the application.

Use Case of Eager Instantiation

Eager instantiation is ideal for beans that are crucial to the application’s startup process, such as configuration services or connection pools, which need to be ready as soon as the application starts.

Example Code: Eager Instantiation

        import org.springframework.context.annotation.Scope;
        import org.springframework.stereotype.Service;
        
        @Service
        @Scope("singleton")  // Eager instantiation, created at application startup
        public class ConfigurationService {
            public ConfigurationService() {
                System.out.println("ConfigurationService bean created at startup");
            }
        }
            

Lazy Instantiation

• Definition: In lazy instantiation, the bean is not created until it is actually requested by the application.
• Benefit: Saves resources and speeds up application startup by only instantiating the bean when needed.
• Drawback: The first request to the bean may experience a slight delay, as the instance is created at that point.

Use Case of Lazy Instantiation

Lazy instantiation is useful for beans that are not always needed during the lifecycle of the application, such as optional services or background tasks.

Example Code: Lazy Instantiation

        import org.springframework.context.annotation.Lazy;
        import org.springframework.stereotype.Service;
        
        @Service
        @Lazy  // Bean will be instantiated only when needed
        public class ReportService {
            public ReportService() {
                System.out.println("ReportService bean created on-demand");
            }
        }
            

2. Prototype

3. Request/Session/Application Scopes

Interview Questions and Answers

                @Service
                @Lazy
                public class HeavyResourceService {
                    public HeavyResourceService() {
                        // Heavy initialization logic
                    }
                }