深度解析Spring內(nèi)置作用域及其在實(shí)踐中的應(yīng)用

更新時(shí)間：2023年06月13日 10:21:38 作者：磚業(yè)洋__

這篇文章主要詳細(xì)介紹了Spring內(nèi)置的作用域類型及其在實(shí)踐中的應(yīng)用，文中有詳細(xì)的代碼示例，對我們的餓學(xué)習(xí)或工作有一定的參考價(jià)值，感興趣的同學(xué)可以借鑒閱讀

1. Spring的內(nèi)置作用域

我們來看看Spring內(nèi)置的作用域類型。在5.x版本中，Spring內(nèi)置了六種作用域：

singleton：在IOC容器中，對應(yīng)的Bean只有一個(gè)實(shí)例，所有對它的引用都指向同一個(gè)對象。這種作用域非常適合對于無狀態(tài)的Bean，比如工具類或服務(wù)類。
prototype：每次請求都會(huì)創(chuàng)建一個(gè)新的Bean實(shí)例，適合對于需要維護(hù)狀態(tài)的Bean。
request：在Web應(yīng)用中，為每個(gè)HTTP請求創(chuàng)建一個(gè)Bean實(shí)例。適合在一個(gè)請求中需要維護(hù)狀態(tài)的場景，如跟蹤用戶行為信息。
session：在Web應(yīng)用中，為每個(gè)HTTP會(huì)話創(chuàng)建一個(gè)Bean實(shí)例。適合需要在多個(gè)請求之間維護(hù)狀態(tài)的場景，如用戶會(huì)話。
application：在整個(gè)Web應(yīng)用期間，創(chuàng)建一個(gè)Bean實(shí)例。適合存儲(chǔ)全局的配置數(shù)據(jù)等。
websocket：在每個(gè)WebSocket會(huì)話中創(chuàng)建一個(gè)Bean實(shí)例。適合WebSocket通信場景。

我們需要重點(diǎn)學(xué)習(xí)兩種作用域：singleton和prototype。在大多數(shù)情況下singleton和prototype這兩種作用域已經(jīng)足夠滿足需求。

2. singleton作用域

2.1 singleton作用域的定義和用途

Singleton是Spring的默認(rèn)作用域。在這個(gè)作用域中，Spring容器只會(huì)創(chuàng)建一個(gè)實(shí)例，所有對該bean的請求都將返回這個(gè)唯一的實(shí)例。

例如，我們定義一個(gè)名為Plaything的類，并將其作為一個(gè)bean：

@Component
public class Plaything {
    public Plaything() {
        System.out.println("Plaything constructor run ...");
    }
}

在這個(gè)例子中，Plaything是一個(gè)singleton作用域的bean。無論我們在應(yīng)用中的哪個(gè)地方請求這個(gè)bean，Spring都會(huì)返回同一個(gè)Plaything實(shí)例。

下面的例子展示了如何創(chuàng)建一個(gè)單實(shí)例的Bean：

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
public class Plaything {
    public Plaything() {
        System.out.println("Plaything constructor run ...");
    }
}

這里可以在Plaything類加上@Scope(BeanDefinition.SCOPE_SINGLETON)，但是因?yàn)槭悄J(rèn)作用域是Singleton，所以沒必要加。

package com.example.demo.configuration;
import com.example.demo.bean.Kid;
import com.example.demo.bean.Plaything;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanScopeConfiguration {
    @Bean
    public Kid kid1(Plaything plaything1) {
        Kid kid = new Kid();
        kid.setPlaything(plaything1);
        return kid;
    }
    @Bean
    public Kid kid2(Plaything plaything2) {
        Kid kid = new Kid();
        kid.setPlaything(plaything2);
        return kid;
    }
}

package com.example.demo.application;
import com.example.demo.bean.Kid;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
@SpringBootApplication
@ComponentScan("com.example")
public class DemoApplication {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(DemoApplication.class);
        context.getBeansOfType(Kid.class).forEach((name, kid) -> {
            System.out.println(name + " : " + kid.getPlaything());
        });
    }
}

在Spring IoC容器的工作中，掃描過程只會(huì)創(chuàng)建bean的定義，真正的bean實(shí)例是在需要注入或者通過getBean方法獲取時(shí)才會(huì)創(chuàng)建。這個(gè)過程被稱為bean的初始化。

這里運(yùn)行 ctx.getBeansOfType(Kid.class).forEach((name, kid) -> System.out.println(name + " : " + kid.getPlaything())); 時(shí)，Spring IoC容器會(huì)查找所有的Kid類型的bean定義，然后為每一個(gè)找到的bean定義創(chuàng)建實(shí)例（如果這個(gè)bean定義還沒有對應(yīng)的實(shí)例），并注入相應(yīng)的依賴。

