设计模式之建造者模式解析

18-05-31 来源：[db:作者]

收藏我要投稿

现在有一个大合同，把奔驰、宝马的车辆模型都制作，有额外添加一个需求：汽车的启动、停止、喇叭声音、引擎声音都有客户自己的控制，他想什么顺序就什么顺序。
首先我们得思考了，奔驰宝马都是一个产品，他们有共有的属性。由我生产N多个奔驰和宝马车辆模型，这些车辆模型都有run方法，但具体到每一个模型的run方法可能中间的执行任务的顺序是不同的，客户需要啥顺序，我就给啥顺序，最终用户买走的只能是既定的模型。我们继续，我们先把我们最基本的Product在类中表明出来：
这里写图片描述
我们定义一个CarModel的抽象类，其中run和setSequence是由抽象类实现的，其他都是子类自己实现，那这个是否可以解决这个问题呢？应该可以，我们把代码实现出来，先看CarModel.java程序:

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 定义一个车辆模型的抽象类，所有的车辆模型都继承这个类
 */

public abstract class CarModel {
 //这个参数是各个基本方法执行的顺序
 private ArrayList 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  sequence){
  this.sequence = sequence;
 }

}

其中setSequence方法允许客户自己设置一个顺序，是要先跑起来在有引擎声音还是现有引擎声音再跑起来，还是说那个喇叭就不要响，对于一个具体的模型永远都固定的，那这个事由客户告诉我们，有1W件是这样的，1W件是那样的顺序，目前的设计能满足这个要求
run方法使用了一个数组的遍历，确定哪个是先执行，不多说了，我们继续看两个实现类，先看BenzModel.java程序：

package com.example.xpeng.myapplication;

import android.util.Log;

/**
 * Created by xpeng on 2018/5/31.
 */

public class BenModel extends CarModel {

 @Override
 protected void alarm() {
  Log.e("xyz","奔驰车的喇叭声音是这个样子的...");
 }

 @Override
 protected void start() {
  Log.e("xyz","奔驰车跑起来这个样子的...");
 }

 @Override
 protected void stop() {
  Log.e("xyz","奔驰车应该这样停车的...");
 }

 @Override
 protected void engineBoom() {
  Log.e("xyz","奔驰车的引擎是这个声音的...");
 }
}

没啥特别的，再看BMWModel.java程序:

package com.example.xpeng.myapplication;

import android.util.Log;

/**
 * Created by xpeng on 2018/5/31.
 */

public class BMWModel extends CarModel {

 @Override
 protected void alarm() {
  Log.e("xyz","宝马车的喇叭声音是这个样子的...");
 }

 @Override
 protected void start() {
  Log.e("xyz","宝马车跑起来这个样子的...");
 }

 @Override
 protected void stop() {
  Log.e("xyz","宝马车应该这样停车的...");
 }

 @Override
 protected void engineBoom() {
  Log.e("xyz","宝马车的引擎是这个声音的...");
 }
}

两个实现类都完成，我们再来看客户的要求，我先要1W个奔驰的模型，这个模型的要求是跑的时候，现发动引擎，然后再挂挡启动，然后停下来,不需要喇叭，那怎么实现呢:

  BenzModel benz = new BenzModel();
 ArrayList sequence = new ArrayList();
  sequence.add("engine boom");
  sequence.add("start");
  sequence.add("stop");
  benz.setSequence(sequence);
  benz.run();

看，满足了客户的需求了，满足完了，还要下一个需求啊，然后第2件宝马模型，只要启动和停止，其他什么都不要，第三件模型，现喇叭，第四件模型。。。知道逼疯为止，那怎么办？
我们修改程序，满足这种变态需求，好，先看修改的类图：
这里写图片描述
增加了一个CarBuilder的抽象类，以及两个实现类，其目的是你要什么排列顺序的车，我就给你什么顺序的车，那我们先看CarBuilder.java抽象类的程序：

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 要什么顺序的车，你说，我给建造出来
 */

public abstract class CarBuilder {

 //建造一个模型，你要给我一个顺序，就是组装顺序
 public abstract void setSequence(ArrayList sequence);

 //设置完毕顺序后，就可以直接拿到这个车辆模型
 public abstract CarModel getCarModel();

}

这个抽象类比较简单，程序上也有注释，不多说，我们看两个实现类，先看BenzBuilder.java的程序代码：

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 各种设置都给了，我们按照一定的顺序制造一个奔驰车
 */

public class BenzBuilder extends CarBuilder {
 private BenModel banz = new BenModel();

 @Override
 public void setSequence(ArrayList sequence) {
  this.banz.setSequence(sequence);
 }

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

下面是BMWBuilder.java程序代码：

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 各种设置都给了，我们按照一定的顺序制造一个奔驰车
 */

public class BMWBuilder extends CarBuilder {
 private BMWModel bmw = new BMWModel();

