Spring 實現兩種設計模式：工廠模式和單態模式（單例模式）

本文摘自：李剛 著 《輕量級 Java EE企業應用實戰 Struts2+Spring+hibernate整合開發》

        在Spring 中大量使用的如下兩種設計模式：工廠模式和單態模式。

工廠模式可將Java 對象的調用者從被調用者的實現邏輯中分離出來，調用者只需關心被調用者必須知足的規則(接口) ，而沒必要關心實例的具體實現過程。這是面向接口編程的優點，能提升程序的解耦，避免全部的類以硬編碼方式耦合在一塊兒。

        若是全部的類直接耦合，極易造成"骨牌效應"，假如B 類調用了A 類，一旦A 類須要修改，則B 類也須要修改；假如C 類調用了B 類，則C 類也須要修改......依次類推，從而致使整個系統都須要改寫。形成"牽一髮而動全身"，而系統重構的代價是至關高的。

        Spring 倡導」面向接口編程「，能夠避免上述的問題，使設計良好的架構可保證系統重構的工做被封閉在重構的層內，毫不會影響其餘層。

        Spring 容器是實例化和管理所有bean 的工廠，Spring 默認將全部的bean 設置成單態模式，無須本身完成單態模式，即對全部相同id 的bean 請求都將返回同一個共享實例。所以，單態模式可大大下降Java 對象在建立和銷燬時的系統開銷。

一. 單態模式的回顧

        單態模式限制了類實例的建立，但採用這種模式設計的類，能夠保證僅有一個實例，並可提供訪問該實例的全局訪問點。J2EE應用的大量組件，都須要保證一個類只有一個實例。好比數據庫引擎訪問點只能有一個。

        更多的時候，爲了提升性能，程序應儘可能減小Java 對象的建立和銷燬時的開銷。使用單態模式可避免Java 類被屢次實例化，讓相同類的所有實例共享同一內存區。

        爲了防止單態模式的類被屢次實例化，應將類的構造器設成私有，這樣就保證了只能經過靜態方法得到類實例。而該靜態方法則保證每次返回的實例都是同一個，這就需將該類的實例設置成類屬性，因爲該屬性須要被靜態方法訪問，所以該屬性應設成靜態屬性。

下面給出單態模式的示例代碼：

package ppp;
//單態模式測試類
public class SingletonTest {
    //該類的一個普通屬性
    int value;
    //使用靜態屬性保存該類的一個實例
    private static SingletonTest instance;
    //構造器私有化，避免該類被屢次實例化
    private SingletonTest(){
        System.out.println("正在執行構造器...");
    }
    //提供靜態方法返回該類實例
    public static SingletonTest getInstance(){
        //實例化類實例前，先檢查該實例是否存在
        if(instance == null){
            //若是不存在，則新建一個實例
            instance = new SingletonTest();
        }
        //返回該類的成員變量：該類的實例
        return instance;
    }
    //如下提供對普通屬性value的getter和setter方法
    public int getValue(){
        return value;
    }

    public void setValue(int values){
        this.value = values;
    }
    public static void main(String args[]){
        SingletonTest t1 = SingletonTest.getInstance();
        SingletonTest t2 = SingletonTest.getInstance();
        t2.setValue(9);
        System.out.println(t1 == t2);
    }
}

        從程序最後的打印結果能夠看出，該類的兩個實例徹底相同。這證實單態模式類的所有實例是同一共享實例。程序裏雖然得到了類的兩個實例，但實際上只執行一次構造器，由於對於單態模式的類，不管有多少次的建立實例請求，都只執行一次構造器。

 

二. 工廠模式的回顧

 

        工廠模式是根據調用數據返回某個類的一個實例，此類能夠是多個類的某一個類。一般，這些類知足共同的規則(接口)或父類。調用者只關心工廠生產的實例是否知足某種規範，即實現的某個接口是否可供本身正常調用(調用者僅僅使用)。該模式給對象之間做出了清晰的角色劃分，下降程序的耦合。

        接口產生的所有實例一般用於實現相同接口，接口裏定義了所有實例共同擁有的方法，這些方法在不一樣的實現類中實現的方式不一樣。從而使程序調用者無須關心方法的具體實現，下降了系統異構的代價。

下面是工廠模式的示例代碼：

package ppp;

//Person接口定義
public interface Person {
    public String sayHello(String name);
    public String sayGoodbye(String name);
}

該接口定義了Person規範，規範要求實現該接口的類必須具備如下兩個的方法：能打招呼，能告別。

package ppp;
//American類實現Person接口
public class American implements Person {
    public String sayHello(String name){
        return name+",hello";
    }
    public String sayGoodbye(String name)
    {
        return name+",goodbye";
    }
}

