建造者模式

建造者模式的定义

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

通用类图如下：

建造者通用类图.png

角色说明

• Product产品类

  通常是实现了模板方法模式，也就是有模板方法和基本方法

• Builder抽象建造者

  规范产品的组件，一般由子类实现。

• ConcreteBuilder具体建造者

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

• Director导演类

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

通用代码

产品类

public class Product {
     public void doSomething(){
             //独立业务处理
     }
}

抽象建造者

public abstract class Builder {
     //设置产品的不同部分，以获得不同的产品
     public abstract void setPart();
     //建造产品
     public abstract Product buildProduct();
}

具体建造者

public class ConcreteProductBuilder extends Builder {
     private Product product = new Product();
     //设置产品零件
     public void setPart(){
             /*
              * 产品类内的逻辑处理
              */
     }
     //组建一个产品
     public Product buildProduct() {
             return product;
     }
}

需要注意的是，如果有多个产品类就有几个具体的建造者，而且这些产品类具有相同的接口或抽象类。

导演类

public class Director {
     private Builder builder = new ConcreteProductBuilder();
     //构建不同的产品
     public Product getAProduct(){
             builder.setPart();
             /*
              * 设置不同的零件，产生不同的产品
              */
             return builder.buildProduct();
     }
}

导演类起到封装作用，避免高层模块深入到建造者内部的实现类。当然，在建造者模式比较庞大的时候，导演类也可以有多个。

示例

不同厂家的生产的汽车，它的动作执行顺序要求不一样，例如：第一个公司的车只要启动和停止功能，其他的什么都不要；第二个公司要求汽车启动时，要先鸣喇叭，然后启动，然后停止。。。

针对上面的情况，我们可以为每家公司的车定义一个建造者，你要功能顺序直接告诉建造者，由建造者来建造

类图如下：

汽车构造类图.png

CarModel类

public abstract class CarModel {
     //这个参数是各个基本方法执行的顺序
     private ArrayList<String> sequence = new ArrayList<String>();
     //模型是启动开始跑了
     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(actionName.equalsIgnoreCase("start")){
                              this.start();  //启动汽车
                      }else if(actionName.equalsIgnoreCase("stop")){
                              this.stop(); //停止汽车
                      }else if(actionName.equalsIgnoreCase("alarm")){
                              this.alarm(); //喇叭开始叫了
                       }else if(actionName.equalsIgnoreCase("engine boom")){
                                                            //如果是engine boom关键字
                              this.engineBoom();  //引擎开始轰鸣
                       }
             }
     }
     //把传递过来的值传递到类内
     final public void setSequence(ArrayList sequence){
             this.sequence = sequence;
     }
}

奔驰和宝马的模型

public class BenzModel extends CarModel {
     protected void alarm() {
             System.out.println("奔驰车的喇叭声音是这个样子的...");
     }
     protected void engineBoom() {
             System.out.println("奔驰车的引擎是这个声音的...");
     }
     protected void start() {
             System.out.println("奔驰车跑起来是这个样子的...");
     }
     protected void stop() {
             System.out.println("奔驰车应该这样停车...");
     }
}

public class BMWModel extends CarModel {
     protected void alarm() {
             System.out.println("宝马车的喇叭声音是这个样子的...");
     }
     protected void engineBoom() {
             System.out.println("宝马车的引擎是这个声音的...");
     }
     protected void start() {
             System.out.println("宝马车跑起来是这个样子的...");
     }
     protected void stop() {
             System.out.println("宝马车应该这样停车...");
     }
}

汽车抽象构造者

public abstract class CarBuilder {
     //建造一个模型，你要给我一个顺序要求，就是组装顺序
     public abstract void setSequence(ArrayList<String> sequence);
     //设置完毕顺序后，就可以直接拿到这个车辆模型
     public abstract CarModel getCarModel();
}

奔驰车的组装者

public class BenzBuilder extends CarBuilder {
     private BenzModel benz = new BenzModel();
     public CarModel getCarModel() {
             return this.benz;
     }
     public void setSequence(ArrayList<String> sequence) {
             this.benz.setSequence(sequence);
     }
}

宝马车的组装者与上面类似

导演者类

public class Director {
     private ArrayList<String> sequence = new ArrayList();
     private BenzBuilder benzBuilder = new BenzBuilder();
     private BMWBuilder bmwBuilder = new BMWBuilder();
     /*
      * A类型的奔驰车模型，先start，然后stop，其他什么引擎、喇叭一概没有
      */
     public BenzModel getABenzModel(){
             //清理场景
             this.sequence.clear();
             //ABenzModel的执行顺序
             this.sequence.add("start");
             this.sequence.add("stop");
             //按照顺序返回一个奔驰车
             this.benzBuilder.setSequence(this.sequence);
             return (BenzModel)this.benzBuilder.getCarModel();
     }
     /*
      * B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭
      */
     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();
     }
     /*
      * C型号的宝马车是先按下喇叭（炫耀嘛），然后启动，然后停止
      */
     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.bmwBuilder.getCarModel();
     }
     /*
      * D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止
      */
     public BMWModel getDBMWModel(){
             this.sequence.clear();
             this.sequence.add("start");
             this.bmwBuilder.setSequence(this.sequence);
             return (BMWModel)this.benzBuilder.getCarModel();
     }
     /*
      * 这里还可以有很多方法，你可以先停止，然后再启动，或者一直停着不动，静态的嘛
      * 导演类嘛，按照什么顺序是导演说了算
      */
}

this.sequence.clear()的作用是防止数据混乱，提前清空一下List。

具体场景类

public class Client {
     public static void main(String[] args) {
             Director director = new Director();
             //1万辆A类型的奔驰车
             for(int i=0;i<10000;i++){
                     director.getABenzModel().run();
             }
             //100万辆B类型的奔驰车
             for(int i=0;i<1000000;i++){
                     director.getBBenzModel().run();
             }
             //1000万辆C类型的宝马车
             for(int i=0;i<10000000;i++){
                     director.getCBMWModel().run();
             }
     }
}

建造者模式的应用

优点

• 封装性

  使用建造者可以使客户端不必知道产品内部组成的细节。

• 建造者独立，容易扩展

  各Builder间相互独立，对系统的扩展非常有利。

• 便于控制细节风险

  由于具体的建造者是独立的，因此可以对建造者过程逐步细化，而不对其他的模块产生任何影响。

使用场景

相同的方法，不同的执行顺序，产生不同的时间结果时，可以采用建造者模式。

多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同，则可以使用该模式。

产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。

在对象创建过程中使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该中场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。

注意事项

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