【手撕 Spring】bean的作用域

悠悠 2024-05-04 08:02 119阅读 0赞

![在这里插入图片描述][bddcb8cec5d647199d3714a9cfe93e1b.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [带你手撕 Spring][Spring]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java]

#### 文章目录 ####

*   *   *  一、什么是bean的作用域
         *  二、为什么要bean的作用域
         *  三、@Scope 注解
         *   *  3.1、ScopedProxyMode
         *  四、Singleton
         *  五、Prototype
         *  六、Request
         *  七、Session
         *  八、bean的作用域是如何实现的

#### 一、什么是bean的作用域 ####

bean的作用域指的是在Spring容器中创建的bean对象的生命周期和可见范围。Spring框架提供了多种不同的作用域，可以根据应用程序的需求选择合适的作用域。

以下是几种常见的bean作用域：

1.  **Singleton**（单例）：在整个应用程序中只创建一个bean实例，并且该实例在容器中共享。每次请求获取该bean时，都会返回同一个实例。
2.  **Prototype**（原型）：每次请求获取该bean时，都会创建一个新的实例。每个实例都是独立的，不共享状态。
3.  **Request**（请求）：每个HTTP请求都会创建一个新的bean实例，并且该实例只在当前请求的范围内可见。不同的请求之间不共享该实例。
4.  **Session**（会话）：每个用户会话（Session）只创建一个bean实例，并且该实例在整个会话期间可见。不同用户的会话之间不共享该实例。

除了上述常见的作用域之外，Spring还提供了其他一些特殊的作用域，如Application（应用程序）作用域、WebSocket作用域等，可以根据具体的需求选择适合的作用域。

通过定义适当的作用域，可以控制bean对象的生命周期和可见性，从而实现更好的资源管理和应用程序性能。

![在这里插入图片描述][b96014232f3846298d0274d54342c312.png]

#### 二、为什么要bean的作用域 ####

bean的作用域非常重要，它决定了在应用程序中创建的bean对象的生命周期和可见范围。以下是一些使用不同作用域的原因：

1.  **节省资源**：通过选择适当的作用域，可以避免创建过多的对象实例，从而节省内存和处理器资源。例如，将只需一个实例的对象配置为单例作用域，可以确保在整个应用程序中只创建一个实例，减少了内存消耗。
2.  **控制对象的生命周期**：不同的作用域可以控制bean对象的生命周期。例如，将对象配置为原型作用域，每次请求获取该bean时都会创建一个新的实例，这对于需要频繁重置状态或避免状态共享的对象非常有用。
3.  **实现不同的可见性**：不同的作用域可以实现不同的可见性。例如，将对象配置为请求作用域，每个HTTP请求都会创建一个新的实例，这对于需要在请求之间保持状态隔离的对象非常有用。
4.  **支持并发**：通过选择适当的作用域，可以支持并发访问。例如，将对象配置为会话作用域，可以确保每个用户会话都有自己的实例，避免了并发访问的问题。

通过选择适当的作用域，可以根据应用程序的需求来管理对象的生命周期、控制资源消耗、实现状态隔离和支持并发访问。这对于构建可扩展、高性能和可维护的应用程序非常重要。

#### 三、@Scope 注解 ####

@Scope注解是Spring框架中用于定义bean的作用域的注解。它可以应用于类级别或方法级别，并且可以接受一个参数来指定作用域类型。

@Scope注解的参数及其用法如下：

1.  singleton（默认值）：表示创建的bean是单例的，即在整个应用程序上下文中只有一个实例。示例代码如下：

@Bean
    @Scope("singleton")
    public MySingletonBean singletonBean() {
        
        return new MySingletonBean();
    }

1.  prototype：表示每次请求bean时都会创建一个新的实例。示例代码如下：

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

1.  request：表示每个HTTP请求都会创建一个新的实例，适用于Web应用程序中的请求作用域。示例代码如下：

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

1.  session：表示每个HTTP会话都会创建一个新的实例，适用于Web应用程序中的会话作用域。示例代码如下：

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

