前言

這篇內容是從另一篇：UML建模、設計原則中分離出來的，原本這個創建型設計模式是和其放在一起的

但是：把這篇創建型設計模式放在一起讓我賊別扭，看起來賊不舒服，越看念頭越不通達，導致老衲躺在床上腦海中冒出來時都睡不著了

因此：最后實在受不了了，還是將其抽離出來

3、設計模式

分類：

注：使用設計模式的規范，類名 = 需求名+使用的對應設計模式名，如：StringBuilder，這就是使用了Builder建造者模式
設計模式不是一成不變的，主要是思想，至于形不需要在意，形只是便于理解罷了

3.1、創建型

這個型別的模式是專門針對于創建物件的，也就是它的適用機制
換言之：這些設計模式提供了一種在創建物件的同時隱藏創建邏輯的方式，而不是使用 new 運算子直接實體化物件

3.1.1、單例模式

定義：保證物件全域唯一，即：保證一個類只有一個實體，哪怕是多執行緒來進行訪問，向外提供一個訪問此實體的方法即可

使用場景

1、資料庫連接池不會反復創建
2、Spring中一個單例模式Bean的創建
3、開發中設定一些全域的屬性進行保存（當然：用Redis更好）

3.1.1.1、static實作

package com.zixieqing.o1static;

import java.util.HashMap;
import java.util.Map;

/**
 * <p>@description  : 該類功能  使用static的方式</p>
 * <p>@package      : com.zixieqing.o1static</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class StaticSingleton {

    private static Map<String, String> CACHE = new HashMap<>();
}

這種方式在第一次運行時就初始化Map了，不需要延遲加載
缺點：需要被繼承或需要維持一些特定狀態時就不適合了

3.1.1.2、懶漢模式

定義：體現在一個“懶”字上，即：需要時才去創建物件

package com.zixieqing.o2lazy;

/**
 * <p>@description  : 該類功能  懶漢式
 *  此種方式不安全：好比多個人搶廁所，會造成不安全，可能有多個人搶到
 * </p>
 * <p>@package      : com.zixieqing.o2lazy</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class LazySingleton {

    /**
     * 1、private static 當前類的屬性
     */
    private static LazySingleton LAZY_SINGLETON_INSTANCE;

    /**
     * 2、private 的構造
     */
    private LazySingleton() {
    }

    /**
     * 3、提供public static 創建當前類的物件的方法
     */
    public static LazySingleton getInstance() {
        if (null != LAZY_SINGLETON_INSTANCE) return LAZY_SINGLETON_INSTANCE;

        LAZY_SINGLETON_INSTANCE = new LazySingleton();
        return LAZY_SINGLETON_INSTANCE;

    }

    /**
     * 4、要想稍微安全就加synchronized同步鎖
     * 但是：此種方式因為把synchronized加在了方法上，導致所有訪問爭鎖而出現 資源的浪費
     */
/*    public static synchronized lazy_unsafe_singleton getInstance() {
        if (null != LAZY_UNSAFE_INSTANCE_SINGLETON) return LAZY_UNSAFE_INSTANCE_SINGLETON;

        LAZY_UNSAFE_INSTANCE_SINGLETON = new Singleton_lazy_unsafe();
        return LAZY_UNSAFE_INSTANCE_SINGLETON;

    }*/
}

3.1.1.3、餓漢模式

定義：體現在“餓”字上，即：一開始就初始化

package com.zixieqing.o3hunger;

/**
 * <p>@description  : 該類功能  餓漢式實作
 * 這種方式和利用static的方式是異曲同工的
 * </p>
 * <p>@package      : com.zixieqing.o3hunger</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class HungerSingleton {

    private static HungerSingleton HUNGER_SINGLETON_INSTANCE = new HungerSingleton();

    private HungerSingleton() {}

    /**
     * 這種方式其實也不安全
     * 因為當多執行緒在if判斷時如果在同一時刻二者都判斷成立為null，就會創建不同的實體
     */
    public static HungerSingleton getInstance() {
        if (null != HUNGER_SINGLETON_INSTANCE) return HUNGER_SINGLETON_INSTANCE;

        HUNGER_SINGLETON_INSTANCE = new HungerSingleton();
        return HUNGER_SINGLETON_INSTANCE;
    }
}

3.1.1.4、內部類


package com.zixieqing.o4innerclass;

/**
 * <p>@description  : 該類功能  使用內部類實作 - 推薦的一種</p>
 * <p>@package      : com.zixieqing.o4innerclass</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class InnerClassSingleton {

    /**
     * 1、private的構造
     */
    private InnerClassSingleton() {}

    /**
     * 2、private static的內部類
     * 巧妙之處：使用static修飾，則：做到執行緒安全，也巧妙借助了第一種實作方式：使用static的形式
     * 同時：內部類可以訪問外部類的靜態屬性和靜態方法
     */
    private static class NewInstance{
        public static InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }

    /**
     * 3、public static對外提供獲取當前類實體的方法
     */
    public static InnerClassSingleton getInstance() {
        return NewInstance.INSTANCE;
    }
}

3.1.1.5、雙重鎖驗證


package com.zixieqing.o5twinlock;

/**
 * <p>@description  : 該類功能  雙重鎖校驗（執行緒安全）</p>
 * <p>@package      : com.zixieqing.o5twinlock</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class TwinLockSingleton {
    /**
     * 最好加上volatile關鍵字，它的作用是：不進行指令重排（指令重排是JVM中的）
     */
    private static volatile TwinLockSingleton INSTANCE;

    private TwinLockSingleton() {}

    public static TwinLockSingleton getInstance() {

        if (null != INSTANCE) return INSTANCE;

        // 雙重驗證：synchronized 和 if
        synchronized (TwinLockSingleton.class) {
            if (null == INSTANCE) return INSTANCE = new TwinLockSingleton();
        }
        return INSTANCE;
    }
}

3.1.1.6、CAS

package com.zixieqing.o6cas;

import java.util.concurrent.atomic.AtomicReference;

/**
 * <p>@description  : 該類功能  利用CAS演算法實作
 * 好處：CAS的忙等演算法是靠底層硬體，所以：保證了執行緒安全 和 不會產生執行緒的切換和阻塞的開銷，從而提高性能
 *      并且：可以支持較大的并發性
 * </p>
 * <p>@package      : com.zixieqing.o6cas</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class CASSingleton {

    private static CASSingleton CAS_SINGLETON_INSTANCE;

    /**
     * AtomicReference<K> 原子參考  保存“一個”K實體
     */
    private static final AtomicReference<CASSingleton> INSTANCE = new AtomicReference<>();

    public static CASSingleton getInstance() {

        /*
            缺點就在這里：CAS的忙等   從而造成：如果一直沒有獲取就會處于死循壞當中
         */
        while (true) {
            CAS_SINGLETON_INSTANCE = INSTANCE.get();
            if (null != CAS_SINGLETON_INSTANCE) return CAS_SINGLETON_INSTANCE;
        /*
            boolean compareAndSet(V expect, V update)
                expect 預期值
                update 要改成的新值
                如果當前值和預期值相等，那么就以原子的方式將值改為新值

             下列邏輯：期望INSTANCE是null，所以將INSTANCE的值改為new Singleton_CAS()
         */
            INSTANCE.compareAndSet(null, new CASSingleton());
            // 獲取INSTANCE的值 回傳值就是AtomicReference<Singleton_CAS>中的泛型型別
            return INSTANCE.get();
        }
    }
}

