ToB企服应用市场:ToB评测及商务社交产业平台

标题: 解析Spring内置作用域及其在实践中的应用 [打印本页]

作者: 兜兜零元    时间: 2023-6-15 21:43
标题: 解析Spring内置作用域及其在实践中的应用
摘要:本文详细解析了Spring的内置作用域,包括Singleton、Prototype、Request、Session、Application和WebSocket作用域,并通过实例讲解了它们在实际开发中的应用。
本文分享自华为云社区《Spring高手之路4——深度解析Spring内置作用域及其在实践中的应用》,作者:砖业洋__ 。
本文详细解析了Spring的内置作用域,包括Singleton、Prototype、Request、Session、Application和WebSocket作用域,并通过实例讲解了它们在实际开发中的应用。特别是Singleton和Prototype作用域,我们深入讨论了它们的定义、用途以及如何处理相关的线程安全问题。通过阅读本文,读者可以更深入地理解Spring作用域,并在实际开发中更有效地使用
1. Spring的内置作用域

我们来看看Spring内置的作用域类型。在5.x版本中,Spring内置了六种作用域:

我们需要重点学习两种作用域:singleton和prototype。在大多数情况下singleton和prototype这两种作用域已经足够满足需求。
2. singleton作用域

2.1 singleton作用域的定义和用途

Singleton是Spring的默认作用域。在这个作用域中,Spring容器只会创建一个实例,所有对该bean的请求都将返回这个唯一的实例。
例如,我们定义一个名为Plaything的类,并将其作为一个bean:
  
  1. @Component
  2. public class Plaything {
  3. public Plaything() {
  4. System.out.println("Plaything constructor run ...");
  5. }
  6. }
复制代码
  在这个例子中,Plaything是一个singleton作用域的bean。无论我们在应用中的哪个地方请求这个bean,Spring都会返回同一个Plaything实例。
下面的例子展示了如何创建一个单实例的Bean:
  
  1. package com.example.demo.bean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class Kid {  private Plaything plaything;  @Autowired  public void setPlaything(Plaything plaything) {  this.plaything = plaything;  }  public Plaything getPlaything() {  return plaything;  } } package com.example.demo.bean; import org.springframework.stereotype.Component; @Component
  2. public class Plaything {
  3. public Plaything() {
  4. System.out.println("Plaything constructor run ...");
  5. }
  6. }
复制代码
  这里可以在Plaything类加上@Scope(BeanDefinition.SCOPE_SINGLETON),但是因为是默认作用域是Singleton,所以没必要加。
  
  1. package com.example.demo.configuration;
  2. import com.example.demo.bean.Kid;
  3. import com.example.demo.bean.Plaything;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. @Configuration
  7. public class BeanScopeConfiguration {
  8. @Bean
  9. public Kid kid1(Plaything plaything1) {
  10. Kid kid = new Kid();
  11. kid.setPlaything(plaything1);
  12. return kid;
  13. }
  14. @Bean
  15. public Kid kid2(Plaything plaything2) {
  16. Kid kid = new Kid();
  17. kid.setPlaything(plaything2);
  18. return kid;
  19. }
  20. }
  21. package com.example.demo.application;
  22. import com.example.demo.bean.Kid;
  23. import org.springframework.boot.autoconfigure.SpringBootApplication;
  24. import org.springframework.context.ApplicationContext;
  25. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  26. import org.springframework.context.annotation.ComponentScan;
  27. @SpringBootApplication
  28. @ComponentScan("com.example")
  29. public class DemoApplication {
  30. public static void main(String[] args) {
  31. ApplicationContext context = new AnnotationConfigApplicationContext(DemoApplication.class);
  32. context.getBeansOfType(Kid.class).forEach((name, kid) -> {
  33. System.out.println(name + " : " + kid.getPlaything());
  34. });
  35. }
  36. }
复制代码
  在Spring IoC容器的工作中,扫描过程只会创建bean的定义,真正的bean实例是在需要注入或者通过getBean方法获取时才会创建。这个过程被称为bean的初始化。