这些是@Scope注解的常用参数和用法。通过使用不同的作用域类型，可以控制bean的生命周期和可见范围，以满足不同的应用需求。

##### 3.1、ScopedProxyMode #####

ScopedProxyMode是@Scope注解的一个参数，用于指定代理模式。它可以应用于类级别或方法级别的@Scope注解上。

ScopedProxyMode的参数值有以下几种：

1.  **DEFAULT**（默认值）：如果目标bean是非单例的，则创建一个基于接口的JDK动态代理。如果目标bean是单例的，则创建一个基于类的CGLIB代理。
2.  **INTERFACES**：始终创建一个基于接口的JDK动态代理，无论目标bean是否是单例的。
3.  **TARGET\_CLASS**：始终创建一个基于类的CGLIB代理，无论目标bean是否是单例的。
4.  **NO**：不创建代理，直接返回目标bean实例。

示例代码如下：

@Bean
    @Scope(value = "prototype", proxyMode = ScopedProxyMode.DEFAULT)
    public MyPrototypeBean prototypeBean() {
        
        return new MyPrototypeBean();
    }
    
    @Bean
    @Scope(value = "singleton", proxyMode = ScopedProxyMode.INTERFACES)
    public MySingletonBean singletonBean() {
        
        return new MySingletonBean();
    }

在上述示例中，对于prototypeBean，使用了默认的代理模式，即根据目标bean的类型来决定使用JDK动态代理还是CGLIB代理。对于singletonBean，明确指定了使用基于接口的JDK动态代理。  
通过设置ScopedProxyMode参数，可以在使用@Scope注解时控制代理的创建方式，以解决作用域之间的依赖问题。

#### 四、Singleton ####

假设我们有一个名为UserService的类，它需要在整个应用程序中只有一个实例，并且在任何地方都可以访问该实例。这时候我们可以使用Singleton作用域来实现这个需求。

首先，我们需要在Spring配置文件中定义一个名为userService的bean，并将其作用域设置为Singleton。这可以通过在bean定义中添加scope属性来完成。

这样就创建了一个名为userService的bean，并且它的作用域是Singleton。这意味着在整个应用程序中只有一个UserService实例，并且在任何地方都可以访问该实例。

接下来，我们可以在其他类中注入userService bean，以便在需要时使用它。这可以通过使用@Autowired注解来完成。

@Service
    public class SomeService {
        
        @Autowired
        private UserService userService;
        // ...
    }

在这个例子中，我们将userService bean注入到SomeService类中，并将其保存在一个私有变量中。这样，我们就可以在SomeService类中使用userService bean。

Singleton作用域的作用是确保在整个应用程序中只有一个实例，并且在任何地方都可以访问该实例。这可以避免创建多个相同的对象，并节省内存和资源。同时，Singleton作用域也可以确保在整个应用程序中共享状态和数据。

#### 五、Prototype ####

假设我们有一个名为OrderService的类，它需要在每次调用时创建一个新的实例，并且每个实例之间相互独立。这时候我们可以使用Prototype作用域来实现这个需求。

首先，我们需要在Spring配置文件中定义一个名为orderService的bean，并将其作用域设置为Prototype。这可以通过在bean定义中添加scope属性来完成。

这样就创建了一个名为orderService的bean，并且它的作用域是Prototype。这意味着每次从容器中获取orderService bean时，都会创建一个新的实例。

接下来，我们可以在其他类中注入orderService bean，并在需要时使用它。这可以通过使用@Autowired注解来完成。

@Service
    public class SomeService {
        
        @Autowired
        private OrderService orderService;
        // ...
    }

在这个例子中，我们将orderService bean注入到SomeService类中，并将其保存在一个私有变量中。每次调用SomeService类时，都会使用一个新的orderService实例。

Prototype作用域的作用是每次调用时创建一个新的实例，并且每个实例之间相互独立。这可以适用于那些需要在每次调用时创建新对象的场景，例如每次请求都需要一个新的Service实例。使用Prototype作用域可以避免共享状态和数据，每次获取的实例都是全新的。