3.1.1.6、列舉

package com.zixieqing.o7num;

/**
 * <p>@description  : 該類功能  使用列舉來實作（極度推薦）
 * </p>
 * <p>@package      : com.zixieqing.o7num</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public enum EnumSingleton {

    /**
     * 物件
     */
    INSTANCE;

    /**
    * 根據需要自行配置getter也行
    */
}

3.1.2、原型模式

定義：根據一個已有物件(原型實體) 創建新的物件（就是克隆）

解決的問題：創建重復物件，而這部分物件本身比較復雜，生成程序從庫或者RPC介面中獲取資料的耗時時長可能會很長，因此：采用克隆的方式會節省時間，總之：當系統中需要創建相同或相似的物件時，就可以用原型模式

場景（在開發中貌似都沒用到過）：

1、CV大師（ctrl+c 和 ctrl+v）
2、JavaSE中的Object.clone()

了解兩個名詞：淺拷貝和深拷貝

淺拷貝
- 1、當類的成員變數是基本資料型別時，淺拷貝會將原物件的屬性值賦值給新物件
- 2、當類中成員變數是參考資料型別時，淺拷貝會將原物件的參考資料型別的地址賦值給新物件的成員變數，也就是說兩個物件共享了同一個資料，當其中一個物件修改成員變數的值時，另外一個的值也會隨之改變
深拷貝
- 無論是基本資料型別還是參考資料型別，都會去開辟額外的空間給新物件

3.1.2.1、用Object.clone() API（不推薦）

3.1.2.1.1、克隆基本資料型別

淺拷貝會將原物件的屬性值賦值給新物件（拷貝的是值）
注：String底層被final修飾了的，修改值之后是重新創建了一個Sting物件，修改之后不會影響原物件

package com.zixieqing;

/**
 * <p>@description  : 該類功能  原型類（屬性都是基本資料型別時）
 * Cloneable 標志Object.clone()方法可以對Person該類的實體進行欄位的復制
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Person implements Cloneable{

    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person person = null;
        try {
            person = (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }

    public String getName() {
        return name;
    }

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

package com.zixieqing;


/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {

        Person person = new Person();
        person.setName("紫邪情");

        Person clonePerson = (Person) person.clone();
        System.out.println( "原型物件：" + person);
        System.out.println( "克隆物件：" + clonePerson);

        clonePerson.setName("小紫");

        System.out.println("==========修改之后=============");
        System.out.println(person);
        System.out.println(clonePerson);

    }
}

3.1.2.1.2、克隆參考資料型別

淺拷貝會將原物件的參考資料型別的地址賦值給新物件的成員變數（拷貝的是地址），也就是說兩個物件共享了同一個資料，當其中一個物件修改成員變數的值時，另外一個的值也會隨之改變

package com.zixieqing;

/**
 * <p>@description  : 該類功能  原型類（屬性是參考資料型別時）
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Peron2 implements Cloneable{
    private Person person;

    public Peron2() {
    }

    public Peron2(Person person) {
        this.person = person;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Peron2 peron2 = null;

        try {
            peron2 = (Peron2) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return peron2;
    }

    @Override
    public String toString() {
        return "Peron2{" +
                "person=" + person +
                '}';
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

package com.zixieqing;


/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {

        Peron2 peron2 = new Peron2();
        Person person = new Person("法外狂徒");
        peron2.setPerson(person);

        Peron2 clonePerson2 = (Peron2) peron2.clone();

        System.out.println(peron2);
        System.out.println(clonePerson2);

        person.setName("張三");
        clonePerson2.setPerson(person);

        System.out.println("修改之后");
        System.out.println(peron2);
        System.out.println(clonePerson2);
    }
}

3.1.2.2、使用序列化（推薦）

package com.zixieqing.o2useserialize;

import com.zixieqing.o1useclone.Person;

import java.io.*;

/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing.o2useserialize</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Test {

    public static void main(String[] args) throws IOException {

        Person3 person3 = new Person3(0, new Person("紫邪情"));
        Person3 cloneInstance = cloneInstance(person3);

        System.out.println(person3);
        System.out.println(cloneInstance);

        cloneInstance.setSex(1);

        System.out.println("===========修改之后=============");

        System.out.println(person3);
        System.out.println(cloneInstance);
    }


    /**
     * <p>@description  : 該方法功能 物件序列化克隆
     * </p>
     * <p>@methodName   : cloneInstance</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param person3 要進行序列化克隆的物件
     * @return com.zixieqing.o2useserialize.Person3
     */
    private static Person3 cloneInstance(Person3 person3) throws IOException {
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis;
        ObjectInputStream ois;
        Person3 person = null;

        try {
            // 序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(person3);

            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            person = (Person3) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != bos) bos.close();

            if (null != oos) oos.close();
        }

        return person;
    }
}

* 3.1.3、工廠模式

3.1.3.1、簡單工廠（工廠基礎）

定義：把對類的創建初始化全都交給一個工廠來執行，而用戶不需要關心創建的程序是什么樣的，只需要告訴工廠，我想要什么就行了

設計模式中并沒有所謂的簡單工廠，這玩意兒嚴格來說是一種編碼規范，但是：也是學工廠模式的基礎

簡單工廠的角色

抽象產品：定義產品的規則，即產品有哪些特性和功能，可以是介面、抽象類、普通類也行（但一般不會這么干）
具體產品：實作或繼承抽象產品的子類
產品工廠：提供創建產品的方法，讓使用者通過該方法獲取產品

3.1.3.1.1、簡單邏輯

開發場景：網上買商品，假設有三種購買方式（前面的數字對應其型別）：1、通過優惠卡；2、通過快播兌換卡；3、啥也沒用，直接購買實物商品，根據前面說的三角色來整活

準備作業：依賴匯入

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- LOGGING begin -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.0.9</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

1、抽象產品：定義規則

package com.zixieqing.o1simplefactory.o1simplelogic;

/**
 * <p>@description  : 該類功能  抽象產品：購物
 * </p>
 * <p>@package      : com.zixieqing.o1simplefactory.o1simplelogic</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IShopping {

    /**
     * <p>@description  : 該方法功能 發送商品
     * </p>
     * <p>@methodName   : sendCommodity</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param userId 用戶id
     * @param goodsName  商品名
     */
    void sendCommodity(String userId, String goodsName) throws Exception;
}

