建造者模式--Builder

　　模拟场景：在上次的模板设计中，我们根据不同的需求建立有不同特性的car，现在一辆car有什么特性都是由我们内部自己决定的，但是现在有新的要求：所有car的特性都由客户自己决定。比如现在要求要建立BMV，但是BMW也有不同的型号，假如型号A要求只需要start和stop方法，型号B要求start、stop、alarm，型号C先start、engineBoom、stop，型号D。。。怎么根据这些不同的需求来建立重用性高的代码？

　　分析：现在既然有不同需求，而且有顺序的要求了，那么就不可以像之前在CarModel中写死了顺序，这样达不到我们的要求。既然有顺序，那么我们可以在CarModel中实例化一个List<String>容器，主要用来装特性执行的顺序，在run方法中循环取出，进行迭代判断，先匹配的先进行执行，不匹配的不执行。

CarModel

package com.zqz.dp.builder;
import java.util.ArrayList;
import java.util.List;
/**
 * @author Qin 生产car的模型，所有的才都按照此模板进行设计
 */
public abstract class CarModel {
         /**
          * 定义一个list<String>容器，用来装car跑动时候是否执行，执行的顺序。
          * 封装好，提供getter、setter
          */
         private List<String> orders=new ArrayList<String>();
         protected List<String> getOrders() {
                   return orders;
         }
         protected void setOrders(List<String> orders) {
                   this.orders = orders;
         }
         /**
          * 首先car要可以启动起来
          */
         protected abstract void start();
         /**
          * 除了可以开动，car也要可以停止下来
          */
         protected abstract void stop();
         /**
          * car还要可以鸣笛
          */
         public abstract void alarm();
         /**
          * car还要有引擎
          */
         protected abstract void engineBoom();
         /**
          * 定义完规定之后，car要开始进行建立模型，下面就是进行具体的操作。设置为final是为了防止子类破坏进行覆写
          */
         protected final void run() {
                   for(String order:orders){        //forEach循环，取出每一个order
                            if(order!=null){        //值不为空
                                     if(order.equalsIgnoreCase("start")){     //如果start匹配成功
                                               this.start(); // car开始启动
                                     }else if(order.equalsIgnoreCase("engine boom")){      //如果engineBoom匹配成功
                                               this.engineBoom(); // 引擎启动
                                     }else if(order.equalsIgnoreCase("alarm")){  //如果alarm匹配成功
                                               this.alarm(); // 开始鸣笛
                                     }else if(order.equalsIgnoreCase("stop")){    //如果shop匹配成功
                                               this.stop(); // car停下来
                                     }
                            }
                   }
         }
}

　　这样顺序的问题已经解决了，如果想要测试的话，可以在client端建立一个list容器，装上car的需要的特性与顺序，然后通过setter方法设置到自己的car中就可以了。

修改的Client

package com.zqz.dp.builder.model;
import java.util.ArrayList;
import java.util.List;
/**
 * @author Qin
 * 场景类，主要是按照模板CarModel生成不同的car，并开动起来
 */
public class Client {
         public static void main(String[] args) {
                   System.out.println("-----------建立第一辆car-------------");
                   CarModel car1=new Car1();    //根据模板建立第一辆car1
                   List<String> orders=new ArrayList<String>();       //建立一个容器来装执行的特性及顺序
                   orders.add("start");       //有start的方法
                   orders.add("stop");                 //有stop的方法
                   car1.setOrders(orders); //设置到car1中
                   car1.run();        //开始建立car，让car跑动起来
         }
}

　　这样确实可以解决问题了，但是否会发现，main方法中的代码太多了，而且如果现在要求有好几种不同型号的car，是否在main方法中要建立多个这样的list容器呢？这样明确是不符合的。所以这个时候用面向对象的知识，就要把这个list容器的全部操作抽象出来，成为独立的一个类。

