探秘Spring Bean的秘境：作用域篇【beans 三】

欢迎来到我的博客，代码的世界里，每一行都是一个故事

在这里插入图片描述

探秘Spring Bean的秘境：作用域篇【beans 三】

- 前言
- 单例作用域
- - 如何声明单例Bean：
  - 特点：
- 原型作用域
- - 如何声明原型Bean：
  - 特点：
- 会话作用域
- - 如何声明会话作用域Bean：
  - 特点：
- 请求作用域
- - 如何声明请求作用域Bean：
  - 特点：
- 自定义作用域
- 作用域的生命周期
- - 单例作用域：
  - 原型作用域：
  - 影响：
- 实际应用场景
- - 1. 单例作用域（Singleton Scope）：
  - 2. 原型作用域（Prototype Scope）：
  - 3. 会话作用域（Session Scope）：
  - 4. 请求作用域（Request Scope）：

前言

在软件开发的舞台上，每个角色都有其独特的作用。Spring框架中的Bean也一样，通过作用域的不同，它们可以在应用中扮演不同的角色。从独一无二的单例到即时生成的原型，Spring的作用域机制为我们提供了丰富的选择。在这篇文章中，我们将带你踏上一场Spring Bean的时空之旅，深入了解每个作用域的特性和适用场景。

单例作用域

在Spring中，单例作用域（Singleton Scope）是默认的Bean作用域之一。当一个Bean被定义为单例时，Spring容器会在整个应用中维护该Bean的单一实例。每次请求该Bean时，都会返回相同的实例。这有助于节省资源，尤其是对于那些昂贵或频繁使用的对象。

如何声明单例Bean：

使用XML配置：

<bean id="mySingletonBean" class="com.example.MySingletonBean" scope="singleton">
    <!-- 其他配置属性 -->
</bean>

使用Java配置：

@Configuration
public class AppConfig {

    @Bean
    public MySingletonBean mySingletonBean() {
        return new MySingletonBean();
    }
}

在上述配置中，scope="singleton" 或者通过Java配置中的@Bean注解，没有指定@Scope注解，默认就是单例作用域。

特点：

唯一实例： Spring容器中只会创建该Bean的一个实例，不论有多少次请求该Bean。
全局共享： 适用于那些可以在整个应用中共享的对象。
节省资源： 对于那些占用大量资源或创建耗时的对象，使用单例可以减少资源消耗。

需要注意的是，虽然单例Bean在大多数情况下是很有用的，但也要小心可能引发的线程安全问题，因为单例Bean是在整个应用中共享的。确保单例Bean的状态是线程安全的，或者采用适当的同步机制。

原型作用域

在Spring中，原型作用域（Prototype Scope）是一种Bean的作用域，它与单例作用域相反。当一个Bean被定义为原型时，每次从容器中获取Bean时，都会创建一个新的实例。这确保每个请求得到的是一个独立的、新的Bean对象。

如何声明原型Bean：

使用XML配置：

<bean id="myPrototypeBean" class="com.example.MyPrototypeBean" scope="prototype">
    <!-- 其他配置属性 -->
</bean>

使用Java配置：

@Configuration
public class AppConfig {

    @Bean
    @Scope("prototype")
    public MyPrototypeBean myPrototypeBean() {
        return new MyPrototypeBean();
    }
}

在上述配置中，scope="prototype" 或者通过Java配置中的@Scope("prototype") 注解都将Bean声明为原型作用域。

特点：

每次请求新实例： 每次从容器中获取Bean时都会创建一个新的实例。
适用于状态不可共享： 适用于那些Bean实例的状态不可共享，每个请求需要一个独立的实例的情况。
资源消耗较大： 适用于那些占用较多资源、创建较慢的对象。

需要注意的是，由于原型Bean的每次请求都会创建一个新实例，容器不会管理这些实例的生命周期。这意味着，如果原型Bean中有需要在销毁时执行的逻辑（例如关闭资源），你需要自行管理。

会话作用域

在Spring中，会话作用域（Session Scope）是一种特殊的作用域，适用于Web应用程序中。当一个Bean被定义为会话作用域时，Spring容器会为每个用户会话（HTTP会话）创建一个独立的实例。这样可以确保在同一会话中共享的Bean实例，而不同会话之间的实例是独立的。

如何声明会话作用域Bean：

使用XML配置：

<bean id="mySessionBean" class="com.example.MySessionBean" scope="session">
    <!-- 其他配置属性 -->
</bean>

使用Java配置：

@Configuration
public class AppConfig {

    @Bean
    @Scope("session")
    public MySessionBean mySessionBean() {
        return new MySessionBean();
    }
}

在上述配置中，scope="session" 或者通过Java配置中的 @Scope("session") 注解都将Bean声明为会话作用域。

特点：

每个会话创建一个实例： 对于Web应用中的每个用户会话，Spring容器会创建一个独立的实例。
适用于会话状态跟踪： 适用于那些需要跟踪用户会话状态的Bean，例如用户登录信息等。
与HTTP会话关联： 与HTTP会话的生命周期相对应，当用户会话结束时，与之关联的Bean实例也被销毁。

会话作用域的使用通常限定在Web应用中，因为它依赖于HTTP会话的存在。这种作用域是有状态的，因此在设计时需要注意确保Bean的状态在会话之间不会产生冲突。

请求作用域

在Spring中，请求作用域（Request Scope）是一种特殊的作用域，适用于Web应用程序中。当一个Bean被定义为请求作用域时，Spring容器会为每个HTTP请求创建一个独立的实例。这样可以确保在同一HTTP请求中共享的Bean实例，而不同请求之间的实例是独立的。