2、具體產品：實作或繼承抽象產品的子類

優惠卡方式


  package com.zixieqing.o1simplefactory.o1simplelogic.impl;

  import com.zixieqing.o1simplefactory.o1simplelogic.IShopping;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  /**
   * <p>@description  : 該類功能  具體商品：優惠卡
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o1simplelogic.impl</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class CouponService implements IShopping {

      private Logger logger = LoggerFactory.getLogger(CouponService.class);

      @Override
      public void sendCommodity(String userId, String goodsName) throws Exception {
          logger.info("用戶：{}，通過優惠卡xxxxxx，購買了：{}", userId, goodsName);
      }
  }

快播兌換卡方式


  package com.zixieqing.o1simplefactory.o1simplelogic.impl;

  import com.zixieqing.o1simplefactory.o1simplelogic.IShopping;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  /**
   * <p>@description  : 該類功能  具體商品：快播兌換卡
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o1simplelogic.impl</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class QvodCardService implements IShopping {

      private Logger logger = LoggerFactory.getLogger(QvodCardService.class);

      @Override
      public void sendCommodity(String userId, String goodsName) throws Exception {
          logger.info("用戶：{}，通過快播兌換卡yyyyy，購買了：{}", userId, goodsName);
      }
  }

實物夠買的方式


  package com.zixieqing.o1simplefactory.o1simplelogic.impl;

  import com.zixieqing.o1simplefactory.o1simplelogic.IShopping;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  /**
   * <p>@description  : 該類功能  具體商品：啥也不用，直接實物購買
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o1simplelogic.impl</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class GoodsService implements IShopping {

      private Logger logger = LoggerFactory.getLogger(GoodsService.class);

      @Override
      public void sendCommodity(String userId, String goodsName) throws Exception {
          logger.info("用戶：{}，實物購買了：{}", userId, goodsName);
      }
  }

3、產品工廠：提供創建產品的方法，讓呼叫者通過該工廠獲取產品

package com.zixieqing.o1simplefactory.o1simplelogic;

import com.zixieqing.o1simplefactory.o1simplelogic.impl.CouponService;
import com.zixieqing.o1simplefactory.o1simplelogic.impl.GoodsService;
import com.zixieqing.o1simplefactory.o1simplelogic.impl.QvodCardService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  產品工廠：購物工廠
 * </p>
 * <p>@package      : com.zixieqing.o1simplefactory.o1simplelogic</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ShoppingFactory {

    private Logger logger = LoggerFactory.getLogger(ShoppingFactory.class);

    /**
     * <p>@description  : 該方法功能 購物
     * </p>
     * <p>@methodName   : shopping</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param type  購物方式 1、優惠卡；2、快播兌換卡；3、實物購買
     * @return com.zixieqing.o1simplefactory.o1simplelogic.IShopping
     */
    public IShopping shopping(Integer type) {
        if (null == type) return null;

        logger.info("正在揀貨.....");

        if (1 == type) return new CouponService();

        if (2 == type) return new QvodCardService();

        if (3 == type) return new GoodsService();

        throw new RuntimeException("不存在的商品服務型別");
    }
}

注：如果上面這個工廠的方法加上了static就變成了靜態工廠（靜態方法能被繼承、但不能被重寫）

4、測驗：呼叫者通過工廠獲取對應產品

package com.zixieqing;

import com.zixieqing.o1simplefactory.o1simplelogic.IShopping;
import com.zixieqing.o1simplefactory.o1simplelogic.ShoppingFactory;

/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class APITest {

    public static void main(String[] args) throws Exception{

        ShoppingFactory shoppingFactory = new ShoppingFactory();

        // 1、優惠卡型別
        IShopping shopping_1 = shoppingFactory.shopping(1);
        shopping_1.sendCommodity(System.nanoTime()+"", "充氣娃娃");

        System.out.println("================華麗的分割線===================");

        // 2、快播兌換卡
        IShopping shopping_2 = shoppingFactory.shopping(2);
        shopping_2.sendCommodity(System.nanoTime()+"", "AI女票");

        System.out.println("================華麗的分割線===================");

        IShopping shopping_3 = shoppingFactory.shopping(3);
        shopping_3.sendCommodity(System.nanoTime()+"", "枸杞");

    }
}

上面就是理解簡單工廠的邏輯，總結一丟丟

簡單工廠的邏輯：
由上圖也可知，簡單工廠優點就是呼叫者可以免除直接創建產品物件的責任，而僅僅"消費"產品，明確責任邊界，降低耦合性，當然其缺點也很明顯
- 1、違背了開閉原則
  - 所以從上圖可知：簡單工廠就是橫向發展（不斷加實作類、工廠類中不斷加邏輯判斷）

3.1.3.1.2、更加貼合開發場景的邏輯

1、先決條件：先簡單搞個回傳結果集的工具類

package com.zixieqing.o1simplefactory.o2complex.util;

