设计模式:建造者(Builder)模式

设计模式之建造者模式

在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由 OPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。

生活中这样的例子很多，如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。

以上所有这些产品都是由多个部件构成的，各个部件可以灵活选择，但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述，只有建造者模式可以很好地描述该类产品的创建。

定义与特点

建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成

结构与实现

结构

建造者（Builder）模式的主要角色如下。

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个滅部件。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

其结构图如图 1 所示。

实现

package com.design.pattern.creationalPattern.builderPattern;

class Client {

    public static void main(String[] args) {
        Builder builder = new DetailBuilder();
        Director director = new Director(builder);
        Product product = director.build();
        product.show();
    }
}
// 产品角色：包含多个组成部件的复杂对象。
class Product{

    private String partOne;

    private String partTwo;

    private String partThree;

    public String getPartOne() {
        return partOne;
    }

    public void setPartOne(String partOne) {
        this.partOne = partOne;
    }

    public String getPartTwo() {
        return partTwo;
    }

    public void setPartTwo(String partTwo) {
        this.partTwo = partTwo;
    }

    public String getPartThree() {
        return partThree;
    }

    public void setPartThree(String partThree) {
        this.partThree = partThree;
    }

    public void show(){

    }
}
//抽象建造者：包含创建产品各个子部件的抽象方法。
abstract class Builder{

    Product product = new Product();
    abstract void buildPartOne();
    abstract void buildPartTwo();
    abstract void buildPartThree();

    public Product getResult(){
        return product;
    }
}
//具体建造者：实现了抽象建造者接口。
class DetailBuilder extends Builder{

    @Override
    void buildPartOne() {
        product.setPartOne("建造第一部分");
    }

    @Override
    void buildPartTwo() {
        product.setPartTwo("建造第二部分");
    }

    @Override
    void buildPartThree() {
        product.setPartThree("建造第三部分");
    }
}
//指挥者：调用建造者中的方法完成复杂对象的创建。
class Director{
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Product build(){
        builder.buildPartOne();
        builder.buildPartTwo();
        builder.buildPartThree();
        return builder.getResult();
    }
}

应用实例

用建造者（Builder）模式描述客厅装修。
分析：客厅装修是一个复杂的过程，它包含墙体的装修、电视机的选择、沙发的购买与布局等。客户把装修要求告诉项目经理，项目经理指挥装修工人一步步装修，最后完成整个客厅的装修与布局，所以本实例用建造者模式实现比较适合。

这里客厅是产品，包括墙、电视和沙发等组成部分。具体装修工人是具体建造者，他们负责装修与墙、电视和沙发的布局。项目经理是指挥者，他负责指挥装修工人进行装修。

package com.design.pattern.creationalPattern.builderPattern;

public class ParlourDecorator {

    public static void main(String[] args) {
        Decorator decorator = new DetailDecorator();
        DecoratorManager manager = new DecoratorManager(decorator);
        Parlour parlour = manager.builder();
        parlour.show();
    }
}

class Parlour{

    private String wall;
    private String TV;
    private String sofa;

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getTV() {
        return TV;
    }

    public void setTV(String TV) {
        this.TV = TV;
    }

    public String getSofa() {
        return sofa;
    }

    public void setSofa(String sofa) {
        this.sofa = sofa;
    }

    public void show(){
        System.out.println("客厅有:"+wall+","+TV+","+sofa);
    }
}

abstract class Decorator{

    Parlour parlour = new Parlour();
    abstract void buildWall();

    abstract void buildTV();

    abstract void buildSofa();

    public Parlour getResult(){
        return parlour;
    }

}

class DetailDecorator extends Decorator{

    @Override
    void buildWall() {
        parlour.setWall("蓝色的墙");
    }

    @Override
    void buildTV() {
        parlour.setTV("TCL电视");
    }

    @Override
    void buildSofa() {
        parlour.setSofa("真皮沙发");
    }
}

class DecoratorManager{
    private Decorator builder;

    public DecoratorManager(Decorator builder) {
        this.builder = builder;
    }

    public Parlour builder(){
        builder.buildWall();
        builder.buildTV();
        builder.buildSofa();
        return builder.getResult();
    }
}

应用场景

建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

• 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
• 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

模式的扩展

建造者（Builder）模式在应用过程中可以根据需要改变，如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。