運(yùn)行結(jié)果：

三個(gè) Kid 的 Plaything bean是相同的，說明默認(rèn)情況下 Plaything 是一個(gè)單例bean，整個(gè)Spring應(yīng)用中只有一個(gè) Plaything bean被創(chuàng)建。

為什么會(huì)有3個(gè)kid？

Kid: 這個(gè)是通過在Kid類上標(biāo)注的@Component注解自動(dòng)創(chuàng)建的。Spring在掃描時(shí)發(fā)現(xiàn)這個(gè)注解，就會(huì)自動(dòng)在IOC容器中注冊這個(gè)bean。這個(gè)Bean的名字默認(rèn)是將類名的首字母小寫kid。
kid1: 在 BeanScopeConfiguration 中定義，通過kid1(Plaything plaything1)方法創(chuàng)建，并且注入了plaything1。
kid2: 在 BeanScopeConfiguration 中定義，通過kid2(Plaything plaything2)方法創(chuàng)建，并且注入了plaything2。

2.2 singleton作用域線程安全問題

需要注意的是，雖然singleton Bean只會(huì)有一個(gè)實(shí)例，但Spring并不會(huì)解決其線程安全問題，開發(fā)者需要根據(jù)實(shí)際場景自行處理。

我們通過一個(gè)代碼示例來說明在多線程環(huán)境中出現(xiàn)singleton Bean的線程安全問題。

首先，我們創(chuàng)建一個(gè)名為Counter的singleton Bean，這個(gè)Bean有一個(gè)count變量，提供increment方法來增加count的值：

package com.example.demo.bean;
import org.springframework.stereotype.Component;
@Component
public class Counter {
    private int count = 0;
    public int increment() {
        return ++count;
    }
}

然后，我們創(chuàng)建一個(gè)名為CounterService的singleton Bean，這個(gè)Bean依賴于Counter，在increaseCount方法中，我們調(diào)用counter.increment方法：

package com.example.demo.service;
import com.example.demo.bean.Counter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class CounterService {
	@Autowired
    private final Counter counter;
    public void increaseCount() {
        counter.increment();
    }
}

我們在多線程環(huán)境中調(diào)用counterService.increaseCount方法時(shí)，就可能出現(xiàn)線程安全問題。因?yàn)?code>counter.increment方法并非線程安全，多個(gè)線程同時(shí)調(diào)用此方法可能會(huì)導(dǎo)致count值出現(xiàn)預(yù)期外的結(jié)果。

要解決這個(gè)問題，我們需要使counter.increment方法線程安全。

這里可以使用原子變量，在Counter類中，我們可以使用AtomicInteger來代替int類型的count，因?yàn)?code>AtomicInteger類中的方法是線程安全的，且其性能通常優(yōu)于synchronized關(guān)鍵字。

package com.example.demo.bean;
import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicInteger;
@Component
public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    public int increment() {
        return count.incrementAndGet();
    }
}

盡管優(yōu)化后已經(jīng)使Counter類線程安全，但在設(shè)計(jì)Bean時(shí)，我們應(yīng)該盡可能地減少可變狀態(tài)。這是因?yàn)榭勺儬顟B(tài)使得并發(fā)編程變得復(fù)雜，而無狀態(tài)的Bean通常更容易理解和測試。

什么是無狀態(tài)的Bean呢？ 如果一個(gè)Bean不持有任何狀態(tài)信息，也就是說，同樣的輸入總是會(huì)得到同樣的輸出，那么這個(gè)Bean就是無狀態(tài)的。反之，則是有狀態(tài)的Bean。

3. prototype作用域

3.1 prototype作用域的定義和用途

在prototype作用域中，Spring容器會(huì)為每個(gè)請求創(chuàng)建一個(gè)新的bean實(shí)例。

例如，我們定義一個(gè)名為Plaything的類，并將其作用域設(shè)置為prototype：

package com.example.demo.bean;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class Plaything {
    public Plaything() {
        System.out.println("Plaything constructor run ...");
    }
}

在這個(gè)例子中，Plaything是一個(gè)prototype作用域的bean。每次我們請求這個(gè)bean，Spring都會(huì)創(chuàng)建一個(gè)新的Plaything實(shí)例。

我們只需要修改上面的Plaything類，其他的類不用動(dòng)。

打印結(jié)果：

這個(gè)@Scope(BeanDefinition.SCOPE_PROTOTYPE)可以寫成@Scope("prototype")，按照規(guī)范，還是利用已有的常量比較好。

