設計模式之2 工廠方法模式

工廠方法模式

uml類圖

定義

Define an interface for creating an object,but let subclasses decide which class to instance.
Factory Method lets a class defer instantiation to subclasses.

定義一個用於創建對象的接口，讓子類決定實例化哪一個類。工廠方法是一個類的實例化延遲到其子類。

抽象產品類：負責定義產品的共性，實現對事物最抽象的定義
具體產品類：
抽象工廠類：對客戶暴露的入口，負責定義工廠的功能
具體工廠類：

實現

1. 抽象產品類（接口）

Machine.java

/**
 * @author heshiyuan
 * @description <p></p>
 * @path java-design-pattern/com.hsy.java.design.pattern.method
 * @date 2018/1/30 15:58
 * @github http://github.com/shiyuan2he
 * @email [email protected]
 * Copyright (c) 2018 [email protected] All rights reserved.
 * @price ¥5    微信：hewei1109
 */
public interface Machine {
    // 車發動起來
    void start() ;
    // 車加速度
    void speed() ;
    // 車制動
    void stop() ;
}

1. 具體產品類

Car.java

/**
 * @author heshiyuan
 * @description <p></p>
 * @path java-design-pattern/com.hsy.java.design.pattern.method.product
 * @date 2018/1/30 16:03
 * @github http://github.com/shiyuan2he
 * @email [email protected]
 * Copyright (c) 2018 [email protected] All rights reserved.
 * @price ¥5    微信：hewei1109
 */
public class Car implements Machine{
    private final Logger _logger = LoggerFactory.getLogger(this.getClass()) ;
    @Override
    public void start() {
        _logger.info("汽車啓動啦");
    }

    @Override
    public void speed() {
        _logger.info("汽車加速啦");
    }

    public void blow() {
        _logger.info("汽車按鈴啦");
    }

    @Override
    public void stop() {
        _logger.info("汽車停車啦");
    }
}

Truck.java

/**
 * @author heshiyuan
 * @description <p></p>
 * @path java-design-pattern/com.hsy.java.design.pattern.method.product
 * @date 2018/1/30 16:04
 * @github http://github.com/shiyuan2he
 * @email [email protected]
 * Copyright (c) 2018 [email protected] All rights reserved.
 * @price ¥5    微信：hewei1109
 */
public class Truck implements Machine{
    private final Logger _logger = LoggerFactory.getLogger(this.getClass()) ;
    @Override
    public void start() {
        _logger.info("卡車啓動啦");
    }

    @Override
    public void speed() {
        _logger.info("卡車加速啦");
    }

    public void blow() {
        _logger.info("卡車按鈴啦");
    }

    @Override
    public void stop() {
        _logger.info("卡車停車啦");
    }
}

Bike.java

/**
 * @author heshiyuan
 * @description <p></p>
 * @path java-design-pattern/com.hsy.java.design.pattern.method.product
 * @date 2018/1/30 16:04
 * @github http://github.com/shiyuan2he
 * @email [email protected]
 * Copyright (c) 2018 [email protected] All rights reserved.
 * @price ¥5    微信：hewei1109
 */
public class Bike implements Machine{
    private final Logger _logger = LoggerFactory.getLogger(this.getClass()) ;
    @Override
    public void start() {
        _logger.info("自行車啓動啦");
    }

    @Override
    public void speed() {
        _logger.info("自行車加速啦");
    }

    @Override
    public void stop() {
        _logger.info("自行車停車啦");
    }
}

1. 抽象工廠類

Factory.java

/**
 * @author heshiyuan
 * @description <p></p>
 * @path java-design-pattern/com.hsy.java.design.pattern.method
 * @date 2018/1/30 15:57
 * @github http://github.com/shiyuan2he
 * @email [email protected]
 * Copyright (c) 2018 [email protected] All rights reserved.
 * @price ¥5    微信：hewei1109
 */
public abstract class Factory {

    public abstract <T extends Machine> T createMachine(Class<T> c);
}

MachineFactory.java

