【設計模式①】單例、原型、工廠方法、抽象工廠模式

環境

Java：1.8.0_202-b08
dependency：

lombok 1.18.6

Guava 27.0.1-jre

slf4j-log4j12 1.7.25
Github Repositories: https://github.com/ilssio/design-pattern

1. 單例模式

a). 定義：

Java中單例模式定義：“一個類有且僅有一個實例，並且自行實例化向整個系統提供。”

b). 實現

請看註釋
①

package io.ilss.pattern.singleton;

/**
 * @author : feng
 * @description: SingletonThree
 * @date : 2019-04-11 15:42
 * @version: : 1.0
 */
public class SingletonOne {

    private final static SingletonOne INSTANCE = new SingletonOne();

    private SingletonOne(){}

    public static SingletonOne getInstance(){
        return INSTANCE;
    }

    /**
     * 第一種：餓漢式 使用靜態常量直接new
     *
     * 在類加載的時候，完成實例，可以避免線程同步問題
     */
}

②

package io.ilss.pattern.singleton;

/**
 * @author : feng
 * @description: SingletonThree
 * @date : 2019-04-11 15:54
 * @version: : 1.0
 */
public class SingletonTwo {
    private final static SingletonTwo INSTANCE;

    static {
        INSTANCE = new SingletonTwo();
    }

    private SingletonTwo() {}

    public static SingletonTwo getInstance() {
        return INSTANCE;
    }

    /**
     * 第二種：餓漢式 使用靜態代碼塊
     *
     * 和第一種類似
     */
}

③

package io.ilss.pattern.singleton;

/**
 * @author : feng
 * @description: SingletonThree
 * @date : 2019-04-11 16:01
 * @version: : 1.0
 */
public class SingletonThree {
    private static SingletonThree SingletonThree;

    private SingletonThree() {}

    public static SingletonThree getInstance() {
        if (SingletonThree == null) {
            SingletonThree = new SingletonThree();
        }
        return SingletonThree;
    }

    /**
     * 第三種：懶漢式 通過getInstance方法中空判斷來實現
     *
     * 注：此種方法線程不安全，多線程情況 不推薦使用。
     *
     */
}

④

package io.ilss.pattern.singleton;

/**
 * @author : feng
 * @description: SingletonFour
 * @date : 2019-04-11 16:11
 * @version: : 1.0
 */
public class SingletonFour {

    private static SingletonFour INSTANCE;

    private SingletonFour() {
    }

    public static synchronized SingletonFour getInstance() {
        if (null == INSTANCE) {
            INSTANCE = new SingletonFour();
        }
        return INSTANCE;
    }

    /**
     * 第四種：懶漢式 使用synchronized同步鎖實現
     *
     * 因爲使用了方法級鎖，效率偏低。
     */
}

⑤

package io.ilss.pattern.singleton;

/**
 * @author : feng
 * @description: SingletonFive
 * @date : 2019-04-11 16:17
 * @version: : 1.0
 */
public class SingletonFive {

    private static SingletonFive INSTANCE;

    private SingletonFive() { }

    public static SingletonFive getInstance() {
        if (null == INSTANCE) {
            synchronized (SingletonFive.class) {
                if (null == INSTANCE) {
                    INSTANCE = new SingletonFive();
                }
            }
        }
        return INSTANCE;
    }

    /**
     * 第五種 懶漢式 使用double-check（雙重檢查機制）
     *
     * 延遲加載，線程安全。 推薦使用
     */
}

⑥

package io.ilss.pattern.singleton;

/**
 * @author : feng
 * @description: SingletonSix
 * @date : 2019-04-12 09:27
 * @version: : 1.0
 */
public class SingletonSix {
    private static class Singleton {
        private static SingletonSix INSTANCE = new SingletonSix();
    }

    public static SingletonSix getInstance() {
        return Singleton.INSTANCE;
    }
    /**
     * 第六種 靜態內部類
     *
     * 採用類裝載的機制來保證初始化實例時只有一個線程。
     * 靜態內部類方式在Singleton類被裝載時並不會立即實例化，
     * 而是在需要實例化時，調用getInstance方法，纔會裝載Singleton類，
     * 從而完成SingletonSix的實例化。
     */
}

⑦

package io.ilss.pattern.singleton;

/**
 * @author : feng
 * @description: SingletonSeven
 * @date : 2019-04-12 09:31
 * @version: : 1.0
 */
public class SingletonSeven {
    public String string = "test";
    // 內部枚舉類
    private enum EnumSingleton{
        // 規範要求必須有註釋。。請忽略這個註釋，好吧 既然你看完了，那就再看兩眼？
        Singleton;
        private SingletonSeven instance;

