设计模式之禅-建造者模式

建造者模式

例子

public abstract class CarModel {
    /**执行顺序*/
    private ArrayList<String> sequence = new ArrayList<>();
    /** 启动*/
    protected abstract void start();
    /**停车*/
    protected abstract void stop();
    /**鸣笛*/
    protected abstract void alarm();
    /**引擎声*/
    protected abstract void engineBoom();
    /**跑*/
    final public void run(){
        for (int i = 0; i < this.sequence.size(); i++) {
            String actionName = this.sequence.get(i);
            if ("start".equalsIgnoreCase(actionName)){
                this.start();
            }else if("stop".equalsIgnoreCase(actionName)){
                this.stop();
            }else if("alarm".equalsIgnoreCase(actionName)){
                this.alarm();
            }else if("engine boom".equalsIgnoreCase(actionName)){
                this.engineBoom();
            }
        }
    }
    final public void setSequence(ArrayList sequence){
        this.sequence = sequence;
    }

}

/**
 * 抽象汽车组装类
 * @author gcl
 * @date 2020-10-13 11:50
 */
public abstract class CarBuilder {
    public abstract void setSequence(ArrayList<String> sequence);
    public abstract CarModel getCarModel();
}

public class BMWModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("BMW 启动");
    }

    @Override
    protected void stop() {
        System.out.println("BMW 停");
    }

    @Override
    protected void alarm() {
        System.out.println("BMW 喇叭");
    }

    @Override
    protected void engineBoom() {
        System.out.println("BMW 引擎");
    }
}

/**
 * 宝马组装类
 * @author gcl
 * @date 2020-10-13 11:52
 */
public class BMWBuilder extends CarBuilder {
    private BMWModel bmwModel = new BMWModel();
    @Override
    public void setSequence(ArrayList<String> sequence) {
        this.bmwModel.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return this.bmwModel;
    }
}

public class BenzModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("benz 启动");
    }

    @Override
    protected void stop() {
        System.out.println("benz 停");
    }

    @Override
    protected void alarm() {
        System.out.println("benz 喇叭");
    }

    @Override
    protected void engineBoom() {
        System.out.println("benz 引擎");
    }
}

/**
 * 奔驰组装类
 * @author gcl
 * @date 2020-10-13 11:52
 */
public class BenzBuilder extends CarBuilder {
    private BenzModel benzModel = new BenzModel();
    @Override
    public void setSequence(ArrayList<String> sequence) {
        this.benzModel.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return this.benzModel;
    }
}

public class Director {
    private ArrayList<String> sequence = new ArrayList<>();
    private BenzBuilder benzBuilder = new BenzBuilder();
    private BMWBuilder bmwBuilder = new BMWBuilder();
    public BenzModel getABenzModel(){
        // 清理场景
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("stop");
        this.benzBuilder.setSequence(this.sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }
    public BenzModel getBBenzModel(){
        // 清理场景
        this.sequence.clear();
        this.sequence.add("engine boom");
        this.sequence.add("start");
        this.sequence.add("stop");
        this.benzBuilder.setSequence(this.sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }
    public BMWModel getCBMWModel(){
        // 清理场景
        this.sequence.clear();
        this.sequence.add("alarm");
        this.sequence.add("start");
        this.sequence.add("stop");
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel) this.benzBuilder.getCarModel();
    }
    public BMWModel getDBMWModel(){
        // 清理场景
        this.sequence.clear();
        this.sequence.add("start");
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel) this.benzBuilder.getCarModel();
    }
    /*
    还有很多方法
     */
}

public class Client {
    //    public static void main(String[] args) {
//        BenzModel benz = new BenzModel();
//        ArrayList<String> sequence = new ArrayList<>();
//        sequence.add("engine boom");
//        sequence.add("start");
//        sequence.add("stop");
//        benz.setSequence(sequence);
//        benz.run();
//    }
    public static void main(String[] args) {
        Director director = new Director();
        for (int i = 0; i < 10000; i++) {
            director.getABenzModel().run();
        }
        for (int i = 0; i < 1000000; i++) {
            director.getBBenzModel().run();
        }
        for (int i = 0; i < 10000; i++) {
            director.getCBMWModel().run();
        }
        for (int i = 0; i < 10000; i++) {
            director.getDBMWModel().run();
        }
    }
}

定义

将一个复杂对象的构建与它的表示分 离，使得同样的构建过程可以创建不同的表示。

在建造者模式中，有如下4个角色：

• Product产品类
  通常是实现了模板方法模式，也就是有模板方法和基本方法。

public class Product {
    public void doSomething(){
        // 业务代码
    }
}

• Builder抽象建造者
  规范产品的组建，一般是由子类实现。

/**
 * 抽象建造者
 * 其中，setPart方法是零件的配置，什么是零件？其他的对象，获得一个不同零件，或者不同的装配顺序就可能产生不同的产品。
 *
 * @author gcl
 * @date 2020-10-13 14:09
 */
public abstract class Builder {
    /**
     * 设置产品的不同部分，以获得不同的产品
     */
    public abstract void setPart();

    /**
     * 建造产品
     */
    public abstract Product buildProduct();
}

• ConcreteBuilder具体建造者
  实现抽象类定义的所有方法，并且返回一个组建好的对象。

/**
 * 具体建造者
 * 需要注意的是，如果有多个产品类就有几个具体的建造者，而且这多个产品类具有相同接口或抽象类
 *
 * @author gcl
 * @date 2020-10-13 14:10
 */
public class ConcreteProduct extends Builder {
    private Product product = new Product();

    @Override
    public void setPart() {
        // 产品类内的逻辑处理
    }

    @Override
    public Product buildProduct() {
        return product;
    }
}

• Director导演类
  负责安排已有模块的顺序，然后告诉Builder开始建造。

/**
 * 导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。当然，在建造者模式比较庞大时，导演类可以有多个。
 *
 * @author gcl
 * @date 2020-10-13 14:15
 */
public class Director {
    private Builder builder = new ConcreteProduct();

    public Product getAProduct() {
        builder.setPart();
        // 设置不同的零件，产生不同的产品
        return builder.buildProduct();
    }
}

优点

• 封装性
  使用建造者模式可以使客户端不必知道产品内部组成的细节。
• 建造者独立，容易扩展
  不同的Builder是相互独立的，对系统的扩展非常有利。
• 便于控制细节风险
  由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

使用场景

• 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
• 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。
• 在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程 中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建 过程，本身已经违反设计的最初目标。

注意事项

建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大不同的 地方，虽然同为创建类模式，但是注重点不同。