Spring系列第六講 玩轉bean scope，避免跳坑裡！

qwer1030274531發表於2020-10-29
SpringBean

singleton

當scope的值設定為singleton的時候，整個spring容器中只會存在一個bean例項，透過容器多次查詢bean的時候（呼叫BeanFactory的getBean方法或者bean之間注入依賴的bean物件的時候），返回的都是同一個bean物件，singleton是scope的預設值，所以spring容器中預設建立的bean物件是單例的，通常spring容器在啟動的時候，會將scope為singleton的bean建立好放在容器中（有個特殊的情況，當bean的lazy被設定為true的時候，表示懶載入，那麼使用的時候才會建立），用的時候直接返回。

案例

bean xml配置

<!-- 單例bean，scope設定為singleton --><bean id="singletonBean" class="com.javacode2018.lesson001.demo4.BeanScopeModel" scope="singleton">
    <constructor-arg index="0" value="singleton"/></bean>1234

BeanScopeModel程式碼

package com.javacode2018.lesson001.demo4;public class BeanScopeModel {
    public BeanScopeModel(String beanScope) {
        System.out.println(String.format("create BeanScopeModel,{sope=%s},{this=%s}", beanScope, this));
    }}1234567

上面構造方法中輸出了一段文字，一會我們可以根據輸出來看一下這個bean什麼時候建立的，是從容器中獲取bean的時候建立的還是容器啟動的時候建立的。

測試用例

package com.javacode2018.lesson001.demo4;import org.junit.Before;import org.junit.Test;import org.springframework.context.support.ClassPathXmlApplicationContext;public class ScopeTest {
    ClassPathXmlApplicationContext context;
    @Before
    public void before() {
        System.out.println("spring容器準備啟動.....");
        //1.bean配置檔案位置
        String beanXml = "classpath:/com/javacode2018/lesson001/demo4/beans.xml";
        //2.建立ClassPathXmlApplicationContext容器，給容器指定需要載入的bean配置檔案
        this.context = new ClassPathXmlApplicationContext(beanXml);
        System.out.println("spring容器啟動完畢！");
    }
    /**
     * 單例bean
     */
    @Test
    public void singletonBean() {
        System.out.println("---------單例bean，每次獲取的bean例項都一樣---------");
        System.out.println(context.getBean("singletonBean"));
        System.out.println(context.getBean("singletonBean"));
        System.out.println(context.getBean("singletonBean"));
    }}1234567891011121314151617181920212223242526272829303132

上面程式碼中before方法上面有@Before註解，這個是junit提供的功能，這個方法會在所有@Test標註的方法之前之前執行，before方法中我們對容器進行初始化，並且在容器初始化前後輸出了一段文字。

上面程式碼中，singletonBean方法中，3次獲取singletonBean對應的bean。

執行測試用例

spring容器準備啟動.....create BeanScopeModel,{sope=singleton},{this=com.javacode2018.lesson001.demo4.BeanScopeModel@e874448}spring容器啟動完畢！---------單例bean，每次獲取的bean例項都一樣---------com.javacode2018.lesson001.demo4.BeanScopeModel@e874448com.javacode2018.lesson001.demo4.BeanScopeModel@e874448com.javacode2018.lesson001.demo4.BeanScopeModel@e8744481234567

結論

從輸出中得到2個結論

  • 前3行的輸出可以看出，BeanScopeModel的構造方法是在容器啟動過程中呼叫的，說明這個bean例項在容器啟動過程中就建立好了，放在容器中快取著

  • 最後3行輸出的是一樣的，說明返回的是同一個bean物件

單例bean使用注意

單例bean是整個應用共享的，所以需要考慮到執行緒安全問題，之前在玩springmvc的時候，springmvc中controller預設是單例的，有些開發者在controller中建立了一些變數，那麼這些變數實際上就變成共享的了，controller可能會被很多執行緒同時訪問，這些執行緒併發去修改controller中的共享變數，可能會出現資料錯亂的問題；所以使用的時候需要特別注意。

prototype

如果scope被設定為prototype型別的了，表示這個bean是多例的，透過容器每次獲取的bean都是不同的例項，每次獲取都會重新建立一個bean例項物件。

案例

bean xml配置

<!-- 多例bean，scope設定為prototype--><bean id="prototypeBean" class="com.javacode2018.lesson001.demo4.BeanScopeModel" scope="prototype">
    <constructor-arg index="0" value="prototype"/></bean>1234

新增一個測試用例

ScopeTest中新增一個方法

/**
 * 多例bean
 */@Testpublic void prototypeBean() {
    System.out.println("---------單例bean，每次獲取的bean例項都一樣---------");
    System.out.println(context.getBean("prototypeBean"));
    System.out.println(context.getBean("prototypeBean"));
    System.out.println(context.getBean("prototypeBean"));}12345678910

