Spring學習手冊（4）—— Spring 依賴注入中介紹了Spring依賴注入的基本方式以及各種類型的參數注入的方式。本文我們詳細介紹下bean的作用域。

一、Spring中bean的作用域

Spring為我們提供了7種作用域管理方式，其中singleton、prototype為最常使用的兩個，而剩下的5個scope描述僅用于web相關的ApplicationContext。

下表簡單介紹該7種方式：

本文我們只介紹最常用的prototype和singleton作用域。

Tip：Spring的單例和設計模式中所提到的單例并不相同：
Spring的單例：一個IOC容器僅創建一個bean實例；
設計模式的單例：ClassLoader中只有一個class存在；

二、singleton 作用域

當將bean的scope設置為singleton，Spring的IOC容器將僅生成和管理一個bean實例，且當你是用id或name獲取bean實例時，IOC容器會返回共享的bean實例。如下圖所示，不同的bean引用accountDao，IOC容器為它們返回同一個實例的引用。

singleton實例圖

由于singleton是為scope的默認方式，因此我們有兩種方式將bean的scope設置為singleton。

<bean id="accountService" class="com.foo.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>

三、prototype作用域

當bean的scope設置為prototype，Spring的IOC容器會在每次請求該bean時，都會創建一個新的實例出來。如下圖所示，不同的bean定義需要注入accountDao，由于accountDao配置的作用域為prototype,所以IOC容器為每個bean創建一個新的accountDao實例。

prototype實例圖

<bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>

四、例子

為測試以上性質，我們創建PrototypeBean、SingletonBean類，類內部有計數器，每當一個新的實例被創建時，內部計數器加1?。代碼如下：

PrototypeBean：

public class PrototypeBean {

    private static int  num = 0;

    private int count;
    public PrototypeBean() {
        num++;
        count = num;
    }

    public int getCount() {
        return count;
    }
}

SingletonBean:

public class SingletonBean {

    private static int num =0;

    private int count;

    public SingletonBean() {
        num++;
        count = num;
    }

    public int getCount() {
        return count;
    }
}

為了使用該類，我們創建UsePrototypeBeanExample類系列和UseSingletonBeanExample類系列，該系列類實現方式相同，只是類名不同，這里我們列出一個例子：

public class UsePrototypeBeanExample1 {

    private PrototypeBean prototypeBean;


    public void setPrototypeBean(PrototypeBean prototypeBean) {
        this.prototypeBean = prototypeBean;
    }

    public PrototypeBean getPrototypeBean() {
        return prototypeBean;
    }
}

以上實驗代碼準備好后，我們將配置組裝我們的bean信息：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">


    <!-- 定義prototype bean -->
    <bean id="prototypeBean" class="com.liangwei.learnspring.PrototypeBean" scope="prototype"/>

    <!-- 定義singleton bean-->
    <bean id="singletonBean" class="com.liangwei.learnspring.SingletonBean" scope="singleton"/>

    <!-- 依賴 prototype bean 屬性注入-->
    <bean id="prototypeExample1" class="com.liangwei.learnspring.UsePrototypeBeanExample1">
        <property name="prototypeBean" ref="prototypeBean"/>
    </bean>

    <bean id="prototypeExample2" class="com.liangwei.learnspring.UsePrototypeBeanExample2">
        <property name="prototypeBean" ref="prototypeBean"/>
    </bean>

    <bean id="prototypeExample3" class="com.liangwei.learnspring.UsePrototypeBeanExample3">
        <property name="prototypeBean" ref="prototypeBean"/>
    </bean>

    <!--依賴singleton bean 屬性注入-->
    <bean id="singletonExample1" class="com.liangwei.learnspring.UseSingletonBeanExample1">
        <property name="singletonBean" ref="singletonBean"/>
    </bean>

    <bean id="singletonExample2" class="com.liangwei.learnspring.UseSingletonBeanExample2">
        <property name="singletonBean" ref="singletonBean"/>
    </bean>

    <bean id="singletonExample3" class="com.liangwei.learnspring.UseSingletonBeanExample3">
        <property name="singletonBean" ref="singletonBean"/>
    </bean>
</beans>

測試代碼：

public class Application {

    public static void main(String[] args){


        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");

        System.out.println("Prototype bean test:");
        UsePrototypeBeanExample1 usePrototypeBeanExample1 = applicationContext.getBean("prototypeExample1",UsePrototypeBeanExample1.class);
        System.out.println(usePrototypeBeanExample1.getPrototypeBean().getCount());

        UsePrototypeBeanExample2 usePrototypeBeanExample2 = applicationContext.getBean("prototypeExample2",UsePrototypeBeanExample2.class);
        System.out.println(usePrototypeBeanExample2.getPrototypeBean().getCount());


        UsePrototypeBeanExample3 usePrototypeBeanExample3 = applicationContext.getBean("prototypeExample3",UsePrototypeBeanExample3.class);
        System.out.println(usePrototypeBeanExample3.getPrototypeBean().getCount());

        System.out.println(applicationContext.getBean("prototypeBean",PrototypeBean.class).getCount());

        System.out.println("\n singleton bean test:");

        UseSingletonBeanExample1 useSingletonBeanExample1 = applicationContext.getBean("singletonExample1",UseSingletonBeanExample1.class);
        System.out.println(useSingletonBeanExample1.getSingletonBean().getCount());

        UseSingletonBeanExample2 useSingletonBeanExample2 = applicationContext.getBean("singletonExample2",UseSingletonBeanExample2.class);
        System.out.println(useSingletonBeanExample2.getSingletonBean().getCount());
        UseSingletonBeanExample3 useSingletonBeanExample3 = applicationContext.getBean("singletonExample3",UseSingletonBeanExample3.class);
        System.out.println(useSingletonBeanExample3.getSingletonBean().getCount());
        System.out.println(applicationContext.getBean("singletonBean",SingletonBean.class).getCount());
    }
}

運行代碼我們會發現輸出結果如下：

Prototype bean test:
1
2
3
4

 singleton bean test:
1
1
1
1

通過測試實驗代碼我們驗證了如下結論：
prototype作用域：

• 需要獲取prototype作用域的bean時會創建一個全新的bean實例；
• 無論使用屬性注入還是使用getBean的方式都會獲得一個新的bean實例
  singleton作用域：
• 需要獲取singleton作用域的bean時會共享同一個bean實例；
• 無論使用屬性注入還是使用getBean的方式獲得的都為共享的bean實例。

測試代碼下載地址