这里运行 ctx.getBeansOfType(Kid.class).forEach((name, kid) -> System.out.println(name + " : " + kid.getPlaything())); 时,Spring IoC容器会查找所有的Kid类型的bean定义,然后为每一个找到的bean定义创建实例(如果这个bean定义还没有对应的实例),并注入相应的依赖。
运行结果:
三个 Kid 的 Plaything bean是相同的,说明默认情况下 Plaything 是一个单例bean,整个Spring应用中只有一个 Plaything bean被创建。
为什么会有3个kid?
2.2 singleton作用域线程安全问题

需要注意的是,虽然singleton Bean只会有一个实例,但Spring并不会解决其线程安全问题,开发者需要根据实际场景自行处理。
我们通过一个代码示例来说明在多线程环境中出现singleton Bean的线程安全问题。
首先,我们创建一个名为Counter的singleton Bean,这个Bean有一个count变量,提供increment方法来增加count的值:
  
  1. package com.example.demo.bean;
  2. import org.springframework.stereotype.Component;
  3. @Component
  4. public class Counter {
  5. private int count = 0;
  6. public int increment() {
  7. return ++count;
  8. }
  9. }
复制代码
  然后,我们创建一个名为CounterService的singleton Bean,这个Bean依赖于Counter,在increaseCount方法中,我们调用counter.increment方法:
  
  1. package com.example.demo.service;
  2. import com.example.demo.bean.Counter;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Service;
  5. @Service
  6. public class CounterService {
  7. @Autowired
  8. private final Counter counter;
  9. public void increaseCount() {
  10. counter.increment();
  11. }
  12. }
复制代码
  1. 我们在多线程环境中调用counterService.increaseCount方法时,就可能出现线程安全问题。因为counter.increment方法并非线程安全,多个线程同时调用此方法可能会导致count值出现预期外的结果。
复制代码
要解决这个问题,我们需要使counter.increment方法线程安全。
这里可以使用原子变量,在Counter类中,我们可以使用AtomicInteger来代替int类型的count,因为AtomicInteger类中的方法是线程安全的,且其性能通常优于synchronized关键字。
  
  1. package com.example.demo.bean;
  2. import org.springframework.stereotype.Component;
  3. import java.util.concurrent.atomic.AtomicInteger;
  4. @Component
  5. public class Counter {
  6. private AtomicInteger count = new AtomicInteger(0);
  7. public int increment() {
  8. return count.incrementAndGet();
  9. }
  10. }
复制代码
  尽管优化后已经使Counter类线程安全,但在设计Bean时,我们应该尽可能地减少可变状态。这是因为可变状态使得并发编程变得复杂,而无状态的Bean通常更容易理解和测试。
什么是无状态的Bean呢? 如果一个Bean不持有任何状态信息,也就是说,同样的输入总是会得到同样的输出,那么这个Bean就是无状态的。反之,则是有状态的Bean。
3. prototype作用域

3.1 prototype作用域的定义和用途

在prototype作用域中,Spring容器会为每个请求创建一个新的bean实例。
例如,我们定义一个名为Plaything的类,并将其作用域设置为prototype:
  
  1. package com.example.demo.bean;
  2. import org.springframework.beans.factory.config.BeanDefinition;
  3. import org.springframework.context.annotation.Scope;
  4. import org.springframework.stereotype.Component;
  5. @Component
  6. @Scope(BeanDefinition.SCOPE_PROTOTYPE)
  7. public class Plaything {
  8. public Plaything() {
  9. System.out.println("Plaything constructor run ...");
  10. }
  11. }
复制代码
  在这个例子中,Plaything是一个prototype作用域的bean。每次我们请求这个bean,Spring都会创建一个新的Plaything实例。
我们只需要修改上面的Plaything类,其他的类不用动。
打印结果:
这个@Scope(BeanDefinition.SCOPE_PROTOTYPE)可以写成@Scope("prototype"),按照规范,还是利用已有的常量比较好。
3.2 prototype作用域在开发中的例子

