Spring?Bean的作用域具體實(shí)現(xiàn)(單例、多例、請求、會話、Application)

更新時間：2025年08月06日 10:52:02 作者：椰椰椰耶

文章講解了Spring?IoC/?DI中Bean作用域的管理方式,涵蓋單例（singleton）、原型（prototype）及Web環(huán)境的request、session、application作用域,通過注解和配置區(qū)分不同作用域的實(shí)例創(chuàng)建規(guī)則,并通過測試驗(yàn)證其生命周期與共享特性,感興趣的朋友一起看看吧

概念

在 Spring Ioc&DI 戒斷，我們學(xué)習(xí)了 Spring 是如何幫助我們管理對象的

通過 @Controller，@Service，@Repository，@Component，@Configuration，@Bean 來聲明 Bean 對象
通過 ApplicationContext 或者 BeanFactory 來獲取對象
通過 @Autowired，Setter 方法或者構(gòu)造方法等來為應(yīng)用程序注入所依賴的 Bean 對象

我們來簡單回顧一下

通過 @Bean 聲明 bean，把 bean 存在 Spring 容器中

public class Dog {  
    private String name;  
    public void setName(String name) {  
        this.name = name;  
    }  
}

@Component  
public class DogBeanConfig {  
    @Bean  
    public Dog dog() {  
        Dog dog = new Dog();  
        dog.setName("旺旺");  
        return dog;  
    }  
}

從 Spring 容器中獲取 Bean
- 通過在代碼中直接注入 ApplicationContext 的方式

@SpringBootTest  
class ApplicationTests {  
    @Autowired  
    private ApplicationContext applicationContext;  
    @Test  
    void contextLoads() {  
        DogBeanConfig dog1 = applicationContext.getBean(DogBeanConfig.class);;  
        System.out.println(dog1);  
    }  
}

司改代碼，從 Spring 容器中多次獲取 Bean

@SpringBootTest  
class ApplicationTests {  
    @Autowired  
    private ApplicationContext applicationContext;  
    @Test  
    void contextLoads() {  
        DogBeanConfig dog1 = applicationContext.getBean(DogBeanConfig.class);;  
        System.out.println(dog1);  
        DogBeanConfig dog2 = applicationContext.getBean(DogBeanConfig.class);;  
        System.out.println(dog2);  
    }  
}

觀察運(yùn)行結(jié)果

發(fā)現(xiàn)輸出的 bean 對象地址是一樣的，說明每次從 Spring 容器中取出來的對象都是同一個

這也是“單例模式”
單例模式：確保一個類只有一個實(shí)例，多次創(chuàng)建也不會創(chuàng)建出多個實(shí)例

Bean 的作用域是值 Bean 在 Spring 框架中的某種行為模式

比如單例作用域：表示 Bean 在整個 Spring 中只有一份，它是全局共享的。那么當(dāng)其他人修改了這個值之后，那么另一個人讀到的就是被修改后的值

修改上述代碼，給 UserController 添加屬性 name

@SpringBootTest  
class ApplicationTests {  
    @Autowired  
    private ApplicationContext applicationContext;  
    @Test  
    void contextLoads() {  
        Dog dog1 = applicationContext.getBean(Dog.class);  
        dog1.setName("狗狗1");  
        System.out.println(dog1);  
        System.out.println(dog1.getName());  
        Dog dog2 = applicationContext.getBean(Dog.class);;  
        System.out.println(dog2);  
        System.out.println(dog2.getName());  
    }  
}

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

dog1 和 dog2 為同一個對象，dog2 拿到了 dog1 設(shè)置的值

那能不能將 bean 對象設(shè)置為非單例的（每次獲取的 bean 都是一個新對象呢）

這就是 Bean 的不同作用域了

Bean 的作用域

在 Spring 中支持 6 中作用域，后 4 種在 Spring MVC 環(huán)境才生效

singleton：單例作用域
- 每個 Spring Ioc 容器內(nèi)同名稱的 Bean 只有一個實(shí)例(單例)(默認(rèn))
prototype：原型作用域（多例作用域）
- 每次使用該 bean 時會創(chuàng)建新的實(shí)例(非單例)
request：請求作用域
- 每個 HTTP 請求生命周期內(nèi)，創(chuàng)建新的實(shí)例（Web 環(huán)境中，了解）
session：會話作用域
- 每個 HTTP Session 生命周期內(nèi)，創(chuàng)建新的實(shí)例（Web 環(huán)境中，了解）
Application：全局作用域
- 每個 ServletContext 生命周期里內(nèi)，創(chuàng)建新的實(shí)例（web 環(huán)境中，了解）
websocket：HTTP WebSocket 作用域
- 每個 WebSocket 生命周期內(nèi)，創(chuàng)建新的實(shí)例（web 環(huán)境中，了解）