　　在这里，因为是car的建造模型，所以把这个类抽象为CarBuilder，表示用来创建不同的模型的car，那么很明显，这个car肯定有一个setOrders(List<String>)，这个方法是用来设置模型的特性及特性的顺序的，当我们建立好模型之后，肯定car就算建立好了，所以在CarBuilder中也应该有一个方法getCarMedol()，表示得到car的模板，当然设置什么模型，得到什么样模板，都是交给子类去实现，所以全部可以定义为abstract。在这里有人会觉得矛盾说，直接把setOrders(List<String>)放在CarModel不是也一样可以实现吗？其实是可以的，不过这样的话CarModel即负责car的特性又关系car的各种特性的执行顺序，兼顾的职责太多了。根据单一职责原则，这里还是构建出一个CarBuilder类会好点，该类只负责CarModel中car的有什么特性且特性的执行顺序。

　　认真的读者应该会发现，这里面虽然抽象出来了一个CarBuilder类，但是在main方法中还是存在着大量的代码。car的定制规则都写在main方法中，这样如果我有几百种建造模型的话，是否在main方法中会存在一大堆代码呢？当然你也可以定义成静态的方法来调用，但是这样的操作还不是很符合逻辑的。

　　最好的方法时再抽象出一个Director类，此类的意思是导演类，用来控制生成car的不同的模型，在这里生成了BMWCar的A、B型号，BenzCar的A型号。其实如果型号不多的话，可以把Director设计成一个单例设计模式的，但是在这里考虑到拓展，如果类型太多的话，可以衍生出一些子类，如BMWDirector等等。紧接着Client也要进行修改，会发现在main方法中变得非常的简洁。

修改的CarModel

package com.zqz.dp.builder.model;
import java.util.ArrayList;
import java.util.List;
/**
 * @author Qin
 * 生产car的模型，所有的才都按照此模板进行设计
 */
public abstract class CarModel {
         /**
          * 定义一个list<String>容器，用来装car跑动时候是否执行，执行的顺序。
          * 封装好，提供getter、setter
          */
         private List<String> orders=new ArrayList<String>();
         public List<String> getOrders() {
                   return orders;
         }
         public void setOrders(List<String> orders) {
                   this.orders = orders;
         }
         /**
          * 首先car要可以启动起来
          */
         protected abstract void start();
         /**
          * 除了可以开动，car也要可以停止下来
          */
         protected abstract void stop();
         /**
          * car还要可以鸣笛
          */
         public abstract void alarm();
         /**
          * car还要有引擎
          */
         protected abstract void engineBoom();
         /**
          * 定义完规定之后，car要开始进行建立模型，下面就是进行具体的操作。设置为final是为了防止子类破坏进行覆写
          */
         public final void run() {
                   for(String order:orders){        //forEach循环，取出每一个order
                            if(order!=null){        //值不为空
                                     if(order.equalsIgnoreCase("start")){     //如果start匹配成功
                                               this.start(); // car开始启动
                                     }else if(order.equalsIgnoreCase("engine boom")){      //如果engineBoom匹配成功
                                               this.engineBoom(); // 引擎启动
                                     }else if(order.equalsIgnoreCase("alarm")){  //如果alarm匹配成功
                                               this.alarm(); // 开始鸣笛
                                     }else if(order.equalsIgnoreCase("stop")){    //如果shop匹配成功
                                               this.stop(); // car停下来
                                     }
                            }
                   }
         }
}

BMWCar

package com.zqz.dp.builder.car;
import com.zqz.dp.builder.model.CarModel;
/**
 * @author Qin
 * 第一辆按照CarModel建立的car1
 */
public class BMWCar extends CarModel {
         @Override
         public void start() {
                   System.out.println("bmw启动");
         }
         @Override
         public void stop() {
                   System.out.println("bmw停下来");
         }
         @Override
         public void alarm() {
                   System.out.println("bmw鸣笛");
         }
         @Override
         public void engineBoom() {
                   System.out.println("bmw启动引擎");
         }
}

package com.zqz.dp.builder.car;
import com.zqz.dp.builder.model.CarModel;
/**
 * @author Qin
 * 第一辆按照CarModel建立的car1
 */
public class BMWCar extends CarModel {
         @Override
         public void start() {
                   System.out.println("bmw启动");
         }
         @Override
         public void stop() {
                   System.out.println("bmw停下来");
         }
         @Override
         public void alarm() {
                   System.out.println("bmw鸣笛");
         }
         @Override
         public void engineBoom() {
                   System.out.println("bmw启动引擎");
         }
}

BenzCar

package com.zqz.dp.builder.car;
import com.zqz.dp.builder.model.CarModel;
/**
 * @author Qin 第二辆按照CarModel建立的car2
 */
public class BenzCar extends CarModel {
         @Override
         public void start() {
                   System.out.println("benz启动");
         }
         @Override
         public void stop() {
                   System.out.println("benz停下来");
         }
         @Override
         public void alarm() {
                   System.out.println("benz鸣笛");
         }
         @Override
         public void engineBoom() {
                   System.out.println("benz启动引擎");
         }
}

CarBuilder

package com.zqz.dp.builder.builder;
import java.util.List;
import com.zqz.dp.builder.modelbuilder.CarModel;
/**
 * @author Qin
 * car的模型，即创建的特性与顺序
 */
public abstract class CarBuilder {
         /**
          * car的模型，存放car的特性，根据不同的顺序是先不同的操作。
          * @param orders  :car的特性
          * 抽象类，交给子类实现
          */
         public abstract void setOrders(List<String> orders);
         /**
          * 得到建立car的model
          * @return      carModel，具体是什么样的model交给子类
          */
         public abstract CarModel getCarModel();
}

BMWBuilder

package com.zqz.dp.builder.builder;
import java.util.List;
import com.zqz.dp.builder.car.BMWCar;
import com.zqz.dp.builder.model.CarModel;
/**
 * @author Qin
 * bmwCar的建造器，设置好关系
 */
public class BMWBuilder extends CarBuilder {
         private CarModel bmwCar=new BMWCar(); //父类实例指向子类，创建BMWCar模型
         @Override
         public void setOrders(List<String> orders) {
                   this.bmwCar.setOrders(orders);   //把存放特性的list集合设置到BMWCar
         }
         @Override
         public CarModel getCarModel() {
                   return this.bmwCar;       //取得CarModel，即取得car的建立的模型，这里的实例是BMW的模型
         }
}

BenzBuilder

package com.zqz.dp.builder.builder;
import java.util.List;
import com.zqz.dp.builder.car.BenzCar;
import com.zqz.dp.builder.model.CarModel;
/**
 * @author Qin
 * benzCar的建造器，设置好关系
 */
public class BenzBuilder extends CarBuilder {
         private CarModel benzCar=new BenzCar();//父类实例指向子类，创建BenzCar模型
         @Override
         public void setOrders(List<String> orders) {
                   this.benzCar.setOrders(orders);   //把存放特性的list集合设置到BenzCar
         }
         @Override
         public CarModel getCarModel() {
                   return this.benzCar;       //取得CarModel，即取得car的建立的模型，这里的实例是Benz的模型
         }
}

Director

package com.zqz.dp.builder.director;
import java.util.ArrayList;
import java.util.List;
import com.zqz.dp.builder.builder.BMWBuilder;
import com.zqz.dp.builder.builder.BenzBuilder;
import com.zqz.dp.builder.builder.CarBuilder;
import com.zqz.dp.builder.model.CarModel;
/**
 * @author Qin
 * 导演类，主要就是用来创建不同的car的建立模型的
 * 比如BMWCar有3中类型，即有3中builder
 */