#### 六、Request ####

假设我们有一个名为OrderService的类，它需要在每个HTTP请求期间共享同一个实例。这时候我们可以使用Request作用域来实现这个需求。

首先，我们需要在Spring配置文件中定义一个名为orderService的bean，并将其作用域设置为Request。这可以通过在bean定义中添加scope属性来完成。

这样就创建了一个名为orderService的bean，并且它的作用域是Request。这意味着每个HTTP请求都会创建一个新的实例，并且在整个请求期间都可以共享使用。  
接下来，我们可以在需要使用orderService的地方进行注入。在Web应用程序中，可以使用@Autowired注解将orderService注入到控制器或服务类中。

@Controller
    public class OrderController {
        
        @Autowired
        private OrderService orderService;
        // ...
    }

在这个例子中，我们将orderService注入到OrderController控制器中，并将其保存在一个私有变量中。每个HTTP请求都会使用同一个orderService实例。

Request作用域的作用是在每个HTTP请求期间共享同一个实例。这适用于那些需要在同一个请求中共享数据和状态的场景。使用Request作用域可以确保每个请求都有自己的实例，避免了多个请求之间的数据混乱和冲突。

#### 七、Session ####

假设我们有一个名为UserSession的类，它需要在用户会话期间共享同一个实例。这时候我们可以使用Session作用域来实现这个需求。

首先，我们需要在Spring配置文件中定义一个名为userSession的bean，并将其作用域设置为Session。这可以通过在bean定义中添加scope属性来完成。

这样就创建了一个名为userSession的bean，并且它的作用域是Session。这意味着每个用户会话都会创建一个新的实例，并且在整个会话期间都可以共享使用。

接下来，我们可以在需要使用userSession的地方进行注入。在Web应用程序中，可以使用@Autowired注解将userSession注入到控制器或服务类中。

@Controller
    public class UserController {
        
        @Autowired
        private UserSession userSession;
        // ...
    }

在这个例子中，我们将userSession注入到UserController控制器中，并将其保存在一个私有变量中。每个用户会话都会使用同一个userSession实例。

Session作用域的作用是在每个用户会话期间共享同一个实例。这适用于那些需要在同一个会话中共享数据和状态的场景。使用Session作用域可以确保每个会话都有自己的实例，避免了多个用户之间的数据混乱和冲突。

#### 八、bean的作用域是如何实现的 ####

Spring底层是通过使用BeanFactory和相应的作用域接口来实现bean的作用域的。在Spring中，BeanFactory是负责创建和管理bean的核心接口。它定义了获取bean实例的方法，并且可以根据作用域的不同来管理bean的生命周期。

Spring提供了几种常用的作用域，包括单例(Singleton)、原型(Prototype)、会话(Session)、请求(Request)等。每种作用域都有不同的生命周期和使用方式。

在Spring中，单例作用域是默认的作用域。当一个bean被定义为单例时，Spring容器会在第一次被请求时创建该bean的实例，并在之后的请求中重用同一个实例。这种作用域适用于那些需要在应用程序中共享的bean，比如服务类或数据访问对象。

原型作用域是指每次请求都会创建一个新的实例。当一个bean被定义为原型时，Spring容器会在每次请求时都创建一个新的实例。这种作用域适用于那些需要每次请求都使用新的实例的bean，比如控制器或会话管理器。

会话作用域是指在用户会话期间共享同一个实例。当一个bean被定义为会话作用域时，Spring容器会在每个用户会话中创建一个新的实例，并在整个会话期间共享使用。这种作用域适用于那些需要在同一个会话中共享数据和状态的bean，比如用户会话信息或购物车。

请求作用域是指在每次请求中共享同一个实例。当一个bean被定义为请求作用域时，Spring容器会在每次请求中创建一个新的实例，并在整个请求期间共享使用。这种作用域适用于那些需要在同一个请求中共享数据和状态的bean，比如请求参数或用户认证信息。

Spring底层通过相应的作用域接口来管理不同作用域的bean实例。例如，SingletonBeanRegistry接口用于管理单例作用域的bean实例，SessionScope接口用于管理会话作用域的bean实例，RequestScope接口用于管理请求作用域的bean实例等。

