設計模式之簡單工廠模式

簡單工廠模式：
簡單工廠模式(Simple Factory Pattern)：又稱爲靜態工廠方法(Static Factory Method)模式，它屬於類創建型模式（同屬於創建型模式的還有工廠方法模式，抽象工廠模式，單例模式，建造者模式）。在簡單工廠模式中，可以根據參數的不同返回不同類的實例。簡單工廠模式專門定義一個類來負責創建其他類的實例，被創建的實例通常都具有共同的父類。

簡單工廠模式由三部分組成：具體工廠、具體產品和抽象產品。

工廠類（Creator）角色：擔任這個角色的是簡單工廠模式的核心，含有與應用緊密相關的商業邏輯。工廠類在客戶端的直接調用下創建產品對象，它往往由一個具體Java類實現。

抽象產品（AbstractProduct）角色：擔任這個角色的類是由簡單工廠模式所創建的對象的父類，或它們共同擁有的接口。抽象產品角色可以用一個Java接口或者Java抽象類實現。

具體產品（ConcreteProduct）角色：簡單工廠模式所創建的任何對象都是這個角色的實例，具體產品角色由一個具體Java類實現

模式優點
工廠類含有必要的判斷邏輯，可以決定在什麼時候創建哪一個產品類的實例，客戶端可以免除直接創建產品對象的責任，而僅僅“消費”產品；簡單工廠模式通過這種做法實現了對責任的分割，它提供了專門的工廠類用於創建對象。
客戶端無須知道所創建的具體產品類的類名，只需要知道具體產品類所對應的參數即可，對於一些複雜的類名，通過簡單工廠模式可以減少使用者的記憶量。
通過引入配置文件，可以在不修改任何客戶端代碼的情況下更換和增加新的具體產品類，在一定程度上提高了系統的靈活性。
當需要引入新的產品是不需要修改客戶端的代碼，只需要添加相應的產品類並修改工廠類就可以了，所以說從產品的角度上簡單工廠模式是符合“開-閉”原則的。
模式缺點
由於工廠類集中了所有產品創建邏輯，工廠類一般被我們稱作“全能類”或者“上帝類”，因爲所有的產品創建他都能完成，這看似是好事，但仔細想想是有問題的。比如全國上下所有的事情都有國家主義一個人幹會不會有問題，當然有！一旦不能正常工作，整個系統都要受到影響。
使用簡單工廠模式將會增加系統中類的個數，在一定程序上增加了系統的複雜度和理解難度。
系統擴展困難，一旦添加新產品就不得不修改工廠邏輯，在產品類型較多時，有可能造成工廠邏輯過於複雜，不利於系統的擴展和維護。所以說從工廠的角度來說簡單工廠模式是不符合“開-閉”原則的。
簡單工廠模式由於使用了靜態工廠方法，造成工廠角色無法形成基於繼承的等級結構。

簡單工廠模式 + 模板方法模式

public interface DataOperation<K, V> {

    /**
     * 類的描述
     * @return
     */
    String getClassDescription();

    /**
     * 插入數據
     * @param k
     * @param v
     */
    void insertData(K k,V v);

    /**
     * 根據value查找key
     * @param v
     * @return
     */
    K findKey(V v);

    /**
     * 根據value查找key
     * @param k
     * @return
     */
    V findValue(K k);

    /**
     * 刪除key
     * @param k
     */
    void deleteKey(K k);

}

public abstract class AbstractDataOperation<K,V> implements DataOperation<K,V>,Serializable{

    /**
     * 類的描述
     * @return
     */
    @Override
    public String getClassDescription(){
        return this.getClass().getName();
    }

    /**
     * 插入數據
     * @param k
     * @param v
     */
    @Override
    public void insertData(K k,V v){
        init();
        insertDataChild(k,v);
    }

    /**
     * 根據value查找key
     * @param v
     * @return
     */
    @Override
    public K findKey(V v){
        init();
        return findKeyChild(v);
    }

    /**
     * 根據value查找key
     * @param k
     * @return
     */
    @Override
    public V findValue(K k){
        init();
        return findValueChild(k);
    }

    /**
     * 刪除key
     * @param k
     */
    @Override
    public void deleteKey(K k){
        init();
        deleteKeyChild(k);
    }

    private void init(){
        System.out.println("SuperHakce\n");
    }

    public abstract void insertDataChild(K k,V v);

    public abstract K findKeyChild(V v);

    public abstract V findValueChild(K k);

    public abstract void deleteKeyChild(K k);

}

@Transactional
@SuppressWarnings("uncheck")
public class RedisOperation<K,V> extends AbstractDataOperation<K,V> implements Serializable{
    /**
     * 插入數據
     * @param k
     * @param v
     */
    public void insertDataChild(K k,V v){
    }

    /**
     * 根據value查找key
     * @param v
     * @return
     */
    public K findKeyChild(V v){
        return null;
    }

    /**
     * 根據value查找key
     * @param k
     * @return
     */
    public V findValueChild(K k){
        return null;
    }

    /**
     * 刪除key
     * @param k
     */
    public void deleteKeyChild(K k){

    }
}

@Component
public class DataOperationFactory<K,V>{
    public static final String REDIS = "Redis";
    public static final String MONGODB = "MongoDB";
    public final DataOperation<K,V> getDataOperation(String dataType){
        switch (dataType){
            case REDIS: {
                return new RedisOperation<K,V>();
            }
            case MONGODB: {
                return new RedisOperation<K,V>();
            }
            default:{
                return new RedisOperation<K,V>();
            }
        }
    }
}