/**
 * <p>@description  : 該類功能  回傳結果集工具類
 * </p>
 * <p>@package      : com.zixieqing.o1simplefactory.o2complex.util</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ResultUtil {

    /**
     * 編碼
     */
    private String code;

    /**
     * 資訊
     */
    private String info;

    public ResultUtil(String code, String info) {
        this.code = code;
        this.info = info;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

2、優惠卡服務

package com.zixieqing.o1simplefactory.o2complex.coupon;

import com.zixieqing.o1simplefactory.o2complex.util.ResultUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  模擬發放優惠券業務
 * </p>
 * <p>@package      : com.zixieqing.o1simplefactory.o2complex.coupon</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class CouponService {

    private Logger logger = LoggerFactory.getLogger(CouponService.class);

    /**
     * <p>@description  : 該方法功能 發放優惠券
     * </p>
     * <p>@methodName   : sendCoupon</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param uId 用戶id
     * @param couponNumber 分配的優惠券號碼
     * @param uuid  隨機生成的uuid號
     * @return com.zixieqing.o1simplefactory.o2complex.util.ResultUtil
     */
    public ResultUtil sendCoupon(String uId, String couponNumber, String uuid) {
        logger.info("發放優惠券業務準備啟動..........");

        logger.info("用戶：{}，獲得了優惠券：{}", uId, uId + couponNumber + uuid);

        return new ResultUtil("0000", "優惠券發放成功");
    }
}

3、快播兌換卡業務

package com.zixieqing.o1simplefactory.o2complex.qvod;

import com.zixieqing.o1simplefactory.o2complex.util.ResultUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  快播兌換卡業務
 * </p>
 * <p>@package      : com.zixieqing.o1simplefactory.o2complex.qvod</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class QvodService {

    private Logger logger = LoggerFactory.getLogger(QvodService.class);

    /**
     * <p>@description  : 該方法功能 授予兌換卡
     * </p>
     * <p>@methodName   : grentToken</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param phone 用戶手機號
     * @param cardId  隨機生成的卡號
     * @return com.zixieqing.o1simplefactory.o2complex.util.ResultUtil 
     */
    public ResultUtil grentToken(String phone, String cardId) {
        logger.info("授予的兌換卡為：{}", phone + cardId);
        return new ResultUtil("0000", phone + cardId);
    }
}

4、實物購買商品業務

輔助物件


  package com.zixieqing.o1simplefactory.o2complex.goods;

  /**
   * <p>@description  : 該類功能  實物購買：支付要求物件
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o2complex.goods</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class DeliverRequest {


      /**
       * 用戶姓名
       */
      private String userName;
      /**
       * 用戶手機
       */
      private String userPhone;
      /**
       * 商品SKU：庫存保有單位
       */
      private String sku;
      /**
       * 訂單ID
       */
      private String orderId;
      /**
       * 識訓人姓名
       */
      private String consigneeUserName;
      /**
       * 識訓人手機
       */
      private String consigneeUserPhone;
      /**
       * 識訓人地址
       */
      private String consigneeUserAddress;

      public String getUserName() {
          return userName;
      }

      public void setUserName(String userName) {
          this.userName = userName;
      }

      public String getUserPhone() {
          return userPhone;
      }

      public void setUserPhone(String userPhone) {
          this.userPhone = userPhone;
      }

      public String getSku() {
          return sku;
      }

      public void setSku(String sku) {
          this.sku = sku;
      }

      public String getOrderId() {
          return orderId;
      }

      public void setOrderId(String orderId) {
          this.orderId = orderId;
      }

      public String getConsigneeUserName() {
          return consigneeUserName;
      }

      public void setConsigneeUserName(String consigneeUserName) {
          this.consigneeUserName = consigneeUserName;
      }

      public String getConsigneeUserPhone() {
          return consigneeUserPhone;
      }

      public void setConsigneeUserPhone(String consigneeUserPhone) {
          this.consigneeUserPhone = consigneeUserPhone;
      }

      public String getConsigneeUserAddress() {
          return consigneeUserAddress;
      }

      public void setConsigneeUserAddress(String consigneeUserAddress) {
          this.consigneeUserAddress = consigneeUserAddress;
      }
  }

業務

  package com.zixieqing.o1simplefactory.o2complex.goods;

  import com.alibaba.fastjson.JSON;
  import com.zixieqing.o1simplefactory.o2complex.util.ResultUtil;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  /**
   * <p>@description  : 該類功能  實物購買商品業務
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o2complex.goods</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class GoodsService {

      private Logger logger = LoggerFactory.getLogger(GoodsService.class);

      /**
       * <p>@description  : 該方法功能 發貨
       * </p>
       * <p>@methodName   : deliverGoods</p>
       * <p>@author: ZiXieqing</p>
       * <p>@version: V1.0.0</p>
       * @param deliverRequest  輔助：支付物件
       * @return com.zixieqing.o1simplefactory.o2complex.util.ResultUtil 
       */
      public ResultUtil deliverGoods(DeliverRequest deliverRequest) {
          logger.info("模擬發送實物商品一個：{}", JSON.toJSONString(deliverRequest));
          return new ResultUtil("0000", "發貨成功：" + deliverRequest);
      }
  }

5、抽象產品：定義規則

package com.zixieqing.o1simplefactory.o2complex;

import java.util.Map;

/**
 * <p>@description  : 該類功能  商品
 * </p>
 * <p>@package      : com.zixieqing.o1simplefactory.o2complex</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface ICommodityService {

    /**
     * <p>@description  : 該方法功能 發送商品
     * </p>
     * <p>@methodName   : sendCommodity</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param uId 用戶id
     * @param commodityId 商品id
     * @param bizId 業務id
     * @param extMap  擴展資訊
     */
    void sendCommodity(String uId, String commodityId, String bizId, Map<String, String> extMap) throws Exception;
}

6、具體商品：實作或繼承抽象產品的子類

優惠卡

  package com.zixieqing.o1simplefactory.o2complex.impl;

  import com.zixieqing.o1simplefactory.o2complex.ICommodityService;
  import com.zixieqing.o1simplefactory.o2complex.coupon.CouponService;
  import com.zixieqing.o1simplefactory.o2complex.util.ResultUtil;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  import java.util.Map;
  import java.util.UUID;

  /**
   * <p>@description  : 該類功能  TODO
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o2complex.impl</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class CouponCommodityServiceImpl implements ICommodityService {

      private Logger logger = LoggerFactory.getLogger(CouponCommodityServiceImpl.class);

      /**
       * 模擬@autowried注入
       */
      private CouponService couponService = new CouponService();

      @Override
      public void sendCommodity(String uId, String commodityId, String bizId, Map<String, String> extMap) throws Exception {
          ResultUtil result = couponService.sendCoupon(uId, commodityId, UUID.randomUUID().toString());

          if (!"0000".equals(result.getCode()))
              throw new RuntimeException(result.getInfo());
      }
  }

快播兌換卡

  package com.zixieqing.o1simplefactory.o2complex.impl;

  import com.zixieqing.o1simplefactory.o2complex.ICommodityService;
  import com.zixieqing.o1simplefactory.o2complex.qvod.QvodService;
  import com.zixieqing.o1simplefactory.o2complex.util.ResultUtil;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  import java.util.Map;

  /**
   * <p>@description  : 該類功能  快播兌換卡發貨
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o2complex.impl</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class QvodCommodityServiceImpl implements ICommodityService {

      private Logger logger = LoggerFactory.getLogger(CouponCommodityServiceImpl.class);

      /**
       * 模擬注入
       */
      private QvodService qvodService = new QvodService();

      @Override
      public void sendCommodity(String uId, String commodityId, String bizId, Map<String, String> extMap) throws Exception {
          // 這里把電話號碼定死，模擬而已
          ResultUtil result = qvodService.grentToken("12345678910", bizId + commodityId);

          logger.info("通過快播兌換卡：{}，獲取商品：{}", bizId + commodityId, commodityId);

          if (!"0000".equals(result.getCode()))
              throw new RuntimeException(result.getInfo());
      }
  }