如何声明请求作用域Bean：

使用XML配置：

<bean id="myRequestBean" class="com.example.MyRequestBean" scope="request">
    <!-- 其他配置属性 -->
</bean>

使用Java配置：

@Configuration
public class AppConfig {

    @Bean
    @Scope("request")
    public MyRequestBean myRequestBean() {
        return new MyRequestBean();
    }
}

在上述配置中，scope="request" 或者通过Java配置中的 @Scope("request") 注解都将Bean声明为请求作用域。

特点：

每个HTTP请求创建一个实例： 对于Web应用中的每个HTTP请求，Spring容器会创建一个独立的实例。
适用于与单个请求相关的Bean： 适用于那些需要与单个HTTP请求相关的Bean，例如处理用户请求的控制器。
与HTTP请求关联： 与HTTP请求的生命周期相对应，当HTTP请求结束时，与之关联的Bean实例也被销毁。

请求作用域的使用通常限定在Web应用中，因为它依赖于HTTP请求的存在。这种作用域是有状态的，因此在设计时需要注意确保Bean的状态在请求之间不会产生冲突。

自定义作用域

在Spring中，你可以通过实现Scope接口来创建自定义的作用域。自定义作用域可以满足特定需求，而不局限于Spring提供的默认作用域（如单例、原型、请求、会话等）。

以下是一个简单的示例，展示如何实现自定义作用域：

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;

import java.util.HashMap;
import java.util.Map;

public class CustomScope implements Scope {

    private final Map<String, Object> scopedObjects = new HashMap<>();
    private final Map<String, Runnable> destructionCallbacks = new HashMap<>();

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        if (!scopedObjects.containsKey(name)) {
            scopedObjects.put(name, objectFactory.getObject());

            // Register a destruction callback
            destructionCallbacks.put(name, () -> {
                // Your custom destruction logic here
                System.out.println("CustomScope: Destroying bean with name " + name);
            });
        }
        return scopedObjects.get(name);
    }

    @Override
    public Object remove(String name) {
        destructionCallbacks.remove(name);
        return scopedObjects.remove(name);
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        destructionCallbacks.put(name, callback);
    }

    @Override
    public Object resolveContextualObject(String key) {
        // Not used in this example
        return null;
    }

    @Override
    public String getConversationId() {
        // Not used in this example
        return null;
    }
}

在这个例子中，CustomScope实现了Scope接口，并提供了自定义的作用域逻辑。其中：

get: 获取指定名称的Bean实例，如果不存在，则创建一个新实例。
remove: 移除指定名称的Bean实例。
registerDestructionCallback: 注册销毁回调，当作用域结束时，Spring容器会调用这些回调以执行自定义的销毁逻辑。
resolveContextualObject: 用于解析上下文对象，通常不使用。
getConversationId: 用于获取对话标识，通常不使用。

接下来，你需要将自定义作用域注册到Spring容器中。这可以通过配置文件或Java配置类完成：

@Configuration
public class AppConfig {

    @Bean
    public static CustomScope customScope() {
        return new CustomScope();
    }

    @Bean
    @Scope(value = "customScope", proxyMode = ScopedProxyMode.TARGET_CLASS)
    public MyCustomScopedBean myCustomScopedBean() {
        return new MyCustomScopedBean();
    }
}

在上述配置中，@Scope注解的value属性指定了使用的作用域，这里是customScope，而proxyMode属性设置为ScopedProxyMode.TARGET_CLASS，用于解决自定义作用域中的依赖注入问题。

请注意，这只是一个简单的自定义作用域示例，实际上可以根据具体需求实现更复杂的逻辑。

作用域的生命周期

在Spring中，不同作用域的Bean生命周期有着显著的差异。主要的作用域包括单例作用域（Singleton Scope）和原型作用域（Prototype Scope）。

单例作用域：

初始化： 单例Bean在容器启动时被创建（懒加载除外），并在整个应用程序的生命周期内保持不变。在首次请求该Bean时，Spring容器会调用构造函数、属性注入、初始化方法（如afterPropertiesSet、@PostConstruct注解的方法）。
销毁： 单例Bean的销毁是在Spring容器关闭时进行的。当容器关闭时，Spring会调用单例Bean的销毁方法（如destroy、@PreDestroy注解的方法）。

原型作用域：

初始化： 原型Bean在每次请求时都会创建一个新实例。每次请求该Bean时，Spring容器会调用构造函数、属性注入、初始化方法（如afterPropertiesSet、@PostConstruct注解的方法）。
销毁： 原型Bean的销毁是由客户端代码负责的。Spring容器不会追踪原型Bean实例的生命周期，也不会在实例不再被引用时自动销毁。如果你的原型Bean实现了DisposableBean接口或使用了@PreDestroy注解的销毁方法，你需要手动调用这些方法。

影响：

资源消耗： 单例Bean由Spring容器管理，因此在整个应用程序生命周期内保持不变。这可能导致资源消耗较大。相反，原型Bean的资源消耗较小，因为每次请求都创建一个新实例。
状态共享： 单例Bean适用于需要在整个应用程序共享状态的情况，而原型Bean适用于需要保持独立状态的情况。
销毁控制： 单例Bean由Spring容器负责销毁，而原型Bean的销毁由客户端代码负责。

总的来说，选择单例作用域还是原型作用域取决于应用程序的具体需求。单例适用于共享状态的场景，而原型适用于每次请求都需要一个独立实例的场景。