Java设计模式之建造者（Builder）模式

Java设计模式之建造者（Builder）模式

建造者模式介绍：

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

因为一个复杂的对象又很多大量组成部分，如电脑，有主板，显卡，显示器，CPU，电源，还有各种小零件等，如何将这些部件装配成一台可以使用的电脑，这个配装过程需要一定的时间，也很复杂，对于这种情况，为了在构建过程中对外部隐藏实现细节，就可以使用建造者模式将部件和组装过程分离，使得构建过程和部件都可以自由扩展，两者之间的耦合也降到最低。

　

建造者模式的定义：

　

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

建造者模式的使用场景：

　

　3.1相同的方法，不同的执行顺序，产生不同的事件结果时

　3.2多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。

　

　3.3产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候使用建造者模式非常适合。

　

　3.4当初始化一个对象特别复杂，如参数多，切很多参数都具有默认值时。

建造者模式的UML类图：

　

角色介绍：

　

Product产品类——产品的抽象类；

　

Builder——抽象Builder类，规范产品的组建，一般是由子类实现具体的组建过程；

　　

ConcreteBuilder——具体的Builder类；

　

Director——统一组装过程

　

　

建造者模式的简单实现：

　

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

　

Computer.java

/**
计算机抽象类，相当于Product角色
*/
public abstract class Computer {
protected String mBoard;
protected String mDisplay;
protected String mOS;

protected Computer(){

}
//设置主板
public void setmBoard(String mBoard) {
this.mBoard = mBoard;
}
//设置显示器
public void setmDisplay(String mDisplay) {
this.mDisplay = mDisplay;
}
//设置操作系统
public abstract void setmOS();

@Override
public String toString() {
return "Computer{" +
"mBoard='" + mBoard + '\'' +
", mDisplay='" + mDisplay + '\'' +
", mOS='" + mOS + '\'' +
'}';
}
}

Windows.java

/**
具体的Computer类，Windows
*/
public class Windows extends Computer {
protected Windows(){

}

@Override
public void setmOS() {
mOS = "Windows10";
}

}

Builder.java

/**
* 抽象Builder类
*/
public abstract class Builder {
//设置主机
public abstract void builderBoard(String borad);
//设置显示器
public abstract void builderDisplay(String display);
//设置操作系统
public abstract void builderOS();

//创建Computer
public abstract Computer create();
}

WindowsBuilder.java

/**
* 具体的Builder类，WindowsBuilder
*/
public class WindowsBuilder extends Builder {
private Computer mComputer = new Windows();
@Override
public void builderBoard(String borad) {
mComputer.setmBoard(borad);
}

@Override
public void builderDisplay(String display) {
mComputer.setmDisplay(display);
}

@Override
public void builderOS() {
mComputer.setmOS();
}

@Override
public Computer create() {
return mComputer;
}
}

Director.java

/**
* Director类，负责构造Computer
*/
public class Director {
Builder mBuilder;
public Director(Builder mBuilder){
this.mBuilder = mBuilder;
}

/**
* 构建对象
* @param board
* @param display
*/
public void construct(String board, String display){
mBuilder.builderBoard(board);
mBuilder.builderDisplay(display);
mBuilder.builderOS();
}
}

Test.java

/**
* 测试代码
*/
public class Test {
public static void main(String[] args) {
//构造器
Builder builder = new WindowsBuilder();
Director pcDirector = new Director(builder);
//封装构建过程，
pcDirector.construct("华硕主板","Retina显示器");
System.out.println("Computer Info : " + builder.create().toString());
}
}

上述实例中，通过具体的WindowsBuilder来构建Windows对象，而Director封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder与Director一起将一个复杂对象的构建与它的表示分离，使用同样的构造过程可以创建不同的对象。

值得注意的是，在显示开发过程中，Director角色经常会被省略。而直接使用一个Builder来进行对象的组装，这个Builder通常为链式调用，它的关键点是每个setter方法都返回自身，也就是return this，这样就使得setter方法可以链式调用，代码大致如下：

new TestBuilder().setA(“A”).setB(“B”).create()；

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