总结来说，Spring底层通过BeanFactory和相应的作用域接口来实现bean的作用域。不同的作用域适用于不同的场景，可以根据需求选择合适的作用域来管理bean的生命周期和共享方式。

在Spring中，BeanFactory是一个负责管理bean的工厂，它负责创建、配置和管理bean对象。作用域接口定义了bean的生命周期和可见范围。

伪代码入下：

// 定义一个作用域接口
    public interface Scope {
        
        Object get(String name, ObjectFactory<?> objectFactory);
        Object remove(String name);
        void registerDestructionCallback(String name, Runnable callback);
        Object resolveContextualObject(String key);
        String getConversationId();
    }
    
    // 定义一个单例作用域实现类
    public class SingletonScope implements Scope {
        
        private Map<String, Object> singletonObjects = new HashMap<>();
         @Override
        public Object get(String name, ObjectFactory<?> objectFactory) {
        
            if (!singletonObjects.containsKey(name)) {
        
                singletonObjects.put(name, objectFactory.getObject());
            }
            return singletonObjects.get(name);
        }
         @Override
        public Object remove(String name) {
        
            return singletonObjects.remove(name);
        }
         @Override
        public void registerDestructionCallback(String name, Runnable callback) {
        
            // 在单例作用域中，销毁回调不需要处理
        }
         @Override
        public Object resolveContextualObject(String key) {
        
            // 在单例作用域中，上下文对象不需要处理
            return null;
        }
         @Override
        public String getConversationId() {
        
            // 在单例作用域中，会话ID不需要处理
            return null;
        }
    }
    
    // 定义一个原型作用域实现类
    public class PrototypeScope implements Scope {
        
        @Override
        public Object get(String name, ObjectFactory<?> objectFactory) {
        
            return objectFactory.getObject();
        }
         @Override
        public Object remove(String name) {
        
            // 在原型作用域中，对象不需要移除
            return null;
        }
         @Override
        public void registerDestructionCallback(String name, Runnable callback) {
        
            // 在原型作用域中，销毁回调不需要处理
        }
         @Override
        public Object resolveContextualObject(String key) {
        
            // 在原型作用域中，上下文对象不需要处理
            return null;
        }
         @Override
        public String getConversationId() {
        
            // 在原型作用域中，会话ID不需要处理
            return null;
        }
    }
    
    // 在配置类中使用作用域
    @Configuration
    public class AppConfig {
        
        @Bean
        @Scope("singleton")
        public SingletonBean singletonBean() {
        
            return new SingletonBean();
        }
         @Bean
        @Scope("prototype")
        public PrototypeBean prototypeBean() {
        
            return new PrototypeBean();
        }
    }
    
    // 测试代码
    public class Main {
        
        public static void main(String[] args) {
        
            // 创建一个Spring应用上下文
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
            applicationContext.register(AppConfig.class);
            applicationContext.refresh();
             // 获取单例作用域的bean
            SingletonBean singletonBean1 = applicationContext.getBean(SingletonBean.class);
            SingletonBean singletonBean2 = applicationContext.getBean(SingletonBean.class);
            System.out.println(singletonBean1 == singletonBean2); // 输出: true
             // 获取原型作用域的bean
            PrototypeBean prototypeBean1 = applicationContext.getBean(PrototypeBean.class);
            PrototypeBean prototypeBean2 = applicationContext.getBean(PrototypeBean.class);
            System.out.println(prototypeBean1 == prototypeBean2); // 输出: false
             // 关闭应用上下文
            applicationContext.close();
        }
    }

>  精彩专栏推荐订阅：在下方专栏??

>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[bddcb8cec5d647199d3714a9cfe93e1b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/6a60798fcb5943a4a9b0030647fdf70e.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[Java]: https://blog.csdn.net/qq_37967783/article/details/130940512
[b96014232f3846298d0274d54342c312.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/2a6d5dea27514fd09a0c01a2d202afd1.png
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center