        // 枚舉類的構造方法在類加載時被實例化
        EnumSingleton(){
            instance = new SingletonSeven();
        }
        private SingletonSeven getInstance(){
            return instance;
        }
    }
    public static SingletonSeven getInstance() {
        return EnumSingleton.Singleton.getInstance();
    }


    /**
     * 第七種：通過內部枚舉類實現
     *
     * Java保證了所有枚舉的構造方法只會被執行一次，所以無論多少線程調用，都只會產生一個實例。
     */
}

2. 原型模式

a). 定義

原型模式就是用原型實例指定創建對象的種類，並且通過複製這些原型創建新的對象。

淺拷貝：使用一個已知實例對新創建實例的成員變量逐個賦值，這個方式被稱爲淺拷貝。

深拷貝：當一個類的拷貝構造方法，不僅要複製對象的所有非引用成員變量值，還要爲引用類型的成員變量創建新的實例，並且初始化爲形式參數實例值。

關於淺拷貝和深拷貝可以看 http://www.cnblogs.com/chenssy/p/3308489.html

b). 實現

①

package io.ilss.pattern.prototype;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: SomeObject
 * @date : 2019-04-12 14:11
 * @version: : 1.0
 */
@Getter
@Setter
@Slf4j
public class SomeObject implements Cloneable {
    private int flag = 1;
    private String msg = "hello world!";

    /**
     * Java中的Object類提供了淺克隆的clone()方法，
     * 具體原型類只要實現 Cloneable 接口就可實現對象的淺克隆
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        SomeObject object1 = new SomeObject();
        SomeObject object2 = (SomeObject) object1.clone();
        SomeObject object3 = (SomeObject) object1.clone();
        object3.setFlag(2);
        log.debug(" object 1 : {} , hashCode() : {} , toString() : {} ", object1, object1.hashCode(), object1.getMsg() + " " + object1.getFlag());
        log.debug(" object 2 : {} , hashCode() : {} , toString() : {} ", object2, object2.hashCode(), object2.getMsg() + " " + object2.getFlag());
        log.debug(" object 3 : {} , hashCode() : {} , toString() : {} ", object3, object3.hashCode(), object3.getMsg() + " " + object3.getFlag());

    }
}

②用帶原型管理器的原型模式來生成包含“圓”和“正方形”等圖形的原型

package io.ilss.pattern.prototype;

/**
 * @author : feng
 * @description: Shape
 * @date : 2019-04-12 14:42
 * @version: : 1.0
 */
interface Shape extends Cloneable {
    /**
     * 拷貝
     * @return Object
     */
    Object clone();

    /**
     * 計算面積
     * @return area
     */
    double computeArea();

}

package io.ilss.pattern.prototype;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

import java.util.Scanner;

/**
 * @author : feng
 * @description: Circle
 * @date : 2019-04-12 14:44
 * @version: : 1.0
 */

@Getter
@Setter
@Slf4j
public class Circle implements Shape {
    double radius = 1.0;
    @Override
    public Object clone() {
        Circle circle = null;
        try {
            circle = (Circle) super.clone();
        } catch (CloneNotSupportedException e) {
            log.error("Clone Circle class failed!");
        }
        return circle;
    }

    @Override
    public double computeArea() {
        return Math.PI * radius * radius;
    }
}

package io.ilss.pattern.prototype;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: Square
 * @date : 2019-04-12 14:48
 * @version: : 1.0
 */
@Getter
@Setter
@Slf4j
class Square implements Shape {
    private double length = 1.0;
    @Override
    public Object clone() {
        Square square = null;
        try {
            square = (Square) super.clone();
        } catch (CloneNotSupportedException e) {
            log.error("Clone Square class failed!");
        }
        return square;
    }

    @Override
    public double computeArea() {
        return length * length;
    }

}

package io.ilss.pattern.prototype;

import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;

import java.util.*;

/**
 * @author : feng
 * @description: PrototypeManager
 * @date : 2019-04-12 14:42
 * @version: : 1.0
 */
@Slf4j
class PrototypeManager {
    private Map<String, Shape> map = Maps.newHashMap();

    public PrototypeManager() {
        map.put("Circle", new Circle());
        map.put("Square", new Square());
    }

    public void addshape(String key, Shape obj) {
        map.put(key, obj);
    }

    public Shape getShape(String key) {
        Shape temp = map.get(key);
        return (Shape) temp.clone();
    }