以我个人来说,我在excel多线程上传的时候用到过这个,当时是EasyExcel框架,我给一部分关键代码展示一下如何在Spring中使用prototype作用域来处理多线程环境下的任务(实际业务会更复杂),大家可以对比,如果用prototype作用域和使用new对象的形式在实际开发中有什么区别。
使用prototype作用域的例子
  
  1. @Resource
  2. private ApplicationContext context;
  3. @PostMapping("/user/upload")
  4. public ResultModel upload(@RequestParam("multipartFile") MultipartFile multipartFile) {
  5. ......
  6. ExecutorService es = new ThreadPoolExceutor(10, 16, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(2000), new ThreadPoolExecutor.CallerRunPolicy());
  7. ......
  8. EasyExcel.read(multipartFile.getInputStream(), UserDataUploadVO.class,
  9. new PageReadListener<UserDataUploadVO>(dataList ->{
  10. ......
  11. // 多线程处理上传excel数据
  12. Future<?> future = es.submit(context.getBean(AsyncUploadHandler.class, user, dataList, errorCount));
  13. ......
  14. })).sheet().doRead();
  15. ......
  16. }
复制代码
  AsyncUploadHandler.java
  
  1. @Component
  2. @Scope(BeanDefinition.SCOPE_PROTOTYPE)
  3. public class AsyncUploadHandler implements Runnable {
  4. private User user;
  5. private List<UserDataUploadVO> dataList;
  6. private AtomicInteger errorCount;
  7. @Resource
  8. private RedisService redisService;
  9. ......
  10. @Resource
  11. private CompanyManagementMapper companyManagementMapper;
  12. public AsyncUploadHandler(user, List<UserDataUploadVO> dataList, AtomicInteger errorCount) {
  13. this.user = user;
  14. this.dataList = dataList;
  15. this.errorCount = errorCount;
  16. }
  17. @Override
  18. public void run() {
  19. ......
  20. }
  21. ......
  22. }
复制代码
  1. AsyncUploadHandler类是一个prototype作用域的bean,它被用来处理上传的Excel数据。由于并发上传的每个任务可能需要处理不同的数据,并且可能需要在不同的用户上下文中执行,因此每个任务都需要有自己的AsyncUploadHandler bean。这就是为什么需要将AsyncUploadHandler定义为prototype作用域的原因。
复制代码
由于AsyncUploadHandler是由Spring管理的,我们可以直接使用@Resource注解来注入其他的bean,例如RedisService和CompanyManagementMapper。
把AsyncUploadHandler交给Spring容器管理,里面依赖的容器对象可以直接用@Resource注解注入。如果采用new出来的对象,那么这些对象只能从外面注入好了再传入进去。
不使用prototype作用域改用new对象的例子
  
  1. @PostMapping("/user/upload")
  2. public ResultModel upload(@RequestParam("multipartFile") MultipartFile multipartFile) {
  3. ......
  4. ExecutorService es = new ThreadPoolExceutor(10, 16, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(2000), new ThreadPoolExecutor.CallerRunPolicy());
  5. ......
  6. EasyExcel.read(multipartFile.getInputStream(), UserDataUploadVO.class,
  7. new PageReadListener<UserDataUploadVO>(dataList ->{
  8. ......
  9. // 多线程处理上传excel数据
  10. Future<?> future = es.submit(new AsyncUploadHandler(user, dataList, errorCount, redisService, companyManagementMapper));
  11. ......
  12. })).sheet().doRead();
  13. ......
  14. }
复制代码
  AsyncUploadHandler.java
  
  1. public class AsyncUploadHandler implements Runnable {
  2. private User user;
  3. private List<UserDataUploadVO> dataList;
  4. private AtomicInteger errorCount;
  5. private RedisService redisService;
  6. private CompanyManagementMapper companyManagementMapper;
  7. ......
  8. public AsyncUploadHandler(user, List<UserDataUploadVO> dataList, AtomicInteger errorCount,
  9. RedisService redisService, CompanyManagementMapper companyManagementMapper) {
  10. this.user = user;
  11. this.dataList = dataList;
  12. this.errorCount = errorCount;
  13. this.redisService = redisService;
  14. this.companyManagementMapper = companyManagementMapper;
  15. }
  16. @Override
  17. public void run() {
  18. ......
  19. }
  20. ......
  21. }
