Beans and Bean Scopes

Beans and Bean Scopes in Spring Boot

Dependency Injection (DI) is a core principle of the Spring framework, and understanding how Spring manages the objects it injects – known as Beans – is crucial. This section dives into what Beans are, how they're defined, and the different Bean Scopes available.

What are Beans?

In the Spring context, a Bean is simply an object that is managed by the Spring IoC (Inversion of Control) container. Think of it as a component that Spring creates, configures, and assembles. These beans can be anything from simple data objects to complex business logic components.

Key Characteristics of Beans:

• Managed by Spring: Spring is responsible for their lifecycle (creation, configuration, and destruction).
• Configurable: Beans can be configured using annotations, XML configuration, or Java configuration.
• Reusable: Beans can be injected into other beans, promoting code reuse and modularity.
• Testable: Because dependencies are injected, beans are easier to test in isolation.

Defining Beans

There are several ways to define beans in a Spring Boot application:

1. Using @Component Annotation:

This is the most common approach. You annotate a class with @Component (or one of its specializations like @Service, @Repository, or @Controller) and Spring automatically detects and registers it as a bean.

import org.springframework.stereotype.Component;

@Component
public class MyService {
    public String getMessage() {
        return "Hello from MyService!";
    }
}

Spring will automatically create an instance of MyService and make it available for dependency injection.

2. Using @Bean Annotation (Java Configuration):

This method is used within a class annotated with @Configuration. It allows you to define a bean by explicitly returning an instance of the class from a method.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}

Here, the myService() method is responsible for creating and returning the MyService bean.

3. XML Configuration (Less Common in Spring Boot):

While still possible, XML configuration is less frequently used in modern Spring Boot applications. It involves defining beans in an XML file and configuring Spring to load that file.

Bean Scopes

The scope of a bean determines how instances of that bean are created and shared within the Spring container. Spring provides several built-in scopes:

1. Singleton (Default):

• Behavior: Only one instance of the bean is created per Spring IoC container. All requests for the bean will receive the same instance.
• Use Case: Suitable for stateless beans or beans that hold configuration data.

@Component
@Scope("singleton") // Explicitly defining singleton (optional, as it's the default)
public class SingletonBean {
    // ...
}

2. Prototype:

• Behavior: A new instance of the bean is created every time it is requested.
• Use Case: Suitable for stateful beans where each request needs its own independent instance. Spring doesn't manage the complete lifecycle of prototype beans; the client code is responsible for managing their lifecycle.

@Component
@Scope("prototype")
public class PrototypeBean {
    // ...
}

3. Request (Web-Aware):

• Behavior: A new instance of the bean is created for each HTTP request. Only available in web-aware Spring applications.
• Use Case: Suitable for beans that need to store data specific to a single HTTP request.

@Component
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopedBean {
    // ...
}

• proxyMode = ScopedProxyMode.TARGET_CLASS: This is crucial. Because the bean is created per request, directly injecting it into a singleton bean would lead to issues. The proxy mode creates a proxy object that resolves to the correct request-scoped instance at runtime.

4. Session (Web-Aware):

• Behavior: A new instance of the bean is created for each HTTP session. Only available in web-aware Spring applications.
• Use Case: Suitable for beans that need to store data specific to a user's session.

@Component
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class SessionScopedBean {
    // ...
}

• proxyMode = ScopedProxyMode.TARGET_CLASS: Similar to request, a proxy is needed for proper injection into other beans.

5. Application (Web-Aware):

• Behavior: A new instance of the bean is created per ServletContext. Essentially, one instance per web application.
• Use Case: Suitable for beans that need to be shared across the entire web application.

@Component
@Scope(value = "application", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ApplicationScopedBean {
    // ...
}

• proxyMode = ScopedProxyMode.TARGET_CLASS: Proxy required for injection.

6. Websocket (Web-Aware):

• Behavior: A new instance of the bean is created for each WebSocket session.
• Use Case: Suitable for beans that need to store data specific to a WebSocket connection.

Choosing the Right Scope

Selecting the appropriate bean scope is vital for application performance and correctness. Consider these factors:

• Statefulness: If the bean holds state, prototype is often the best choice to avoid concurrency issues.
• Concurrency: singleton beans require careful consideration to ensure thread safety if they are stateful.
• Web Application Context: For web applications, request, session, and application scopes provide convenient ways to manage data within the HTTP lifecycle.
• Performance: singleton is generally the most performant scope, as it minimizes object creation overhead.

Accessing Bean Scopes

You can access the current scope using the ScopedObject class, but this is less common in typical Spring Boot applications. The primary way to leverage bean scopes is through proper injection and understanding how Spring manages the lifecycle of beans within those scopes.

This overview provides a foundation for understanding beans and bean scopes in Spring Boot. Experimenting with different scopes and observing their behavior is the best way to solidify your understanding.