/**
 * @author heshiyuan
 * @description <p></p>
 * @path java-design-pattern/com.hsy.java.design.pattern.method
 * @date 2018/1/30 16:01
 * @github http://github.com/shiyuan2he
 * @email [email protected]
 * Copyright (c) 2018 [email protected] All rights reserved.
 * @price ¥5    微信：hewei1109
 */
public class MachineFactory extends Factory{
    @Override
    public <T extends Machine> T createMachine(Class<T> c) {
        Machine machine = null ;
        try {
            machine = (Machine) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) machine;
    }
}

1. 測試

/**
 * @author heshiyuan
 * @description <p></p>
 * @path java-design-pattern/com.hsy.java.design.pattern.method.client
 * @date 2018/1/30 16:13
 * @github http://github.com/shiyuan2he
 * @email [email protected]
 * Copyright (c) 2018 [email protected] All rights reserved.
 * @price ¥5    微信：hewei1109
 */
public class ClientTest {
    @Test
    public void createMachine(){
        // 打包給客戶的集裝箱
        List<Machine> list = new ArrayList<>() ;
        /**
         * 實例化一個造車工廠
         */
        Factory factory = new MachineFactory() ;
        /**
         * 1.客戶下訂單，開始造車（2輛汽車，2兩卡車，2兩自行車）
         */
        // 造汽車生產線
        for(int i=0;i<2;i++){
            list.add(factory.createMachine(Car.class));
        }
        // 造卡車生產線
        for(int i=0;i<2;i++){
            list.add(factory.createMachine(Truck.class));
        }
        // 造自行車生產線
        for(int i=0;i<2;i++){
            list.add(factory.createMachine(Bike.class));
        }

        //客戶開始測驗每輛車的性能
        list.forEach(ele -> {
            ele.start() ;
            ele.speed();
            ele.stop();
            if(ele instanceof Car){
                ((Car) ele).blow();
            }
            if(ele instanceof Truck){
                ((Truck) ele).blow();
            }
        });
    }
}

優點

1. 良好的封裝行，代碼結構清晰

2. 工廠方法模式的擴展性非常優秀。

   增加產品類的情況下，只要適當地修改具體的工廠類或擴展一個工廠類，就可以完成“擁抱變化”

3. 屏蔽產品類

   產品類的實現如果變化，調用者不需要關心，它只需要關心產品的接口，只要接口保持不變，系統中的上層模塊就不要發生變化。
   因爲產品中的實例化工作是由工廠類負責的。

4. 工廠方法模式是典型的解耦框架。

   高層模塊需要知道產品的抽象類，其他的實現類都不用關心，符合迪米特法則-我不需要的就不要去交流

   也符合依賴倒置原則-只依賴產品類的抽象；

   也符合里氏替換原則-使用產品子類替換產品父類；

使用場景

1. 工廠方法模式是new一個對象的替代品，所以在所有需要生成對象的地方都可以使用，但是需要慎重的考慮是否要增加一個工廠類進行管理，增加代碼的複雜度;

2. 需要靈活的、可擴展的框架時，可以考慮採用工廠方法模式。

   萬物皆對象，那萬物也就皆產品類，例如需要設計一個連接郵件服務器的框架，有三種網絡協議可供選擇：pop3、imap、http，我們就可以把這三種
   連接方法作爲產品類，定義一個接口，然後定義對郵件的操作方法，用不同的方法實現三個具體的產品類，再定義一個工廠方法，按照不同的傳入條件，
   選擇不同的連接方式。如此設計，可以做到完美的擴展，如果某些郵件服務器提供了WebService接口，我們只要增加一個產品類就可以了。

3. 工廠方法模式可以用在異構項目中。

   例如，通過webservice與一個非Java的項目交互，雖然WebService號稱是可以做到異構系統的同構化，但是在實際的開發中，還是會碰到很多問題，
   如類型問題、wsdl文件的支持問題等。從WSDL中產生的對象都認爲是一個產品，然後由一個具體的工廠類進行管理，減少與外圍系統的耦合。

4. 可以使用在測試驅動開發的框架下。