實物購買

  package com.zixieqing.o1simplefactory.o2complex.impl;

  import com.zixieqing.o1simplefactory.o2complex.ICommodityService;
  import com.zixieqing.o1simplefactory.o2complex.goods.DeliverRequest;
  import com.zixieqing.o1simplefactory.o2complex.goods.GoodsService;
  import com.zixieqing.o1simplefactory.o2complex.util.ResultUtil;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  import java.util.Map;

  /**
   * <p>@description  : 該類功能  實物購買商品
   * </p>
   * <p>@package      : com.zixieqing.o1simplefactory.o2complex.impl</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class GoodsCommodityServiceImpl implements ICommodityService {

      private Logger logger = LoggerFactory.getLogger(GoodsCommodityServiceImpl.class);

      /**
       * 模擬注入
       */
      private GoodsService goodsService = new GoodsService();

      @Override
      public void sendCommodity(String uId, String commodityId, String bizId, Map<String, String> extMap) throws Exception {
          DeliverRequest deliverRequest = new DeliverRequest();
          // 下面這些資訊去資料庫搞出來
          deliverRequest.setUserName("紫邪情");
          deliverRequest.setUserPhone("123143124342");
          deliverRequest.setSku(commodityId);
          deliverRequest.setOrderId(bizId);
          deliverRequest.setConsigneeUserName(extMap.get("consigneeUserName"));
          deliverRequest.setConsigneeUserPhone(extMap.get("consigneeUserPhone"));
          deliverRequest.setConsigneeUserAddress(extMap.get("consigneeUserAddress"));

          ResultUtil result = goodsService.deliverGoods(deliverRequest);

          if (!"0000".equals(result.getCode()))
              throw new RuntimeException(result.getInfo());
      }
  }

7、產品工廠：提供創建產品的方法，讓呼叫者通過該方法獲取產品

package com.zixieqing.o1simplefactory.o2complex;

import com.zixieqing.o1simplefactory.o2complex.impl.CouponCommodityServiceImpl;
import com.zixieqing.o1simplefactory.o2complex.impl.GoodsCommodityServiceImpl;
import com.zixieqing.o1simplefactory.o2complex.impl.QvodCommodityServiceImpl;

/**
 * <p>@description  : 該類功能  產品工廠
 * </p>
 * <p>@package      : com.zixieqing.o1simplefactory.o2complex</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class CommodityFactory {

    /**
     * <p>@description  : 該方法功能 獲取產品
     * </p>
     * <p>@methodName   : getCommodity</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param type  產品型別
     * @return com.zixieqing.o1simplefactory.o2complex.ICommodityService 
     */
    public ICommodityService getCommodity(Integer type) {
        if (1 == type) return new CouponCommodityServiceImpl();

        if (2 == type) return new QvodCommodityServiceImpl();

        if (3 == type) return new GoodsCommodityServiceImpl();

        throw new RuntimeException("不合法的商品型別");
    }
}

8、測驗

package com.zixieqing;

import com.zixieqing.o1simplefactory.o1simplelogic.IShopping;
import com.zixieqing.o1simplefactory.o1simplelogic.ShoppingFactory;
import com.zixieqing.o1simplefactory.o2complex.CommodityFactory;
import com.zixieqing.o1simplefactory.o2complex.ICommodityService;

import java.util.UUID;

/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class APITest {

    public static void main(String[] args) throws Exception{

        System.out.println("================華麗的分割線：簡單結合業務開發進行測驗===================");

        CommodityFactory commodityFactory = new CommodityFactory();

        // 1、優惠卡型別
        ICommodityService commodity_1 = commodityFactory.getCommodity(1);
        commodity_1.sendCommodity(System.nanoTime() + "",
                System.currentTimeMillis() + "",
                UUID.randomUUID() + "",
                null);

        // 2、快播兌換卡
        ICommodityService commodity_2 = commodityFactory.getCommodity(2);
        commodity_2.sendCommodity(System.nanoTime() + "",
                System.currentTimeMillis() + "",
                UUID.randomUUID() + "",
                null);

        // 3、實物購買
        ICommodityService commodity_3 = commodityFactory.getCommodity(3);
        HashMap<String, String> extMap = new HashMap<>();
        extMap.put("consigneeUserName", "紫邪情");
        extMap.put("consigneeUserPhone", "31343214321432");
        extMap.put("consigneeUserAddress", "浙江省.杭州市.余杭區.XX街道.YY小區.324134321431");
        commodity_3.sendCommodity(System.nanoTime() + "",
                System.currentTimeMillis() + "",
                UUID.randomUUID() + "",
                extMap);
    }
}

3.1.3.1.3、構建出簡單工廠的方式

廢話文學

1、思考要創建的幾個實體（具體產品）之間有什么共通性
2、將多個實體的共通性抽取成一個介面（抽象產品）
3、使用一個工廠來對創建的實體進行判斷，從而讓呼叫者根據條件得到想要的實體物件（還可以結合反射來創建物件）
4、然后根據下圖進行架構即可

3.1.3.2、工廠方法模式

定義：定義一個創建物件的介面，但由子類（具體工廠）決定要實體化的類是哪一個，工廠方法讓類把實體化推遲到子類
解決的問題：明確地計劃不同條件下創建不同實體時就可以考慮是否采用工廠模式，從而提高擴展性，減少以后的改代碼量

廢話文學：

工廠方法模式的角色
- 抽象工廠角色：工廠方法模式的核心，是具體工廠角色必須實作的介面或者繼承的父類
- 具體工廠角色：含有和具體業務邏輯有關的代碼，由業務呼叫創建對應的具體產品的物件
- 抽象產品角色：是具體產品繼承的父類或者是實作的介面
- 具體產品角色：具體工廠角色所創建的物件就是此角色的實體
工廠方法模式這玩意兒其實就是在簡單工廠的基礎上稍微變了一下而已，多了一層罷了（沒什么是加一層解決不了的，一層不行，那就再來一層），這里加的這一層就是對業務層再抽象了一下而已
簡單工廠是橫向發展（不斷橫向添加實作類），而工廠方法模式本質是為了解決簡單工廠模式的問題（違背開閉原則），所以優點和簡單工廠模式一樣，其是縱向發展（不斷縱向添加工廠類+實作類）
簡單工廠模式
工廠方法模式：
- 從上圖可以看出：工廠方法模式做的是同一類產品（一條流水線開機時不會還搞多產品加工吧），這個點就是和下面抽象工廠的最大區別（抽象工廠針對的是產品簇）

3.1.3.2.1、Java中使用工廠方法模式的地方

這個東西其實在剛剛前面的代碼中有一個東西就用到了，即：SLF4J日志門面，前面用了一個LoggerFactory，它里面就用到了工廠方法模式

1、進入getLogger()

// 進入getLogger()
private Logger logger = LoggerFactory.getLogger(QvodService.class);


// 得到的代碼
    public static Logger getLogger(Class clazz) {
        // 進入這里的getLogger()
        return getLogger(clazz.getName());
    }

// 得到代碼
    public static Logger getLogger(String name) {
        // 再看一下getILoggerFactory()
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }

// getILoggerFactory()的代碼
    public static ILoggerFactory getILoggerFactory() {
        if (INITIALIZATION_STATE == 0) {
            INITIALIZATION_STATE = 1;
            performInitialization();
        }

        switch(INITIALIZATION_STATE) {
        case 1:
			// 重點1、static SubstituteLoggerFactory TEMP_FACTORY = new SubstituteLoggerFactory();
            return TEMP_FACTORY;
        case 2:
            throw new IllegalStateException("org.slf4j.LoggerFactory could not be successfully initialized. See also http://www.slf4j.org/codes.html#unsuccessfulInit");
        case 3:
            return StaticLoggerBinder.getSingleton().getLoggerFactory();
        case 4:
			// 重點2、static NOPLoggerFactory NOP_FALLBACK_FACTORY = new NOPLoggerFactory();
            return NOP_FALLBACK_FACTORY;
        default:
            throw new IllegalStateException("Unreachable code");
        }
    }