我們來看簡單的代碼實(shí)現(xiàn)

定義幾個不同作用域的 bean

@Component  
public class DogBeanConfig {  
    @Bean  
    public Dog dog() {  
        Dog dog = new Dog();  
        dog.setName("旺旺");  
        return dog;  
    }  
    @Bean  
    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)  
    public Dog singleDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)  
    public Dog prototype() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @RequestScope    
    public Dog requestDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @SessionScope    
    public Dog sessionDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
    @Bean  
    @ApplicationScope    
    public Dog applicationDog() {  
        Dog dog = new Dog();  
        return dog;  
    }  
}

@RequestScope 等同于 @Scope (value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
@SessionScope 等同于 @Scope (value =WebApplicationContext.SCOPE_SESSION, proxyMode =ScopedProxyMode.TARGET_CLASS)
@ApplicationScope 等同于 @Scope (value =WebApplicationContext. SCOPE_APPLICATION, proxyMode =ScopedProxyMode. TARGET_CLASS)

proxyMode ?來為 springbean 設(shè)置代理 .proxyMode = ScopedProxyMode.TARGET_CLASS 表?這個 Bean 基于 CGLIB 實(shí)現(xiàn)動態(tài)代理，Request，session 和 application 作?域的 Bean 需要設(shè)置 proxyMode

代碼測試

測試不同作用域的 bean 取到的對象是否一樣

@RestController  
public class DogController {  
    @Autowired  
    private Dog singleDog;  
    @Autowired  
    private Dog prototypeDog;  
    @Autowired  
    private Dog requestDog;  
    @Autowired  
    private Dog sessionDog;  
    @Autowired  
    private Dog applicationDog;  
    @Autowired  
    private ApplicationContext applicationContext;  
    @RequestMapping("/single")  
    public String single(){  
        Dog contexDog = (Dog) applicationContext.getBean("singleDog");  
        return "dog: " + singleDog.toString() + ", contextDog: " + contexDog;  
    }  
    @RequestMapping("/prototype")  
    public String prototype() {  
        Dog contextDog = (Dog) applicationContext.getBean("prototypeDog");  
        return "dog: " + prototypeDog.toString() + ", contextDog: " + contextDog;  
    }  
    @RequestMapping("/request")  
    public String request(){  
        Dog contexDog = (Dog) applicationContext.getBean("requestDog");  
        return "dog: " + requestDog.toString() + ", contextDog: " + contexDog;  
    }  
    @RequestMapping("/session")  
    public String session() {  
        Dog contextDog = (Dog) applicationContext.getBean("sessionDog");  
        return "dog: " + sessionDog.toString() + ", contextDog: " + contextDog;  
    }  
    @RequestMapping("/application")  
    public String application() {  
        Dog contextDog = (Dog) applicationContext.getBean("applicationDog");  
        return "dog: " + applicationDog.toString() + ", contextDog: " + contextDog;  
    }  
}

每個請求都獲取兩次 Bean
@Autowired 和 applicationContext.getBean("singleDog") 都是從 Spring 容器中獲取對象

觀察 Bean 的作用域

1.單例作用域

地址： http://127.0.0.1:8080/single

多次訪問，得到的都是同一個對象，并且 @Autowired 和 applicationContext.getBean() 也是同一個對象

2.多例作用域

地址： http://127.0.0.1:8080/prototype

觀察 ContextDog，每次獲取的對象都不一樣（注入的對象在 Spring 容器啟動時，就已經(jīng)注入了，所以多次請求訪問也不會發(fā)生變化）

3.請求作用域

地址： http://127.0.0.1:8080/request

在一次請求中，@Autowired 和 applicationContext.getBean() 也是同一個對象，但是每次請求，都會重新創(chuàng)建對象

4.會話作用域

地址： http://127.0.0.1:8080/session

在一個 session 中，多次請求，獲取到的對象都是同一個

換一個瀏覽器訪問，發(fā)現(xiàn)會重新創(chuàng)建對象（另一個 session）

5.Application作用域

地址： http://127.0.0.1:8080/application

在一個應(yīng)用中，多次訪問都是同一個對象

Application scope 就是對于整個 web 容器來說，bean 的作用域是 ServletContext 級別的
這個和 singleton 有點(diǎn)類似，區(qū)別在于：Application scope 是 ServletContext 的單例，singleton 是一個 ApplicationContext 的單例
在一個 web 容器中 ApplicationContext 可以有多個（了解即可）

到此這篇關(guān)于Spring Bean的作用域具體實(shí)現(xiàn)(單例、多例、請求、會話、Application)的文章就介紹到這了,更多相關(guān)Spring Bean作用域內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: