定义

它属于创建型模式的一种，将一个复杂的对象分解成多个简单的对象来进行构建，将复杂的构建层与表示层分离，使得相同的构建过程可以创建不同的表示的模式便是建造者模式

举个栗子

现在有一个建造汽车的工厂，他们主要目的是生成汽车，汽车的标识都是相同的（大众），但是汽车轮子有不同的型号，汽车的发动机也是有不同的功率的

三个组成

  • 抽象建造者

    Car就是抽象建造者,它具备一些车的基本属性还有方法, 它是抽象的,用户不需要知道它的存在,
    那么Tyre(轮胎),Engine(发动机),分别就是车的具体部件(具体类),

  • 指挥者

    创建的BenChi类,其实就是一个指挥者的角色,负责把对应的部件组装起来,

  • 具体建造者

函数的调用者

抽象建造者

  1. // #建造者模式 
  4. // 抽象建造者
  5. var Car = function (param) {
  6.     // 速度
  7.     this.speed = param && param.speed || '0';
  8.     // 重量
  9.     this.weight = param && param.weight || '0';
  10. }
  13. Car.prototype = {
  14.     // 获取速度
  15.     getSpeed: function () {
  16.         return this.speed;
  17.     },
  18.     // 获取重量
  19.     getWeight: function () {
  20.         return this.weight
  21.     }
  22. }
  25. // 轮胎部件类
  26. var Tyre = function (type) {
  27.     var that = this;
  28.     // 构造器
  29.     // 构造函数中通过传入的type类型设置相对应的轮胎尺寸
  30.     (function (type,that) {
  31.         switch (type) {
  32.             case 'small':
  33.             that.tyre = '小号轮胎';
  34.             that.tyreIntro = '正在使用小号轮胎';
  35.             break;
  36.             case 'normal':
  37.             that.tyre = '中号轮胎';
  38.             that.tyreIntro = '正在使用中号轮胎';
  39.             break;
  40.             case 'big':
  41.             that.tyre = '大号轮胎';
  42.             that.tyreIntro = '正在使用大号轮胎';
  43.             break;
  44.         }
  45.     })(type,this);
  46. }
  49. Tyre.prototype = {
  50.     // 更换轮胎的方法
  51.     changeType: function (type) {
  52.         that.tyre = type;
  53.         that.tyreIntro = '正在使用'+type;
  54.     }
  55. }
  58. // 发动机部件类
  59. var Engine = function (type) {
  60.     var that = this;
  61.     // 构造器
  62.     // 构造函数中通过传入的type类型设置相对应的发动机类型
  63.     (function (type,that) {
  64.         switch (type) {
  65.             case 'small':
  66.             that.engine = '小号发动机';
  67.             that.engineIntro = '正在使用小号发动机';
  68.             break;
  69.             case 'normal':
  70.             that.engine = '中号发动机';
  71.             that.engineIntro = '正在使用中号发动机';
  72.             break;
  73.             case 'big':
  74.             that.engine = '大号发动机';
  75.             that.engineIntro = '正在使用大号发动机';
  76.             break;
  77.         }
  78.     })(type,this);
  79. }
  81. Engine.prototype = {
  82.     // 更换发动机的方法
  83.     changeType: function (type) {
  84.         that.engine = type;
  85.         that.engineIntro = '正在使用'+type;
  86.     }
  87. }

指挥者

  1. /**
  2.  * 指挥者,建造一个奔驰车的类
  3.  * @param {*轮胎类型 small normal big} tyre 
  4.  * @param {*发动机类型 small normal big} engine 
  5.  * @param {*车辆基本属性 param.speed:速度 param.weight: 重量} param 
  6.  */
  7. var BenChi = function (tyre,engine,param) {
  8.     // 创建一个车辆缓存对象
  9.     var _car = new Car(param);
  10.     // 创建车辆的轮胎
  11.     _car.tyreInfo = new Tyre(tyre);
  12.     // 创建车辆的发动机
  13.     _car.engineInfo = new Engine(engine);
  14.     // 将创建的车辆对象返回
  15.     return _car;
  16. }

具体建造者

  1. // 具体建造者 实例化奔驰车类
  2. var benchi1 = new BenChi('small','big',{speed: 200,weight: '200'});
  3. console.log(benchi1.speed);// 200
  4. console.log(benchi1.weight);// 200
  5. console.log(benchi1.tyreInfo.tyre);// 小号轮胎
  6. console.log(benchi1.tyreInfo.tyreIntro);// 正在使用小号轮胎
  7. console.log(benchi1.engineInfo.engine);// 大号发动机
  8. console.log(benchi1.engineInfo.engineIntro);// 正在使用大号发动机

总结

优点

  • 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
  • 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。