上面的兩個：TEMP_FACTORY、NOP_FALLBACK_FACTORY都實作了ILoggerFactory

2、看一眼ILoggerFactory

// 這個就是根工廠：定義最大規則的那個叼毛
public interface ILoggerFactory {
    Logger getLogger(String var1);
}

逆向回來，邏輯就變成如下的樣子

廢話文學

在開發中怎么使用工廠方法模式（下列邏輯不止適用于此模式，創建型、行為型、結構型均適合，了解每種型別針對的是對什么做架構即可，如：是對類中方法、還是類本身等等做架構來進行抽離，最后時間長了一看需求就知道咋個設計了）
- 1、思考自己要創建的幾個實體（即：具體產品）有什么共通性
- 2、將共通性抽取出來變成一個介面或抽象類（即：抽象產品）
- 3、思考對每一個實體（產品）弄一個工廠類之后（即：具體工廠），那這幾個工廠類之間又有什么共通性
- 4、將工廠類的共通性抽取出來變成一個介面（即：抽象工廠）
- 5、當然：再考慮以后應該會在什么地方添加功能、是否會擴展的話更好，但這一條需要經驗積累
- 6、然后使用下圖方式做架構即可

3.1.3.2.2、實體

場景：檔案決議，假設有兩種：1、xml檔案決議；2、json檔案決議

邏輯如下

1、抽象產品

package com.zixieqing.o2factorymethod;

/**
 * <p>@description  : 該類功能  檔案決議器
 * </p>
 * <p>@package      : com.zixieqing.o2factorymethod</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IFileParser {

    String parse();
}

2、具體產品

json決議


  package com.zixieqing.o2factorymethod.impl;

  import com.zixieqing.o2factorymethod.IFileParser;

  /**
   * <p>@description  : 該類功能  json檔案決議器
   * </p>
   * <p>@package      : com.zixieqing.o2factorymethod.impl</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class JsonFileParse implements IFileParser {
      @Override
      public String parse() {
          return "這里就搞json檔案決議的邏輯";
      }
  }

xml決議


  package com.zixieqing.o2factorymethod.impl;

  import com.zixieqing.o2factorymethod.IFileParser;

  /**
   * <p>@description  : 該類功能  xml檔案決議器
   * </p>
   * <p>@package      : com.zixieqing.o2factorymethod</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class XMLFileParse implements IFileParser {
      @Override
      public String parse() {
          return "這里就搞xml檔案的決議邏輯";
      }
  }

3、抽象工廠

package com.zixieqing.o2factorymethod.factory;

import com.zixieqing.o2factorymethod.IFileParser;

/**
 * <p>@description  : 該類功能  決議器抽象工廠
 * </p>
 * <p>@package      : com.zixieqing.o2factorymethod</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IParserFactory {

    IFileParser parse();
}

4、具體工廠

json決議工廠


  package com.zixieqing.o2factorymethod.factory.impl;

  import com.zixieqing.o2factorymethod.IFileParser;
  import com.zixieqing.o2factorymethod.factory.IParserFactory;
  import com.zixieqing.o2factorymethod.impl.JsonFileParse;

  /**
   * <p>@description  : 該類功能  json決議工廠
   * </p>
   * <p>@package      : com.zixieqing.o2factorymethod.factory</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class JsonParseFactory implements IParserFactory {

      @Override
      public IFileParser parse() {
          return new JsonFileParse();
      }
  }

xml決議工廠


  package com.zixieqing.o2factorymethod.factory.impl;

  import com.zixieqing.o2factorymethod.IFileParser;
  import com.zixieqing.o2factorymethod.factory.IParserFactory;
  import com.zixieqing.o2factorymethod.impl.XMLFileParse;

  /**
   * <p>@description  : 該類功能  xml決議工廠
   * </p>
   * <p>@package      : com.zixieqing.o2factorymethod.factory</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class XMLParseFactory implements IParserFactory {
      @Override
      public IFileParser parse() {
          return new XMLFileParse();
      }
  }

3.1.3.3、抽象工廠模式

定義：在工廠方法模式的基礎上，對工廠進行變化一下

解決的問題：產品簇的問題（一個中心工廠來創建其他工廠）

對于產品簇百度有一個通俗易懂的解釋：指具有相同或相似的功能結構或性能，共享主要的產品特征、組件或子結構，并通過變型配置來滿足特定市場的一組產品的聚類

廢話文學對產品簇的解釋：產品簇是指工廠生產出的產品們之間彼此具備強關聯，比如：AK47工廠生產的 AK47步槍、AK47專配的子彈，一旦 AK47裝錯了子彈是無法正常開槍的（甚至會炸膛）

抽象工廠模式的角色

抽象工廠角色：工廠方法模式的核心，是具體工廠角色必須實作的介面或者繼承的父類
具體工廠角色：含有和具體業務邏輯有關的代碼，由業務呼叫創建對應的具體產品的物件
抽象產品角色：是具體產品繼承的父類或者是實作的介面
具體產品角色：具體工廠角色所創建的物件就是此角色的實體

抽象工廠模式邏輯舉例（上面的四角色自行對應）

3.1.3.3.1、簡單邏輯實作

就用上面說的家具來舉例

1、椅子介面（抽象產品）

package com.zixieqing.o3abstractfactory;

/**
 * <p>@description  : 該類功能  抽象產品：椅子介面
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IChair {

    /**
     * <p>@description  : 該方法功能 生產椅子
     * </p>
     * <p>@methodName   : createChair</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     *
     * @return java.lang.String
     */
    String create();
}

1.1、木質桌子（具體產品）

package com.zixieqing.o3abstractfactory.impl;

import com.zixieqing.o3abstractfactory.IChair;

/**
 * <p>@description  : 該類功能  具體產品：木質椅子
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class WoodenChair implements IChair {
    @Override
    public String create() {
        return "木質椅子";
    }
}

1.2、塑料桌子（具體產品）

package com.zixieqing.o3abstractfactory.impl;

import com.zixieqing.o3abstractfactory.IChair;

/**
 * <p>@description  : 該類功能  具體產品：塑料椅子
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class PlasticChair implements IChair {
    @Override
    public String create() {
        return "塑料椅子";
    }
}

2、桌子介面（抽象產品）

package com.zixieqing.o3abstractfactory;

/**
 * <p>@description  : 該類功能  抽象產品：桌子介面
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IDesk {

    /**
     * <p>@description  : 該方法功能 生產桌子
     * </p>
     * <p>@methodName   : create</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     *
     * @return java.lang.String
     */
    String create();

}

木質桌子