下面是Person類的另外一個實現類：Chinese

package ppp;
//Chinese類實現Person接口
public class Chinese implements Person {
    public String sayHello(String name){
        return name+",您好";
    }
    public String sayGoodbye(String name)
    {
        return name+",下次再見";
    }
}

而後再看Person工廠的代碼：

package ppp;

public class PersonFactory {
    public Person getPerson(String ethnic)
    {
        if(ethnic.equalsIgnoreCase("chin"))
        {
            return new Chinese();
        }else{
            return new American();
        }
    }
}

以上是最簡單的工廠模式框架，其主程序以下：

package ppp;

public class FactoryTest {
    public static void main(String[] args){
        //建立PersonFactory實例 ，得到工廠實例
        PersonFactory pf = new PersonFactory();
        //定義接口Person實例，面向接口編程
        Person p = null;
        //使用工廠得到person實例
        p = pf.getPerson("chin");
        //下面調用Person接口方法
        System.out.println(p.sayHello("wawa"));
        System.out.println(p.sayGoodbye("wawa"));
        //使用工廠得到Person的另外一個實例
        p = pf.getPerson("ame");
        //再次調用Person接口的方法
        System.out.println(p.sayHello("wawa"));
        System.out.println(p.sayGoodbye("wawa"));
    }
}

由此可看出，主程序從Person 接口的具體類中解耦出來，並且程序調用者無須關心Person 的實例化過程，主程序僅僅與工廠服務定位結合在一塊兒，可得到全部工廠能產生的實例。具體類的變化，接口無須發生任何改變，調用者程序代碼部分也無須發生任何改動。
下面是Spring 對這兩種模式的實現。

 

三. Spring 對單態與工廠模式的實現

 

        隨着Spring 提供工廠模式的實現，在使用Spring 時，無須本身提供工廠類。由於Spring容器是最大的工廠，並且是個功能超強的工廠。Spring 使用配置文件管理全部的bean ，其配置文件中bean 由Spring 工廠負責生成和管理。

下面是關於兩個實例的配置文件：

<!--下面是xml文件的文件頭-->
<?xml version = "1.0" encoding = "gb2312"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
   "http://www.springsource.org/dtd/spring-beans.dtd">
<!--beans是Spring配置文件的根元素-->
<beans>
<!--定義第一個bean，該bean的id是chinese-->
<bean id = "chinese" class = "ppp.Chinese"/>
<!--定義第二個bean，該bean的id是American-->
<bean id = "american" class = "ppp.American"/>
</beans>

主程序部分以下：

package ppp;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class SpringTest {
    public static void main(String[] args) {
        //實例化Spring容器
        ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
        //定義Person接口實例
        Person p = null;
        //經過Spring上下文得到Chinese實例
        p = (Person)ctx.getBean("chinese");
        //執行chinese實例的方法
        System.out.println(p.sayHello("wawa"));
        System.out.println(p.sayGoodbye("wawa"));

        p = (Person)ctx.getBean("american");
        System.out.println(p.sayHello("wawa"));
        System.out.println(p.sayGoodbye("wawa"));
    }
}

       使用Spring 時，即便沒有工廠類PersonFactory ，程序同樣可使用工廠模式， Spring徹底能夠提供全部工廠模式的功能。

       下面對主程序部分進行簡單的修改：   

package ppp;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class SpringTest{
     public static void main(String[] args){
         //實例化Spring容器
         ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
         //定義p1接口的實例p1
         Person p1 = null;
         //經過Spring上下文得到Chinese實例
         p1 = (Person)ctx.getBean("Chinese");
         //定義p2接口的實例p2
         Person p2 = null;
         p2 = (Person)ctx.getBean("Chinese");
         System.out.println(p1 == p2);
     }
}

          程序的執行結果是：true

        代表Spring對接受容器管理的所有的bean，默認採用單態模式管理，建議不要隨意更改bean的行爲方式。由於從性能上講，單態的bean比非單態的bean性能更爲優秀。

        仔細檢查上面的代碼就會發現以下的特色;

        （1）除測試部分的主程序外，代碼並未出現Spring的特定類和接口。

        （2）調用者的代碼，也就是測試用的主程序部分，僅僅面向Person的接口編程，而無需知道實現類的具體名稱。同時，經過修改配置文件來完全切換底層的具體實現類。

        （3）因爲廠無需多個實例，所以工廠應該採用單態模式設計，其中Spring上下文也就是Spring工廠，已被設計成單態。

          Spring工廠模式，不只提供了建立bean的功能，還提供了對bean的生命週期的管理。最重要的是還以管理bean和bean之間的依賴關係。