執行測試用例

spring容器準備啟動.....spring容器啟動完畢！---------單例bean，每次獲取的bean例項都一樣---------create BeanScopeModel,{sope=prototype},{this=com.javacode2018.lesson001.demo4.BeanScopeModel@289d1c02}com.javacode2018.lesson001.demo4.BeanScopeModel@289d1c02create BeanScopeModel,{sope=prototype},{this=com.javacode2018.lesson001.demo4.BeanScopeModel@22eeefeb}com.javacode2018.lesson001.demo4.BeanScopeModel@22eeefebcreate BeanScopeModel,{sope=prototype},{this=com.javacode2018.lesson001.demo4.BeanScopeModel@17d0685f}com.javacode2018.lesson001.demo4.BeanScopeModel@17d0685f123456789

結論

輸出中可以看出，容器啟動過程中並沒有去建立BeanScopeModel物件，3次獲取prototypeBean得到的都是不同的例項，每次獲取的時候才會去呼叫構造方法建立bean例項。

多例bean使用注意

多例bean每次獲取的時候都會重新建立，如果這個bean比較複雜，建立時間比較長，會影響系統的效能，這個地方需要注意。

下面要介紹的3個：request、session、application都是在spring web容器環境中才會有的。

request

當一個bean的作用域為request，表示在一次http請求中，一個bean對應一個例項；對每個http請求都會建立一個bean例項，request結束的時候，這個bean也就結束了，request作用域用在spring容器的web環境中，這個以後講springmvc的時候會說，spring中有個web容器介面WebApplicationContext，這個裡面對request作用域提供了支援，配置方式：

<bean id="" class="" scope="request" />1

session

這個和request類似，也是用在web環境中，session級別共享的bean，每個會話會對應一個bean例項，不同的session對應不同的bean例項，springmvc中我們再細說。

<bean id="" class="" scope="session" />1

application

全域性web應用級別的作用於，也是在web環境中使用的，一個web應用程式對應一個bean例項，通常情況下和singleton效果類似的，不過也有不一樣的地方，singleton是每個spring容器中只有一個bean例項，一般我們的程式只有一個spring容器，但是，一個應用程式中可以建立多個spring容器，不同的容器中可以存在同名的bean，但是sope=aplication的時候，不管應用中有多少個spring容器，這個應用中同名的bean只有一個。

<bean id="" class="" scope="application" />1

自定義scope

有時候，spring內建的幾種sope都無法滿足我們的需求的時候，我們可以自定義bean的作用域。

自定義Scope 3步驟

第1步：實現Scope介面

我們來看一下這個介面定義 

package org.springframework.beans.factory.config;import org.springframework.beans.factory.ObjectFactory;import org.springframework.lang.Nullable;public interface Scope {
    /**
    * 返回當前作用域中name對應的bean物件
    * name：需要檢索的bean的名稱
    * objectFactory：如果name對應的bean在當前作用域中沒有找到，那麼可以呼叫這個ObjectFactory來建立這個物件
    **/
    Object get(String name, ObjectFactory<?> objectFactory);
    /**
     * 將name對應的bean從當前作用域中移除
     **/
    @Nullable
    Object remove(String name);
    /**
     * 用於註冊銷燬回撥，如果想要銷燬相應的物件,則由Spring容器註冊相應的銷燬回撥，而由自定義作用域選擇是不是要銷燬相應的物件
     */
    void registerDestructionCallback(String name, Runnable callback);
    /**
     * 用於解析相應的上下文資料，比如request作用域將返回request中的屬性。
     */
    @Nullable
    Object resolveContextualObject(String key);
    /**
     * 作用域的會話標識，比如session作用域將是sessionId
     */
    @Nullable
    String getConversationId();}1234567891011121314151617181920212223242526272829303132333435363738

第2步：將自定義的scope註冊到容器

需要呼叫org.springframework.beans.factory.config.ConfigurableBeanFactory#registerScope的方法，看一下這個方法的宣告 

/**
* 向容器中註冊自定義的Scope
*scopeName：作用域名稱
* scope：作用域物件
**/void registerScope(String scopeName, Scope scope);123456

第3步：使用自定義的作用域

定義bean的時候，指定bean的scope屬性為自定義的作用域名稱。

案例
需求
下面我們來實現一個執行緒級別的bean作用域，同一個執行緒中同名的bean是同一個例項，不同的執行緒中的bean是不同的例項。

實現分析
需求中要求bean線上程中是貢獻的，所以我們可以透過ThreadLocal來實現，ThreadLocal可以實現執行緒中資料的共享。

下面我們來上程式碼。

ThreadScope