package com.zixieqing.o3abstractfactory.impl;

import com.zixieqing.o3abstractfactory.IDesk;

/**
 * <p>@description  : 該類功能  具體產品：木質桌子
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class WoodenDesk implements IDesk {
    @Override
    public String create() {
        return "木質桌子";
    }
}

塑料桌子

package com.zixieqing.o3abstractfactory.impl;

import com.zixieqing.o3abstractfactory.IDesk;

/**
 * <p>@description  : 該類功能  具體產品：塑料桌子
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class PlastidDeck implements IDesk {
    @Override
    public String create() {
        return "塑料桌子";
    }
}

3、家具抽象工廠

package com.zixieqing.o3abstractfactory;

/**
 * <p>@description  : 該類功能  抽象工廠：家具工廠
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IFurnitureFactory {

    IChair createChair();

    IDesk createDesk();
}

木質家具工廠

package com.zixieqing.o3abstractfactory.factory;

import com.zixieqing.o3abstractfactory.IChair;
import com.zixieqing.o3abstractfactory.IDesk;
import com.zixieqing.o3abstractfactory.IFurnitureFactory;
import com.zixieqing.o3abstractfactory.impl.WoodenChair;
import com.zixieqing.o3abstractfactory.impl.WoodenDesk;

/**
 * <p>@description  : 該類功能  具體工廠：專門生產木質家具這一產品簇需要的東西
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory.factory</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class WoodenIFurnitureFactory implements IFurnitureFactory {
    @Override
    public IChair createChair() {
        return new WoodenChair();
    }

    @Override
    public IDesk createDesk() {
        return new WoodenDesk();
    }
}

塑料家具工廠

package com.zixieqing.o3abstractfactory.factory;

import com.zixieqing.o3abstractfactory.IChair;
import com.zixieqing.o3abstractfactory.IDesk;
import com.zixieqing.o3abstractfactory.IFurnitureFactory;
import com.zixieqing.o3abstractfactory.impl.PlasticChair;
import com.zixieqing.o3abstractfactory.impl.PlastidDeck;

/**
 * <p>@description  : 該類功能  具體工廠：專門生產塑料家具這一產品簇需要的東西
 * </p>
 * <p>@package      : com.zixieqing.o3abstractfactory</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class PlasticFurnitureFactory implements IFurnitureFactory {
    @Override
    public IChair createChair() {
        return new PlasticChair();
    }

    @Override
    public IDesk createDesk() {
        return new PlastidDeck();
    }
}

4、測驗

package com.zixieqing;

import com.zixieqing.o3abstractfactory.factory.PlasticFurnitureFactory;
import com.zixieqing.o3abstractfactory.factory.WoodenIFurnitureFactory;

/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class AbstractFactoryTest {

    public static void main(String[] args) {
        // 木質椅子
        String chair = new WoodenIFurnitureFactory().createChair().create();
        // 木質桌子
        String desk = new PlasticFurnitureFactory().createDesk().create();

        System.out.println(chair + "+" +desk);

        // 想要塑料家具這個產品簇的東西，就去找塑料家具工廠即可
    }
}

3.1.3.2、工廠方法VS抽象工廠模式

廢話文學

1、首先兩個模式都可以生產產品 / 創建實體
2、其次看前面的定義：
- 工廠方法針對的是“某種產品”，繼而成為“某種產品A” 對應 “某工廠A”
- 抽象工廠針對的是“某類產品”，繼而變成“某工廠B” 生產 “某類產品”（可以得到這類產品的實體，也可以得到這類產品的零部件）
3、情景理解：
- 工廠方法模式就像華為手機專賣店一樣，賣的是這一種手機
- 抽象工廠模式就像手機售賣店一樣，可以買到華為、小米等手機，同時也可以根據自己需要買到自己手機的零部件
4、在場景上（注意看下圖，兩個很像的，但注意看下圖中抽象工廠、抽象產品這兩個地方）：
- 工廠方法模式：它是讓某一條產品線上的產品更易被擴展（要擴展就是下圖加工廠和實作類唄）
- 抽象工廠模式：它是讓多條產品線中，既保證這多條產品線中的單條產品線的產品更易被擴展的同時，又保證多條產品線之間遵循著同樣的約束

* 3.1.4、建造者模式

定義：將一個復雜物件的構建與表示分離，使得同樣的構建程序可以創建不同的表示；另外：建造者模式又叫生成器模式

換言之：將多個簡單物件通過一步一步組裝，最后變成復雜物件的程序；同時：簡單物件之間的組裝（相同的物料）通過相似的組裝程序可以得到不一樣的復雜物件（即：相同 / 相似的物料，不同的繁瑣組裝，得到不同的物件[此物件是一個復雜物件組合起來的]）

典型例子：計算機有顯示幕、滑鼠、鍵盤等等部件，不同用戶想要的電腦樣子、配置不一樣，但都只需要和售賣員講一下自己要的，最后店鋪就會組裝好用戶想要的電腦給用戶

注意：核心點是“相同或相似的組成成分”，即：創建物件需要很多步驟，但是步驟的順序不一定固定，這種場景才是使用建造者模式的最佳場景（開發經典例子：一個類的內部結構很復雜，如有很多屬性時，就可以考慮用建造者模式改造一下）

建造者角色

產品（Product）：就是最終要創建的產品物件
抽象建造者（Builder）：規范產品物件的各個組成部分的建造；可以是介面或抽象類；相當于：老板，專門約束下級的
具體建造者（ConcreteBuilder）：實作或繼承抽象建造者的子類；是創建產品物件的執行者；相當于：真正干活的人
指揮者（Director）：負責產品物件的構建次序（注：這個叼毛可有可無），就相當于：有圖紙的工程師；它和抽象建造者是關聯關系（即：這里面的方法回傳值型別是抽象建造者型別）
- 可有可無的原因：呼叫者萬一就是個懂行的，那還要專門找個看圖紙的干嘛，直接上場指揮產品應該按什么順序構建就可以了
- 由于這個指揮者可有可無，所以這個建造者模式的寫法相當靈活，建造者模式的核心是抽象建造者和具體建造者，其他的隨意變（結合其他設計模式、結合自己認為不影響邏輯的設計都可以），要么介面+實作類，要么抽象類+繼承類，但是也得注意：抽象建造者里面的成員需要滿足的條件，即：方法或屬性的設計（換言之：就是依賴倒置原則，只是對屬性或方法進行了要求，從而做到讓物件的構建獨立（產品物件的屬性構建順序：可以通過指揮者、也可以直接完全交給呼叫者），表示分離（直接交給具體構建者，最后得到一個產品物件即可）

3.1.4.1、簡單邏輯

3.1.4.1.1、有指揮者的情況

注：以下邏輯不是固定的，可以隨意變化

大體類圖如下

1-1、產品物件

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  產品物件：電腦
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Computer {

    /**
     * 電腦主機
     */
    private String host;

    /**
     * 電腦顯示幕
     */
    private String monitor;

    /**
     * 擴展資訊
     */
    private String extendMap;

    @Override
    public String toString() {
        return "Computer{" +
                "host='" + host + '\'' +
                ", monitor='" + monitor + '\'' +
                ", extendMap='" + extendMap + '\'' +
                '}';
    }

    public void setHost(String host) {
        this.host = host;
    }

    public void setMonitor(String monitor) {
        this.monitor = monitor;
    }

    public void setExtendMap(String extendMap) {
        this.extendMap = extendMap;
    }
}

