设计模式之Builder模式的简单实现

Builder模式介绍

Builder模式是一步一步创建一个复杂对象的创建型模型，它允许用户在不知道内部构建细节的情况下，可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦，使得构建过程和表示隔离开来

因为一个复杂的对象有很多大量组成部件，如汽车，有车轮，方向盘，发动机，还有各种小零件等，如何将这些部件装配成一辆汽车，这个装配过程很漫长，也很复杂，对于这种情况，为了在构建过程中对外隐藏实现细节，就可以使用Builder模式将部件和组装过程分离，使得构建过程和部件都可以自由扩展，两者之间的耦合也降到最低。

Builder模式的定义

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

Builder模式的使用场景

(1) 相同的方法，不同的执行顺序，产生不同的事件结果
(2)多个部件或零件，都可以装配到一个对象中，但是产生的运行结 果又不相同时
(3) 产品类非常复杂，或者产品类中的调用顺序不同产生不同的作用，这个时候使用构建者模式非常合适
(4) 当初始化一个对象特别复杂，如参数多，且很多参数都具有默认值时。

Builder模式的简单实现

计算机的组装过程较为复杂，并且组装顺序是不固定的，为了易于理解，我们把计算机组装的过程简化为构建主机，设置操作系统，设置显示器3个部分，然后通过Director和具体的Builder来构建计算机对象。代码如下：

package com.ljz.builderdemo;
//计算机抽象类，即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(0;
}

@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方法可以链式调用，代码大致如下：

new TestBuilder().setA("A").setB("B").create();

通过这种形式不仅去除了Director角色，整个结构也更简单，也能对Product对象的组装过程有更精细的控制。