3.2 prototype作用域在開發(fā)中的例子

以我個(gè)人來說，我在excel多線程上傳的時(shí)候用到過這個(gè)，當(dāng)時(shí)是EasyExcel框架，我給一部分關(guān)鍵代碼展示一下如何在Spring中使用prototype作用域來處理多線程環(huán)境下的任務(wù)（實(shí)際業(yè)務(wù)會(huì)更復(fù)雜），大家可以對比，如果用prototype作用域和使用new對象的形式在實(shí)際開發(fā)中有什么區(qū)別。

使用prototype作用域的例子

@Resource
private ApplicationContext context;
@PostMapping("/user/upload")
public ResultModel upload(@RequestParam("multipartFile") MultipartFile multipartFile) {
	......
	ExecutorService es = new ThreadPoolExceutor(10, 16, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(2000), new ThreadPoolExecutor.CallerRunPolicy());
	......
	EasyExcel.read(multipartFile.getInputStream(), UserDataUploadVO.class, 
		new PageReadListener<UserDataUploadVO>(dataList ->{
		......
		// 多線程處理上傳excel數(shù)據(jù)
			Future<?> future = es.submit(context.getBean(AsyncUploadHandler.class, user, dataList, errorCount));
		......
		})).sheet().doRead();
	......
}

AsyncUploadHandler.java

@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class AsyncUploadHandler implements Runnable {
	private User user;
	private List<UserDataUploadVO> dataList;
	private AtomicInteger errorCount;
	@Resource
	private RedisService redisService;
	@Resource
	private CompanyManagementMapper companyManagementMapper;
	public AsyncUploadHandler(user, List<UserDataUploadVO> dataList, AtomicInteger errorCount) {
		this.user = user;
		this.dataList = dataList;
		this.errorCount = errorCount;
	}
	......
}

AsyncUploadHandler類是一個(gè)prototype作用域的bean，它被用來處理上傳的Excel數(shù)據(jù)。由于并發(fā)上傳的每個(gè)任務(wù)可能需要處理不同的數(shù)據(jù)，并且可能需要在不同的用戶上下文中執(zhí)行，因此每個(gè)任務(wù)都需要有自己的AsyncUploadHandler bean。這就是為什么需要將AsyncUploadHandler定義為prototype作用域的原因。

由于AsyncUploadHandler是由Spring管理的，我們可以直接使用@Resource注解來注入其他的bean，例如RedisService和CompanyManagementMapper。

把AsyncUploadHandler交給Spring容器管理，里面依賴的容器對象可以直接用@Resource注解注入。如果采用new出來的對象，那么這些對象只能從外面注入好了再傳入進(jìn)去。

不使用prototype作用域改用new對象的例子

@PostMapping("/user/upload")
public ResultModel upload(@RequestParam("multipartFile") MultipartFile multipartFile) {
	......
	ExecutorService es = new ThreadPoolExceutor(10, 16, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(2000), new ThreadPoolExecutor.CallerRunPolicy());
	......
	EasyExcel.read(multipartFile.getInputStream(), UserDataUploadVO.class, 
		new PageReadListener<UserDataUploadVO>(dataList ->{
		......
		// 多線程處理上傳excel數(shù)據(jù)
			Future<?> future = es.submit(new AsyncUploadHandler(user, dataList, errorCount, redisService, companyManagementMapper));
		......
		})).sheet().doRead();
	......
}

AsyncUploadHandler.java

public class AsyncUploadHandler implements Runnable {
	private User user;
	private List<UserDataUploadVO> dataList;
	private AtomicInteger errorCount;
	private RedisService redisService;
	private CompanyManagementMapper companyManagementMapper;
	public AsyncUploadHandler(user, List<UserDataUploadVO> dataList, AtomicInteger errorCount, 
						RedisService redisService, CompanyManagementMapper companyManagementMapper) {
		this.user = user;
		this.dataList = dataList;
		this.errorCount = errorCount;
		this.redisService = redisService;
		this.companyManagementMapper = companyManagementMapper;
	}
	......
}

如果直接新建AsyncUploadHandler對象，則需要手動(dòng)傳入所有的依賴，這會(huì)使代碼變得更復(fù)雜更難以管理，而且還需要手動(dòng)管理AsyncUploadHandler的生命周期。

4. request作用域（了解）