package com.javacode2018.lesson001.demo4;import org.springframework.beans.factory.ObjectFactory;import org.springframework.beans.factory.config.Scope;import org.springframework.lang.Nullable;import java.util.HashMap;import java.util.Map;import java.util.Objects;/**
 * 自定義本地執行緒級別的bean作用域，不同的執行緒中對應的bean例項是不同的，同一個執行緒中同名的bean是同一個例項
 */public class ThreadScope implements Scope {
    public static final String THREAD_SCOPE = "thread";//@1
    private ThreadLocal<Map<String, Object>> beanMap = new ThreadLocal() {
        @Override
        protected Object initialValue() {
            return new HashMap<>();
        }
    };
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Object bean = beanMap.get().get(name);
        if (Objects.isNull(bean)) {
            bean = objectFactory.getObject();
            beanMap.get().put(name, bean);
        }
        return bean;
    }
    @Nullable
    @Override
    public Object remove(String name) {
        return this.beanMap.get().remove(name);
    }
    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        //bean作用域範圍結束的時候呼叫的方法，用於bean清理
        System.out.println(name);
    }
    @Nullable
    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }
    @Nullable
    @Override
    public String getConversationId() {
        return Thread.currentThread().getName();
    }}12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758

BeanScopeModel   question/

package com.javacode2018.lesson001.demo4;public class BeanScopeModel {
    public BeanScopeModel(String beanScope) {
        System.out.println(String.format("執行緒:%s,create BeanScopeModel,{sope=%s},{this=%s}", Thread.currentThread(), beanScope, this));
    }}1234567

上面的構造方法中會輸出當前執行緒的資訊，到時候可以看到建立bean的執行緒。

bean配置檔案

beans-thread.xml內容

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="
       xmlns:xsi="
       xsi:schemaLocation="
    /spring-beans-4.3.xsd">
    <!-- 自定義scope的bean -->
    <bean id="threadBean" class="com.javacode2018.lesson001.demo4.BeanScopeModel" scope="thread">
        <constructor-arg index="0" value="thread"/>
    </bean></beans>1234567891011

注意上面的scope是我們自定義的，值為thread

測試用例 hunan/

package com.javacode2018.lesson001.demo4;import org.springframework.context.support.ClassPathXmlApplicationContext;import java.util.concurrent.TimeUnit;public class ThreadScopeTest {
    public static void main(String[] args) throws InterruptedException {
        String beanXml = "classpath:/com/javacode2018/lesson001/demo4/beans-thread.xml";
        //手動建立容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();
        //設定配置檔案位置
        context.setConfigLocation(beanXml);
        //啟動容器
        context.refresh();
        //向容器中註冊自定義的scope
        context.getBeanFactory().registerScope(ThreadScope.THREAD_SCOPE, new ThreadScope());//@1
        //使用容器獲取bean
        for (int i = 0; i < 2; i++) { //@2
            new Thread(() -> {
                System.out.println(Thread.currentThread() + "," + context.getBean("threadBean"));
                System.out.println(Thread.currentThread() + "," + context.getBean("threadBean"));
            }).start();
            TimeUnit.SECONDS.sleep(1);
        }
    }}12345678910111213141516171819202122232425262728

執行輸出 

執行緒:Thread[Thread-1,5,main],create BeanScopeModel,{sope=thread},{this=com.javacode2018.lesson001.demo4.BeanScopeModel@4049d530}Thread[Thread-1,5,main],com.javacode2018.lesson001.demo4.BeanScopeModel@4049d530Thread[Thread-1,5,main],com.javacode2018.lesson001.demo4.BeanScopeModel@4049d530執行緒:Thread[Thread-2,5,main],create BeanScopeModel,{sope=thread},{this=com.javacode2018.lesson001.demo4.BeanScopeModel@87a76da}Thread[Thread-2,5,main],com.javacode2018.lesson001.demo4.BeanScopeModel@87a76daThread[Thread-2,5,main],com.javacode2018.lesson001.demo4.BeanScopeModel@87a76da123456

從輸出中可以看到，bean在同樣的執行緒中獲取到的是同一個bean的例項，不同的執行緒中bean的例項是不同的。

總結

  1. spring容器自帶的有2種作用域，分別是singleton和prototype；還有3種分別是spring web容器環境中才支援的request、session、application

  2. singleton是spring容器預設的作用域，一個spring容器中同名的bean例項只有一個，多次獲取得到的是同一個bean；單例的bean需要考慮執行緒安全問題

  3. prototype是多例的，每次從容器中獲取同名的bean，都會重新建立一個；多例bean使用的時候需要考慮建立bean對效能的影響

  4. 一個應用中可以有多個spring容器

  5. 自定義scope 3個步驟，實現Scope介面，將實現類註冊到spring容器，使用自定義的sope


來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/30239065/viewspace-2730829/，如需轉載，請註明出處，否則將追究法律責任。

相關文章