1-2、抽象建造者

package com.zixieqing.o1simple.builder;

import com.zixieqing.o1simple.Computer;

/**
 * <p>@description  : 該類功能  抽象建造者：老板 約束下級
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IComputerBuilder {

    IComputerBuilder buildHost();

    IComputerBuilder buildMonitor();

    IComputerBuilder buildExtendMap();

    Computer getComputer();
}

1-3、具體建造者

package com.zixieqing.o1simple.builder;

import com.zixieqing.o1simple.Computer;

/**
 * <p>@description  : 該類功能  具體建造者：干活的員工
 * </p>
 * <p>@package      : com.zixieqing.o1simple.builder</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ComputerBuilder implements IComputerBuilder{

    /**
     * 組合產品物件
     */
    private Computer computer = new Computer();


    /**
     * 產品物件零部件：建造主機
     */
    @Override
    public ComputerBuilder buildHost() {
        computer.setHost("主機配置");
      /*
        回傳this就是成為鏈式呼叫的關鍵，如：
        computerBuilder.buildMonitor()
                        .buildHost()
                        .buildExtendMap()
                        .getComputer();
      */
        return this;
    }

    /**
     * 產品物件零部件：顯示幕型別
     */
    @Override
    public ComputerBuilder buildMonitor() {
        computer.setMonitor("顯示幕型別");
        return this;
    }

    /**
     * 產品物件零部件：額外資訊
     */
    @Override
    public ComputerBuilder buildExtendMap() {
        computer.setExtendMap("額外資訊");
        return this;
    }

    /**
     * 回傳構建好的復雜物件 / 產品物件
     */
    @Override
    public Computer getComputer() {
        return computer;
    }
}

1-4、指揮者

package com.zixieqing.o1simple.builder;

import com.zixieqing.o1simple.Computer;

/**
 * <p>@description  : 該類功能  指揮者：拿圖紙的工程師，負責產品物件的構建順序
 * </p>
 * <p>@package      : com.zixieqing.o1simple.builder</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ComputerDirector {

    private static IComputerBuilder computerBuilder = new ComputerBuilder();

    public static Computer getComputer() {
        // 1、先搞顯示幕
        return computerBuilder.buildMonitor()
                // 在搞主機配置(這里能夠進行鏈式呼叫，就是因為具體建造者中建造各部件(屬性)時使用了return this的原因)
                .buildHost()
                // 最后弄其他配置資訊
                .buildExtendMap()
                .getComputer();
    }
}

1-5、測驗

package com.zixieqing;

import com.zixieqing.o1simple.builder.ComputerDirector;

/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class APITest {

    public static void main(String[] args) {

        System.out.println(ComputerDirector.getComputer());
    }
}

1-6、結果

Computer{host='主機配置', monitor='顯示幕型別', extendMap='額外資訊'}

3.1.4.1.2、沒有指揮者的情況

有的時候會面臨一種情況

上面這個指揮者中的代碼多此一舉了，這種應該直接交給呼叫者就行了，由呼叫者自己來安排產品物件的構建順序是怎么樣的，因此：稍微變一下，把指揮者去掉，然后呼叫者直接去找建造者即可（抽象建造者、具體建造者代碼不變，直接去掉指揮者），那呼叫就變成如下的樣子

package com.zixieqing;

import com.zixieqing.o1simple.Computer;
import com.zixieqing.o1simple.builder.ComputerBuilder;
import com.zixieqing.o1simple.builder.ComputerDirector;
import com.zixieqing.o1simple.builder.IComputerBuilder;

/**
 * <p>@description  : 該類功能  測驗
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class APITest {

    public static void main(String[] args) {

        IComputerBuilder computerBuilder = new ComputerBuilder();

        Computer computer = computerBuilder.buildHost()
                .buildExtendMap()
                .buildMonitor()
                .getComputer();

        System.out.println(computer);
    }
}

看到上面這個樣子是不是感覺熟悉了，就是JDK中StringBuilder的append()這個API的設計模式，當然：要是使用過MyBatis的xml開發模式，那里面有一個使用SqlSessionFactoryBuilder來獲取SqlSessionFactory，這里也用到了這個設計模式，甚至Spring底層的BeanDefinitionBuilder通過getBeanDefinition獲取BeanDefinition物件也用到了

        StringBuilder builder = new StringBuilder();

        builder.append("張三")
               .append("李四")
               .append("大刀王五")
               .append("王麻子");

看到上面這種是自己傳值進去的，所以抽象建造者就又可以變一下了唄（產品物件的各部件物件的構建，值優呼叫者傳進去），如：

package com.zixieqing.o1simple.builder;

import com.zixieqing.o1simple.Computer;

/**
 * <p>@description  : 該類功能  抽象建造者：老板 約束下級
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IComputerBuilder {

    // 這樣甩手掌柜就可以甩得稍微徹底點了
    IComputerBuilder buildHost(String host);

    IComputerBuilder buildMonitor(String monitor);

    IComputerBuilder buildExtendMap(String extendMap);

    Computer getComputer();
}

甚至說：要是是類似于SpringBoot的自動轉配呢？需要的一些東西在組態檔中，可不可以結合工廠模式去進行加載呢（單例模式隨便一個地方都可以扔進去）？

4、下一篇：行為型設計模式

鏈接：https://www.cnblogs.com/xiegongzi/p/16860825.html

援助博主：若您覺得閱讀本文對您有幫助，請點一下右邊"推薦"按鈕，我在此感謝！當然您也可以選擇[ 關注我 ]，可以很方便找到我！
本人原則：本人的博文內容出發點是筆記梳理和知識分享，但：還請不要進行大部分內容"原封不動"的復制粘貼！
本文著作權：歸作者紫邪情所有
來源網址：https://www.cnblogs.com/xiegongzi/p/16911098.html
侵權說明：本文若有侵權的地方，請聯系我，我會立刻整改！

本人沒有對復制博文內容進行宣告嵌套，所以歡迎各位進行少量內容復制粘貼、參考等操作，但若是進行大部分內容復制粘貼、參考等行為，那麻煩在文章頁面明顯位置給出原文連接，否則我若知曉，必會進行追究！
最后：限于本人水平，如果文章和代碼有表述不當之處，還請在評論區指明，我感激不盡！

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/538873.html

標籤：其他

上一篇：(Java)設計模式：創建型

下一篇：一言不合就重構