 @Override
 public void setSequence(ArrayList sequence) {
  this.bmw.setSequence(sequence);
 }

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

程序简单实用，看我们怎么调用：

  ArrayList sequence = new ArrayList();

  sequence.add("engine boom");
  sequence.add("start");
  sequence.add("stop");

  //要一个奔驰车
  BenzBuilder benzBuilder = new BenzBuilder();
  //把顺序给这个builder类，制造出这样一个车出来
  benzBuilder.setSequence(sequence);
  //制造出一个奔驰车
  BenModel benz = (BenModel) benzBuilder.getCarModel();
  //奔驰车跑一下看看
  benz.run();

  //按照同样的顺序，我再要一个宝马车
  BMWBuilder bmwBuilder = new BMWBuilder();
  benzBuilder.setSequence(sequence);
  BenModel bmw = (BenModel) bmwBuilder.getCarModel();
  bmw.run();

看，是不是比刚才直接访问产品类（procut）简单了很多把，那还有个这样的需求，这四个过程(start,stop,alarm,engineBoom)按照排列组合有很多种，那我们怎么满足这种需求呢？就是要有个类来安排这几个方法组合，我们这个叫导演类，先看一下类图：
这里写图片描述
增加了Director类，这个类是做了层封装，类中的方法说明如下：
A型号的奔驰车辆模型是只有启动（start）、停止(stop)方法，其他的引擎声音、喇叭都没有；
B型号车的奔驰是现发动引擎。。
C型号的宝马车是先叫一下喇叭（alarm）…
D型号宝马车是先一个启动(start)。。。
后面的E型号、F型号随意组合

我们来看一下代码实现，Director.java代码如下:

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 导演安排顺序，生产车辆模型
 */

public class Director {
 private ArrayList sequence = new ArrayList<>();

 private BenzBuilder benzBuilder = new BenzBuilder();

 private BMWBuilder bmwBuilder = new BMWBuilder();

 /**
  * A类型的奔驰车模型，先start，然后stop，其他什么引擎了，喇叭一概没有
  */
 public BenModel getABenzModel(){
  //清理场景
  this.sequence.clear();
  //这只ABenzModel的执行顺序
  this.sequence.add("start");
  this.sequence.add("stop");
  //按照顺序返回一个奔驰车
  this.benzBuilder.setSequence(this.sequence);
  return (BenModel) this.benzBuilder.getCarModel();
 }

 /**
  * B类型的奔驰车模型
  */
 public BenModel getBBenzModel(){
  //清理场景
  this.sequence.clear();
  //这只ABenzModel的执行顺序
  this.sequence.add("alarm");
  this.sequence.add("start");
  this.sequence.add("stop");
  //按照顺序返回一个奔驰车
  this.benzBuilder.setSequence(this.sequence);
  return (BenModel) this.benzBuilder.getCarModel();
 }


 /**
  * C类型的宝马车模型
  */
 public BMWModel getCBWMModel(){
  //清理场景
  this.sequence.clear();
  //这只ABenzModel的执行顺序
  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 getDBWMModel(){
  //清理场景
  this.sequence.clear();
  //这只ABenzModel的执行顺序
  this.sequence.add("start");
  //按照顺序返回一个奔驰车
  this.bmwBuilder.setSequence(this.sequence);
  return (BMWModel) this.bmwBuilder.getCarModel();
 }

}

大家看到程序中有很多this调用，如果你要调用类中的成员变量或方法，需要在前面加上this关键字，，加上this关键字，我就是要调用本类中成员变量或方法，而不是本方法中的一个变量，还有super方法也是一样，是调用父类的成员变量或者方法，那就要加上这个关键字，不要省略。

最终调用方法：

Director director = new Director();

  for (int i = 0; i <3 ; i++) {
director.getABenzModel().run();
  }

  for (int i = 0; i <5 ; i++) {
director.getBBenzModel().run();
  }

  for (int i = 0; i <1 ; i++) {
director.getCBWMModel().run();
  }

整个程序编写完了，这就是建造者模式，中间有几个角色需要说明一下：
CarModel以及两个实现类BenzModel和BMWModel叫做产品类（product Class），这个产品类实现了模版方法模式，也就是有模版方法和基本方法，这个参考模版方法模式；
CarBuilder以及两个实现类BenzBuilder和BMWBuilder叫做建造者（Builder Class），在上面的那个例子中就是我，负责建造Benz和BMW车模，按照指定的顺序：
Director类叫做导演类（Director Class），负责安排已有模块的顺序，然后告诉Builder开始建造
大家看到这里是不是觉得这个建造者模式跟工厂模式非常相似，是的，是非常相似，但是记住一点你就可以游刃有余的使用了：建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了；而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序不是它关心的。

点击复制链接与好友分享!回本站首页