public class Director {
         /**
          * list容器，用来存放car的特性及顺序
          */
         private List<String> orders=new ArrayList<String>();
         /**
          * BMWCar的建造模型，即建造器
          */
         private CarBuilder bmwBuilder=new BMWBuilder();
         /**
          * BenzCar的建造模型，即建造器
          */
         private CarBuilder benzBuilder=new BenzBuilder();
         /**
          * 第一辆bmwCar的建造模型，设置好特性和顺序
          * @return      CarModel模板，主要返回的是具体的car
          */
         public CarModel getABMWCar(){
                   this.orders.clear(); //先清空list集合
                   this.orders.add("start");        //先启动
                   this.orders.add("engine boom"); //启动引擎
                   this.orders.add("stop");        //停止
                   this.bmwBuilder.setOrders(orders);     //设置list容器到建造器中
                   return this.bmwBuilder.getCarModel();        //通过建造器取得对应的car实例
         }
         /**
          * 第二辆bmwCar的建造模型，设置好特性和顺序
          * @return      CarModel模板，主要返回的是具体的car
          */
         public CarModel getBBMWCar(){
                   this.orders.clear(); //先清空list集合
                   this.orders.add("start");        //先启动
                   this.orders.add("alarm");      //鸣笛
                   this.orders.add("stop");        //停止
                   this.bmwBuilder.setOrders(orders);     //设置list容器到建造器中
                   return this.bmwBuilder.getCarModel();        //通过建造器取得对应的car实例
         }
         /**
          * 第一辆benzCar的建造模型，设置好特性和顺序
          * @return      CarModel模板，主要返回的是具体的car
          */
         public CarModel getABenzCar(){
                   this.orders.clear(); //先清空list集合
                   this.orders.add("start");        //先启动
                   this.orders.add("stop");        //停止
                   this.benzBuilder.setOrders(orders);     //设置list容器到建造器中
                   return this.benzBuilder.getCarModel();        //通过建造器取得对应的car实例
         }
}

Client

package com.zqz.dp.builder.client;
import com.zqz.dp.builder.director.Director;
/**
 * @author Qin
 * 场景类，主要是按照模板CarModel生成不同的car，并开动起来
 */
public class Client {
         public static void main(String[] args) {
                   Director dir=new Director();   //导演类，决定car的特性及顺序
                   System.out.println("-----------建立第一辆car-------------");
                   dir.getABMWCar().run();        //通过模板A建立第一辆bmwCar,并让car跑一会
                   System.out.println("-----------建立第二辆car-------------");
                   dir.getABenzCar().run();//通过模板A建立第一辆benzCar,并让car跑一会
         }
}

在建造者设计模式中，有如下四个角色：

　　1、  Product产品类，如上面的BMWCar和BenzCar。考虑到拓展性还有CarModel

　　2、  Builder抽象建造者，如CarBuilder

　　3、  Builder的实现类，如BMWBuilder、BenzBuilder

　　4、  Director导演类，负责告诉Builder如果进行建造

建造者的优点：

　　1、  封装性：客户端Client不需要知道产品类BMWCar和BenzCar的细节，不需要知道建造器Builder是如何实现的，只知道Director中有方法可以调用放回基本CarModel。

　　2、  建造者独立，容易扩展：BMWBuilder、BenzBuilder是相互独立的，便于拓展。

　　3、  便于控制细节：在拓展中不对其他模块产生影响。

建造者的使用场景：

　　1、  相同的方法，不同的执行顺序，产生不同的事件结果。

　　2、  多个部件或者零件，都可以装配到一个对象中，但产生运行的结果又不一样上面的CarModel。

　　3、  产品类非常复杂，或者产品类的不同的调用顺序产生不同的结果。

注意事项：和工厂方法的区别：

　　建造者关注的是零件类型跟执行的顺序。记住一点：建造者模式最主要的功能是基本方法的调用顺序，也就是其实基本方法已经实现了。而工厂中最主要的就是创建方法。