复制代码
  如果直接新建AsyncUploadHandler对象,则需要手动传入所有的依赖,这会使代码变得更复杂更难以管理,而且还需要手动管理AsyncUploadHandler的生命周期。
4. request作用域(了解)

request作用域:Bean在一个HTTP请求内有效。当请求开始时,Spring容器会为每个新的HTTP请求创建一个新的Bean实例,这个Bean在当前HTTP请求内是有效的,请求结束后,Bean就会被销毁。如果在同一个请求中多次获取该Bean,就会得到同一个实例,但是在不同的请求中获取的实例将会不同。
  
  1. @Component
  2. @Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
  3. public class RequestScopedBean {
  4. // 在一次Http请求内共享的数据
  5. private String requestData;
  6. public void setRequestData(String requestData) {
  7. this.requestData = requestData;
  8. }
  9. public String getRequestData() {
  10. return this.requestData;
  11. }
  12. }
复制代码
  上述Bean在一个HTTP请求的生命周期内是一个单例,每个新的HTTP请求都会创建一个新的Bean实例。
5. session作用域(了解)

session作用域:Bean是在同一个HTTP会话(Session)中是单例的。也就是说,从用户登录开始,到用户退出登录(或者Session超时)结束,这个过程中,不管用户进行了多少次HTTP请求,只要是在同一个会话中,都会使用同一个Bean实例。
  
  1. @Component
  2. @Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
  3. public class SessionScopedBean {
  4. // 在一个Http会话内共享的数据
  5. private String sessionData;
  6. public void setSessionData(String sessionData) {
  7. this.sessionData = sessionData;
  8. }
  9. public String getSessionData() {
  10. return this.sessionData;
  11. }
  12. }
复制代码
  这样的设计对于存储和管理会话级别的数据非常有用,例如用户的登录信息、购物车信息等。因为它们是在同一个会话中保持一致的,所以使用session作用域的Bean可以很好地解决这个问题。
但是实际开发中没人这么干,会话id都会存在数据库,根据会话id就能在各种表中获取数据,避免频繁查库也是把关键信息序列化后存在Redis。
6. application作用域(了解)

application作用域:在整个Web应用的生命周期内,Spring容器只会创建一个Bean实例。这个Bean在Web应用的生命周期内都是有效的,当Web应用停止后,Bean就会被销毁。
  
  1. @Component
  2. @Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode = ScopedProxyMode.TARGET_CLASS)
  3. public class ApplicationScopedBean {
  4. // 在整个Web应用的生命周期内共享的数据
  5. private String applicationData;
  6. public void setApplicationData(String applicationData) {
  7. this.applicationData = applicationData;
  8. }
  9. public String getApplicationData() {
  10. return this.applicationData;
  11. }
  12. }
复制代码
  如果在一个application作用域的Bean上调用setter方法,那么这个变更将对所有用户和会话可见。后续对这个Bean的所有调用(包括getter和setter)都将影响到同一个Bean实例,后面的调用会覆盖前面的状态。
7. websocket作用域(了解)

websocket作用域:Bean 在每一个新的 WebSocket 会话中都会被创建一次,就像 session 作用域的 Bean 在每一个 HTTP 会话中都会被创建一次一样。这个Bean在整个WebSocket会话内都是有效的,当WebSocket会话结束后,Bean就会被销毁。
  
  1. @Component
  2. @Scope(value = "websocket", proxyMode = ScopedProxyMode.TARGET_CLASS)
  3. public class WebSocketScopedBean {
  4. // 在一个WebSocket会话内共享的数据
  5. private String socketData;
  6. public void setSocketData(String socketData) {
  7. this.socketData = socketData;
  8. }
  9. public String getSocketData() {
  10. return this.socketData;
  11. }
  12. }
复制代码
  上述Bean在一个WebSocket会话的生命周期内是一个单例,每个新的WebSocket会话都会创建一个新的Bean实例。
这个作用域需要Spring Websocket模块支持,并且应用需要配置为使用websocket。
 
点击关注,第一时间了解华为云新鲜技术~

免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!




欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4