request作用域：Bean在一個(gè)HTTP請求內(nèi)有效。當(dāng)請求開始時(shí)，Spring容器會(huì)為每個(gè)新的HTTP請求創(chuàng)建一個(gè)新的Bean實(shí)例，這個(gè)Bean在當(dāng)前HTTP請求內(nèi)是有效的，請求結(jié)束后，Bean就會(huì)被銷毀。如果在同一個(gè)請求中多次獲取該Bean，就會(huì)得到同一個(gè)實(shí)例，但是在不同的請求中獲取的實(shí)例將會(huì)不同。

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopedBean {
    // 在一次Http請求內(nèi)共享的數(shù)據(jù)
    private String requestData;
    public void setRequestData(String requestData) {
        this.requestData = requestData;
    }
    public String getRequestData() {
        return this.requestData;
    }
}

上述Bean在一個(gè)HTTP請求的生命周期內(nèi)是一個(gè)單例，每個(gè)新的HTTP請求都會(huì)創(chuàng)建一個(gè)新的Bean實(shí)例。

5. session作用域（了解）

session作用域：Bean是在同一個(gè)HTTP會(huì)話（Session）中是單例的。也就是說，從用戶登錄開始，到用戶退出登錄（或者Session超時(shí)）結(jié)束，這個(gè)過程中，不管用戶進(jìn)行了多少次HTTP請求，只要是在同一個(gè)會(huì)話中，都會(huì)使用同一個(gè)Bean實(shí)例。

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class SessionScopedBean {
    // 在一個(gè)Http會(huì)話內(nèi)共享的數(shù)據(jù)
    private String sessionData;
    public void setSessionData(String sessionData) {
        this.sessionData = sessionData;
    }
    public String getSessionData() {
        return this.sessionData;
    }
}

這樣的設(shè)計(jì)對于存儲(chǔ)和管理會(huì)話級別的數(shù)據(jù)非常有用，例如用戶的登錄信息、購物車信息等。因?yàn)樗鼈兪窃谕粋€(gè)會(huì)話中保持一致的，所以使用session作用域的Bean可以很好地解決這個(gè)問題。

但是實(shí)際開發(fā)中沒人這么干，會(huì)話id都會(huì)存在數(shù)據(jù)庫，根據(jù)會(huì)話id就能在各種表中獲取數(shù)據(jù)，避免頻繁查庫也是把關(guān)鍵信息序列化后存在Redis。

6. application作用域（了解）

application作用域：在整個(gè)Web應(yīng)用的生命周期內(nèi)，Spring容器只會(huì)創(chuàng)建一個(gè)Bean實(shí)例。這個(gè)Bean在Web應(yīng)用的生命周期內(nèi)都是有效的，當(dāng)Web應(yīng)用停止后，Bean就會(huì)被銷毀。

@Component
@Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ApplicationScopedBean {
    // 在整個(gè)Web應(yīng)用的生命周期內(nèi)共享的數(shù)據(jù)
    private String applicationData;
    public void setApplicationData(String applicationData) {
        this.applicationData = applicationData;
    }
    public String getApplicationData() {
        return this.applicationData;
    }
}

如果在一個(gè)application作用域的Bean上調(diào)用setter方法，那么這個(gè)變更將對所有用戶和會(huì)話可見。后續(xù)對這個(gè)Bean的所有調(diào)用（包括getter和setter）都將影響到同一個(gè)Bean實(shí)例，后面的調(diào)用會(huì)覆蓋前面的狀態(tài)。

7. websocket作用域（了解）

websocket作用域：Bean 在每一個(gè)新的 WebSocket 會(huì)話中都會(huì)被創(chuàng)建一次，就像 session 作用域的 Bean 在每一個(gè) HTTP 會(huì)話中都會(huì)被創(chuàng)建一次一樣。這個(gè)Bean在整個(gè)WebSocket會(huì)話內(nèi)都是有效的，當(dāng)WebSocket會(huì)話結(jié)束后，Bean就會(huì)被銷毀。

@Component
@Scope(value = "websocket", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class WebSocketScopedBean {
    // 在一個(gè)WebSocket會(huì)話內(nèi)共享的數(shù)據(jù)
    private String socketData;
    public void setSocketData(String socketData) {
        this.socketData = socketData;
    }
    public String getSocketData() {
        return this.socketData;
    }
}

上述Bean在一個(gè)WebSocket會(huì)話的生命周期內(nèi)是一個(gè)單例，每個(gè)新的WebSocket會(huì)話都會(huì)創(chuàng)建一個(gè)新的Bean實(shí)例。

這個(gè)作用域需要Spring Websocket模塊支持，并且應(yīng)用需要配置為使用websocket。

以上就是深度解析Spring內(nèi)置作用域及其在實(shí)踐中的應(yīng)用的詳細(xì)內(nèi)容，更多關(guān)于Spring內(nèi)置作用域及應(yīng)用的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: