物件導向-設計模式-建立型

物件導向-設計模式-建立型

 

　　　　　　晴川歷歷漢陽樹，芳草萋萋鸚鵡洲。

 

簡介：物件導向-設計模式-建立型。

一、概述

何謂設計模式：

設計模式(Design Pattern)是一套被反覆使用、多數人知曉的、經過分類的、程式碼設計經驗的總結。

設計模式的好處&學習目的：

1、為了程式碼可重用行、讓程式碼更易被他人理解、保證程式碼的可靠性、使程式碼編寫真正實現工程化；

2、設計模式便於我們維護專案，增強系統的健壯性和可擴充套件性；

3、設計模式還可以鍛鍊碼農的設計思維、昇華程式碼質量等。

二、建立型

單例模式、簡單工廠模式、工廠方法模式、抽象工廠模式、生成器模式、原型模式。

1、單例（Singleton）

單例模式參考連結：https://www.cnblogs.com/taojietaoge/p/10336439.html

Intent

確保一個類只有一個例項，並提供該例項的全域性訪問點。

Class Diagram

使用一個私有建構函式、一個私有靜態變數以及一個公有靜態函式來實現。

私有建構函式保證了不能通過建構函式來建立物件例項，只能通過公有靜態函式返回唯一的私有靜態變數。

 

Implementation

Ⅰ 懶漢式-執行緒不安全

以下實現中，私有靜態變數 uniqueInstance 被延遲例項化，這樣做的好處是，如果沒有用到該類，那麼就不會例項化 uniqueInstance，從而節約資源。

這個實現在多執行緒環境下是不安全的，如果多個執行緒能夠同時進入 if (uniqueInstance == null) ，並且此時 uniqueInstance 為 null，那麼會有多個執行緒執行 uniqueInstance = new Singleton(); 語句，這將導致例項化多次 uniqueInstance。

// 懶漢模式-執行緒不安全
public class Singleton {

    private static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

Ⅱ 餓漢式-執行緒安全

執行緒不安全問題主要是由於 uniqueInstance 被例項化多次，採取直接例項化 uniqueInstance 的方式就不會產生執行緒不安全問題。

但是直接例項化的方式也丟失了延遲例項化帶來的節約資源的好處。

// 餓漢模式
public class Singleton {

    private static Singleton uniqueInstance = new Singleton();

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        return uniqueInstance;
    }
}

Ⅲ 懶漢式-執行緒安全

只需要對 getUniqueInstance() 方法加鎖，那麼在一個時間點只能有一個執行緒能夠進入該方法，從而避免了例項化多次 uniqueInstance。

但是當一個執行緒進入該方法之後，其它試圖進入該方法的執行緒都必須等待，即使 uniqueInstance 已經被例項化了。這會讓執行緒阻塞時間過長，因此該方法有效能問題，不推薦使用。

// 懶漢模式-執行緒安全方法
public class Singleton {

    private static Singleton uniqueInstance;

    private Singleton() {
    }

    public static synchronized Singleton getUniqueInstance() {  // synchronized 加鎖
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

Ⅳ 雙重校驗鎖-執行緒安全

uniqueInstance 只需要被例項化一次，之後就可以直接使用了。加鎖操作只需要對例項化那部分的程式碼進行，只有當 uniqueInstance 沒有被例項化時，才需要進行加鎖。

雙重校驗鎖先判斷 uniqueInstance 是否已經被例項化，如果沒有被例項化，那麼才對例項化語句進行加鎖。

// 雙重校驗鎖
public class Singleton {

    private volatile static Singleton uniqueInstance;  // 使用 volatile 關鍵字修飾，禁止JVM 指令重排序

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {  // synchronized 對例項化語句加鎖
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

考慮下面的實現，也就是隻使用了一個 if 語句。在 uniqueInstance == null 的情況下，如果兩個執行緒都執行了 if 語句，那麼兩個執行緒都會進入 if 語句塊內。雖然在 if 語句塊內有加鎖操作，但是兩個執行緒都會執行 uniqueInstance = new Singleton(); 這條語句，只是先後的問題，那麼就會進行兩次例項化。因此必須使用雙重校驗鎖，也就是需要使用兩個 if 語句：第一個 if 語句用來避免 uniqueInstance 已經被例項化之後的加鎖操作，而第二個 if 語句進行了加鎖，所以只能有一個執行緒進入，就不會出現 uniqueInstance == null 時兩個執行緒同時進行例項化操作。

if (uniqueInstance == null) {
    synchronized (Singleton.class) {  // 如果兩個執行緒都執行了 if 語句
        uniqueInstance = new Singleton();
    }
}

uniqueInstance 採用 volatile 關鍵字修飾也是很有必要的， uniqueInstance = new Singleton(); 這段程式碼其實是分為三步執行：

1. 為 uniqueInstance 分配記憶體空間
2. 初始化 uniqueInstance
3. 將 uniqueInstance 指向分配的記憶體地址

但是由於 JVM 具有指令重排的特性，執行順序有可能變成 1>3>2。指令重排在單執行緒環境下不會出現問題，但是在多執行緒環境下會導致一個執行緒獲得還沒有初始化的例項。例如，執行緒 T₁ 執行了 1 和 3，此時 T₂ 呼叫 getUniqueInstance() 後發現 uniqueInstance 不為空，因此返回 uniqueInstance，但此時 uniqueInstance 還未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保證在多執行緒環境下也能正常執行。

volatile 如何保證禁止指令重排序參考連結：https://www.cnblogs.com/taojietaoge/p/10260888.html

Ⅴ 靜態內部類實現

當 Singleton 類被載入時，靜態內部類 SingletonHolder 沒有被載入進記憶體。只有當呼叫 getUniqueInstance() 方法從而觸發 SingletonHolder.INSTANCE 時 SingletonHolder 才會被載入，此時初始化 INSTANCE 例項，並且 JVM 能確保 INSTANCE 只被例項化一次。

這種方式不僅具有延遲初始化的好處，而且由 JVM 提供了對執行緒安全的支援。

Ⅵ 列舉實現

1 使用列舉類實現單例的好處：寫法簡單、預設執行緒安全、反序列化（反射、克隆）時也不會建立新的物件。

// 列舉類實現單例
public enum Singleton {

    INSTANCE;

    private String objName;


    public String getObjName() {
        return objName;
    }


    public void setObjName(String objName) {
        this.objName = objName;
    }


    public static void main(String[] args) {

        // 單例測試
        Singleton firstSingleton = Singleton.INSTANCE;
        firstSingleton.setObjName("firstName");
        System.out.println(firstSingleton.getObjName());
        Singleton secondSingleton = Singleton.INSTANCE;
        secondSingleton.setObjName("secondName");
        System.out.println(firstSingleton.getObjName());
        System.out.println(secondSingleton.getObjName());

        // 反射獲取例項測試
        try {
            Singleton[] enumConstants = Singleton.class.getEnumConstants();
            for (Singleton enumConstant : enumConstants) {
                System.out.println(enumConstant.getObjName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

輸出：
firstName
secondName
secondName
secondName

該實現可以防止反射攻擊。在其它實現中，通過 setAccessible() 方法可以將私有建構函式的訪問級別設定為 public，然後呼叫建構函式從而例項化物件，如果要防止這種攻擊，需要在建構函式中新增防止多次例項化的程式碼。該實現是由 JVM 保證只會例項化一次，因此不會出現上述的反射攻擊。

該實現在多次序列化和序列化之後，不會得到多個例項。而其它實現需要使用 transient 修飾所有欄位，並且實現序列化和反序列化的方法。

單例小結

最佳的單例實現模式就是列舉模式。利用列舉的特性，讓JVM 來幫我們保證執行緒安全和單一例項。

2、簡單工廠（Simple Factory）

Intent

在建立一個物件時不向客戶暴露內部細節，並提供一個建立物件的通用介面。

Class Diagram

簡單工廠把例項化的操作單獨放到一個類中，這個類就成為簡單工廠類，讓簡單工廠類來決定應該用哪個具體子類來例項化。

這樣做能把客戶類和具體子類的實現解耦，客戶類不再需要知道有哪些子類以及應當例項化哪個子類。客戶類往往有多個，如果不使用簡單工廠，那麼所有的客戶類都要知道所有子類的細節。而且一旦子類發生改變，例如增加子類，那麼所有的客戶類都要進行修改。

Implementation

public interface Product {
}

public class ConcreteProduct implements Product {
}

public class ConcreteProduct1 implements Product {
}

public class ConcreteProduct2 implements Product {
}

以下的 Client 類包含了例項化的程式碼，這是一種錯誤的實現。如果在客戶類中存在這種例項化程式碼，就需要考慮將程式碼放到簡單工廠中。

// 錯誤實現
public class Client {

    public static void main(String[] args) {
        int type = 1;
        Product product;
        if (type == 1) {
            product = new ConcreteProduct1();
        } else if (type == 2) {
            product = new ConcreteProduct2();
        } else {
            product = new ConcreteProduct();
        }
        // do what u want to do
    }
}

以下的 SimpleFactory 是簡單工廠實現，它被所有需要進行例項化的客戶類呼叫。

public class SimpleFactory {

    public Product createProduct(int type) {
        if (type == 1) {  // 也可以用switch 當物件型別太多
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}

public class Client {
    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        // 只需要傳一個型別引數，例項化具體物件  
        Product product1 = simpleFactory.createProduct(1);
        Product product2 = simpleFactory.createProduct(2);
    }
}

3、工廠方法（Factory Method）

Intent

定義了一個建立物件的介面，但由子類決定要例項化哪個類。工廠方法把例項化操作推遲到子類。

Class Diagram

在簡單工廠中，建立物件的是另一個類，而在工廠方法中，是由子類來建立物件。

下圖中，Factory 有一個 doSomething() 方法，這個方法需要用到一個產品物件，這個產品物件由 factoryMethod() 方法建立。該方法是抽象的，需要由子類去實現。

 

Implementation

public abstract class Factory {
    abstract public Product factoryMethod();  // 抽象方法，由子類去實現
    public void doSomething() {
        Product product = factoryMethod();
        // do something with the product
    }
}

public class ConcreteFactory extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

public class ConcreteFactory1 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct1();
    }
}

public class ConcreteFactory2 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct2();  // 由子類來建立物件
    }
}

4、抽象工廠（Abstract Factory）

Intent

提供一個介面，用於建立 相關的物件家族 。

Class Diagram

抽象工廠模式建立的是物件家族，也就是很多物件而不是一個物件，並且這些物件是相關的，也就是說必須一起建立出來。而工廠方法模式只是用於建立一個物件，這和抽象工廠模式有很大不同。

抽象工廠模式用到了工廠方法模式來建立單一物件，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是讓子類來實現，這兩個方法單獨來看就是在建立一個物件，這符合工廠方法模式的定義。

至於建立物件的家族這一概念是在 Client 體現，Client 要通過 AbstractFactory 同時呼叫兩個方法來建立出兩個物件，在這裡這兩個物件就有很大的相關性，Client 需要同時建立出這兩個物件。

從高層次來看，抽象工廠使用了組合，即 Cilent 組合了 AbstractFactory，而工廠方法模式使用了繼承。

 

Implementation

public class AbstractProductA {
}

public class AbstractProductB {
}

public class ProductA1 extends AbstractProductA {
}

public class ProductA2 extends AbstractProductA {
}

public class ProductB1 extends AbstractProductB {
}

public class ProductB2 extends AbstractProductB {
}

public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}

public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        AbstractProductA productA = abstractFactory.createProductA();
        AbstractProductB productB = abstractFactory.createProductB();
        // do something with productA and productB
    }
}

6、生成器（Builder）

Intent

封裝一個物件的構造過程，並允許按步驟構造。

Class Diagram

 

Implementation

以下是一個簡易的 StringBuilder 實現，參考了 JDK 1.8 原始碼。

public class AbstractStringBuilder {
    protected char[] value;

    protected int count;

    public AbstractStringBuilder(int capacity) {
        count = 0;
        value = new char[capacity];
    }

    public AbstractStringBuilder append(char c) {
        ensureCapacityInternal(count + 1);
        value[count++] = c;
        return this;
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
    }

    void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
    }
}

public class StringBuilder extends AbstractStringBuilder {
    public StringBuilder() {
        super(16);
    }

    @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }
}

public class Client {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        final int count = 26;
        for (int i = 0; i < count; i++) {
            sb.append((char) ('a' + i));
        }
        System.out.println(sb.toString());
    }
}

abcdefghijklmnopqrstuvwxyz

6、原型模式（Prototype）

Intent

使用原型例項指定要建立物件的型別，通過複製這個原型來建立新物件。

Class Diagram

Implementation

public abstract class Prototype {
    abstract Prototype myClone();
}

public class ConcretePrototype extends Prototype {

    private String filed;

    public ConcretePrototype(String filed) {
        this.filed = filed;
    }

    @Override
    Prototype myClone() {
        return new ConcretePrototype(filed);
    }

    @Override
    public String toString() {
        return filed;
    }
}

public class Client {
    public static void main(String[] args) {
        Prototype prototype = new ConcretePrototype("abc");
        Prototype clone = prototype.myClone();
        System.out.println(clone.toString());  // abc
    }
}

 

 

 

 

晴川歷歷漢陽樹

　　　　　　芳草萋萋鸚鵡洲