一、介绍，定义
Builder模式是一步步创建一个复杂对象的创建模式，允许用户在不知道内部构造细节的情况下，可以更精细的控制对象的构造流程。
讲一个复杂对象的构建与他的表示相分离。使得同样的构建过程可以创建不同的表示。
二、使用场景
1相同的方法，不同的生产顺序，产生不同的时间结果时；
2多个部件或者零件。都可以装配到一个对象中，但是产生的运行结果又不相同时；
3产品类非常复杂。或者类中的点调用顺序不同产生了不同的作用；
4初始化一个对象特别复杂，如参数多，且很多参数都有默认值时。
三、Builder模式UML类图
3.png
Products产品类（产品的抽象类）
Builder类（规范产品的组建，但一般不实现具体过程，由子类实现具体组建过程）
ConcreteBuilder类（具体实现Builder类抽象方法）
Director类（统一组装类，多数情况下都会省略该类）。
四、Builder模式简单实现
计算机的组装过程较为复杂，并且组装顺序是不固定的，为了易于理解，我们把计算机组装的过程简化为构建主机，设置操作系统，设置显示器3个部分，然后通过Director和具体的Builder来构建计算机对象。代码如下：
计算机抽象类，即Product角色
public abstract class Computer{
protected String mBoard;
protected String mDisplay;
protected String nOS;
protected Computer(){
}
//设置主板
public void setBoard(String board){
mBoard=board;
}
//设置显示器
public void setDisplay(String display){
mDisplat=display;
}
//设置操作系统
public void setOS();
@Override
public String toString(){
return "Computer[mBoard="+mBoard+",mDisplay="+mDisplay+",mOS="+mOS+"]";
}
}
具体的Computer类，Macbook
public class Macbook extends Computer{
protect Macbook(){
}
@Override
public void setOS(){
mOS="Mac OS X 10.10";
}
抽象Builder类
public abstract class Builder{
//设置主机
protected abstract void buildBoard(String board);
//设置显示器
protected abstract void buildDisplay(String display);
//设置操作系统
protected abstract void buildOS();
//创建Computer
public abstract Computer creat();
}
具体的Build类，MacbookBuilder
public class MacbookBuilder extends Builder{
private Computer mComputer=new Macbook();
@Override
public void buildBoard(String board){
mComputer.setBoard(core);
}
@Override
public void buildDisplay(String display){
mComputer.setDisplay(display);
}
@Override
public void buildOS(){
mComputer.setOS();
}
@Override
public Computer creat(){
return mComputer;
}
}
Director类，负责构造Computer
public class Director{
Builder mBuilder=null;
//@param builder
public Director(Builder builder){
mBuilder=builder;
}
//构建对象
public void construct(String board,String display){
mBuilder.buildBoard(board);
mBuilder.buildDisplay(display);
mBuilder.buildOS();
}
}
测试代码
public class Test{
public static void main(String[] args){
//构造器
Builder builder=new MacbookBuilder();
//Director
Dirctor pcDirector=new Director(builder);
//封装构建过程，4核，内存2GB,Mac系统
pcDirector.construct("因特尔主板","Retina显示器");
//构建计算机，输出相关信息
System.out.println("Computer info:"+builder.create().toString());
}
}
输出结果：
Computer Info: Computer[mBoard=英特尔主板，mDisplay=Retina显示器，mOS=Mac os x 10.10]
上述代码中，通过具体的MacbookBuilder来构建Macbook对象，而Director封装了构建复杂产品的过程，对外隐藏了细节。Builder与Director一起将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。
值得注意的是，在现实开发过程中，Director角色经常会被忽略。而直接使用一个Builder来进行对象的封装，这个Builder通常为链式调用，它的关键点是每个setter方法都返回自身，也就是return this,这样就使得setter方法可以链式调用.
五、Builder模式另一个例子
宝马汽车的组装，简单分为几步（组装汽车外壳、组装汽车中控、组装汽车发动机等机械部件、内饰）。
Product类：
public abstract class BMWCar {
// 汽车外壳
protected String mShell;
// 汽车多媒体中控
protected String mControl;
// 汽车引擎和其他机械部件
protected String mEngineAndOthers;
// 汽车内饰
protected String mDecoration;
protected BMWCar(){
}
// 转配汽车外壳
public void setShell(String mShell) {
this.mShell = mShell;
}
// 装配汽车多媒体中控
public void setControl(String mControl) {
this.mControl = mControl;
}
// 装配汽车机械部件
public void setEngineAndOthers() {
}
// 装配汽车内饰
public void setDecoration(String mDecoration) {
this.mDecoration = mDecoration;
}
}
这个类定义产品，但是并不去装配产品，只是定义一个规则，那么我们想要组装一台X6汽车，这里先抽象的设置X6和一般宝马汽车最大的不同是发动机和机械组件,所以一上来我们的生产工人先把各型号的发动机组装好，这个是技术活，当然给高级工程师，不需要装配工人介入了。
public class BMWX6Car extends BMWCar{
protected BMWX6Car(){
}
// 抽象为X6区别就是发动机等主要机械组件不一样
@Override
public void setEngineAndOthers() {
mEngineAndOthers = "宝马X6专用发动机";
}
}
宝马汽车的主要部分已经好了，那么把这个大框架给到组装工人去做外层处理，再定义一个生产规则：（Builder类）
public abstract class Builder {
// 设置外壳
public abstract Builder buliderShell(String shell);
// 设置中控系统
public abstract Builder buliderControl(String control);
// 装置机械组件
public abstract Builder buliderEngineAndOthers();
// 装配内饰
public abstract Builder buliderDecoration(String decoration);
// 出厂汽车
public abstract BMWCar create();
}
这当时组装经理定义好了规则，下发给下一级员工。(下面说具体的Bulider类)
public class BMWX6Bulider extends Builder{
private BMWCar mBMWCar = new BMWX6Car();
@Override
public Builder buliderShell(String shell) {
mBMWCar.setShell(shell);
return this;
}
@Override
public Builder buliderControl(String control) {
mBMWCar.setControl(control);
return this;
}
@Override
public Builder buliderEngineAndOthers() {
mBMWCar.setEngineAndOthers();
return this;
}
@Override
public Builder buliderDecoration(String decoration) {
mBMWCar.setDecoration(decoration);
return this;
}
@Override
public BMWCar create() {
return mBMWCar;
}
}
为了满足生产线流水工作，组长把这个组装过程封装了一下，只要员工按规矩来就能够组装好，而且组装过程变得非常简单，员工只需要把组装的原件放到指定位置就OK(Director类)。
public class Director {
Builder mBulider = null;
public Director(Builder builder){
this.mBulider = builder;
}
/**
* 统一组装，简化生产步骤
* @param shell
* @param control
* @param decoration
* @return
*/
public BMWCar createCar(String shell,String control,String decoration){
return mBulider.buliderShell(shell)
.buliderControl(control)
.buliderEngineAndOthers()
.buliderDecoration(decoration).create();
}
}
六、优点缺点
优点：
良好的封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节；
建造者独立，容易扩展；
缺点：
会产生多余的Builder对象以及Director对象，消耗内存。
网友评论