    public static void main(String[] args) {
        PrototypeManager manager = new PrototypeManager();
        Shape object1 = manager.getShape("Circle");
        log.debug(" {} ", object1.computeArea());

        Shape object2 = manager.getShape("Square");
        log.debug(" {} ", object2.computeArea());

        Circle circle = (Circle) manager.getShape("Circle");
        circle.setRadius(2.2);
        Shape object3 = circle;
        log.debug(" {} ", object3.computeArea());

    }
}

3. 工廠方法模式

a). 定義

工廠方法模式是簡單工廠模式的衍生，解決了許多簡單工廠模式的問題。首先完全實現‘開－閉原則’，實現了可擴展。其次更復雜的層次結構，可以應用於產品結果複雜的場合。

簡單工廠模式是屬於創建型模式。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。
簡單工廠模式是工廠模式中最簡單實用的模式，可以理解爲是不同工廠模式的一個特殊實現。
簡單工廠模式又稱靜態工廠方法模式。它存在的目的很簡單：定義一個用於創建對象的接口。

工廠方法模式中考慮的是一類產品的生產，如畜牧場只養動物、電視機廠只生產電視機、計算機軟件學院只培養計算機軟件專業的學生

工廠方法模式的主要角色如下。

抽象工廠（Abstract Factory）：提供了創建產品的接口，調用者通過它訪問具體工廠的工廠方法 newProduct() 來創建產品。
具體工廠（ConcreteFactory）：主要是實現抽象工廠中的抽象方法，完成具體產品的創建。
抽象產品（Product）：定義了產品的規範，描述了產品的主要特性和功能。
具體產品（ConcreteProduct）：實現了抽象產品角色所定義的接口，由具體工廠來創建，它同具體工廠之間一一對應。

b). 實現

Product

package io.ilss.pattern.factorymethod;

/**
 * @author : feng
 * @description: Product 抽象產品
 * @date : 2019-04-12 16:10
 * @version: : 1.0
 */
interface Product {
    public void show();
}
ConcreteProduct

package io.ilss.pattern.factorymethod;

import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: ConcreteProductOne 產品1
 * @date : 2019-04-12 16:11
 * @version: : 1.0
 */
@Slf4j
class ConcreteProductOne implements Product {
    private String name = "One";
    @Override
    public void show() {
        log.info("Product {} show()", name);
    }
}

package io.ilss.pattern.factorymethod;

import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: ConcreteProductOne 產品2
 * @date : 2019-04-12 16:11
 * @version: : 1.0
 */
@Slf4j
class ConcreteProductTwo implements Product {
    private String name = "Two";
    @Override
    public void show() {
        log.info("Product {} show()", name);
    }
}

AbstractFactory

package io.ilss.pattern.factorymethod;

/**
 * @author : feng
 * @description: ProductAbstractFactory 抽象工廠
 * @date : 2019-04-12 16:13
 * @version: : 1.0
 */
public interface ProductAbstractFactory {

    /**
     * 生產產品
     * @return Product
     */
    Product newProduct();

}

ConcreteFactory

package io.ilss.pattern.factorymethod;

/**
 * @author : feng
 * @description: ProductConcreteOneFactory 具體工廠1
 * @date : 2019-04-12 16:15
 * @version: : 1.0
 */
public class ProductConcreteOneFactory implements ProductAbstractFactory {

    @Override
    public Product newProduct() {
        return new ConcreteProductOne();
    }
}

package io.ilss.pattern.factorymethod;

/**
 * @author : feng
 * @description: ProductConcreteTwoFactory 具體工廠2
 * @date : 2019-04-12 16:16
 * @version: : 1.0
 */
public class ProductConcreteTwoFactory implements ProductAbstractFactory {
    @Override
    public Product newProduct() {
        return new ConcreteProductTwo();
    }
}

4. 抽象工廠模式

a). 定義

抽象工廠模式是所有形態的工廠模式中最爲抽象和最具一般性的一種形態。抽象工廠模式是指當有多個抽象角色時，使用的一種工廠模式。抽象工廠模式可以向客戶端提供一個接口，使客戶端在不必指定產品的具體的情況下，創建多個產品族中的產品對象。根據里氏替換原則，任何接受父類型的地方，都應當能夠接受子類型。因此，實際上系統所需要的，僅僅是類型與這些抽象產品角色相同的一些實例，而不是這些抽象產品的實例。換言之，也就是這些抽象產品的具體子類的實例。工廠類負責創建抽象產品的具體子類的實例。

里氏替換原則：

里氏替換原則(Liskov Substitution Principle LSP)面向對象設計的基本原則之一。里氏替換原則中說，任何基類可以出現的地方，子類一定可以出現。 LSP是繼承複用的基石，只有當衍生類可以替換掉基類，軟件單位的功能不受到影響時，基類才能真正被複用，而衍生類也能夠在基類的基礎上增加新的行爲。

如此，問題產生了：“我們如何去度量繼承關係的質量？”

Liskov於1987年提出了一個關於繼承的原則** “Inheritance should ensure that any property proved about supertype objects also holds for subtype objects.”——“繼承必須確保超類所擁有的性質在子類中仍然成立。” **也就是說，當一個子類的實例應該能夠替換任何其超類的實例時，它們之間才具有is-A關係。

該原則稱爲Liskov Substitution Principle——里氏替換原則。

抽象工廠是一種爲訪問類提供一個創建一組相關或相互依賴對象的接口，且訪問類無須指定所要產品的具體類就能得到同族的不同等級的產品的模式結構。
抽象工廠模式是工廠方法模式的升級版本，工廠方法模式只生產一個等級的產品，而抽象工廠模式可生產多個等級的產品。

b). 實現

package io.ilss.pattern.abstractfactory;

/**
 * @author : feng
 * @description: ProductOne 抽象產品 1
 * @date : 2019-04-12 16:10
 * @version: : 1.0
 */
interface ProductOne {
    public void show();
}


package io.ilss.pattern.abstractfactory;

/**
 * @author : feng
 * @description: ProductOne 抽象產品 2
 * @date : 2019-04-12 16:10
 * @version: : 1.0
 */
interface ProductTwo {
    public void show();
}

package io.ilss.pattern.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: ConcreteProductOneOne 產品1 廠商1
 * @date : 2019-04-12 16:46
 * @version: : 1.0
 */
@Slf4j
public class ConcreteProductOneOne implements ProductOne {
    private String name = "OneOne";
    @Override
    public void show() {
        log.info("Product {} show()", name);
    }
}

package io.ilss.pattern.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: ConcreteProductOneTwo 產品1 廠商2
 * @date : 2019-04-12 16:46
 * @version: : 1.0
 */
@Slf4j
public class ConcreteProductOneTwo implements ProductOne {
    private String name = "OneTwo";
    @Override
    public void show() {
        log.info("Product {} show()", name);

    }
}

package io.ilss.pattern.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: ConcreteProductTwoOne 產品2 廠商1
 * @date : 2019-04-12 16:46
 * @version: : 1.0
 */
@Slf4j
public class ConcreteProductTwoOne implements ProductTwo {
    private String name = "TwoOne";
    @Override
    public void show() {
        log.info("Product {} show()", name);

    }
}

package io.ilss.pattern.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * @author : feng
 * @description: ConcreteProductTwoTwo 產品2 廠商2
 * @date : 2019-04-12 16:46
 * @version: : 1.0
 */
@Slf4j
public class ConcreteProductTwoTwo implements ProductTwo {
    private String name = "TwoTwo";
    @Override
    public void show() {
        log.info("Product {} show()", name);

    }
}

package io.ilss.pattern.abstractfactory;

/**
 * @author : feng
 * @description: AbstractFactory 抽象工廠
 * @date : 2019-04-12 16:43
 * @version: : 1.0
 */
interface AbstractFactory
{
    public ProductOne newProductOne();
    public ProductTwo newProductTwo();
}

package io.ilss.pattern.abstractfactory;

/**
 * @author : feng
 * @description: ProductConcreteOneFactory 工廠1
 * @date : 2019-04-12 16:44
 * @version: : 1.0
 */
public class ProductConcreteOneFactory {
    public ProductOne newProductOne() {
        return new ConcreteProductOneOne();
    }

    public ProductTwo newProductTwo() {
        return new ConcreteProductTwoOne();
    }
}

package io.ilss.pattern.abstractfactory;

/**
 * @author : feng
 * @description: ProductConcreteTwoFactory 工廠2
 * @date : 2019-04-12 16:44
 * @version: : 1.0
 */
public class ProductConcreteTwoFactory {
    public ProductOne newProductOne() {
        return new ConcreteProductOneTwo();
    }

    public ProductTwo newProductTwo() {
        return new ConcreteProductTwoTwo();
    }
}

參考文章

【設計模式①】單例、原型、工廠方法、抽象工廠模式

環境

1. 單例模式

a). 定義：

b). 實現

2. 原型模式

a). 定義

b). 實現

3. 工廠方法模式

a). 定義

b). 實現

4. 抽象工廠模式

a). 定義

b). 實現

Spring Cloud—EureKa服務的註冊與發現基本概念和實現

【設計模式②】建造者、代理、適配器、橋接模式

【設計模式①】單例、原型、工廠方法、抽象工廠模式

數據庫—索引面試常見問題

BUG-RocketMQ之sendDefaultImpl call timeout 和 No route info of this topic

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結