设计模式系列之建造者模式(Builder Pattern)——复杂对象的组装与建立

说明：设计模式系列文章是读刘伟所著《设计模式的艺术之道(软件开发人员内功修炼之道)》一书的阅读笔记。我的感受这本书讲的不错，有兴趣推荐读一读。详细内容也能够看看此书做者的博客https://blog.csdn.net/LoveLion/article/details/17517213

模式概述

模式定义

没有人买车会只买一个轮胎或者方向盘，你们买的都是一辆包含轮胎、方向盘和发动机等多个部件的完整汽车。如何将这些部件组装成一辆完整的汽车并返回给用户，这是建造者模式须要解决的问题。建造者模式又称为生成器模式，它是一种较为复杂、使用频率也相对较低的建立型模式。建造者模式为客户端返回的不是一个简单的产品，而是一个由多个部件组成的复杂产品。

它将客户端与包含多个组成部分（或部件）的复杂对象的建立过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只须要知道所需建造者的类型便可。它关注如何一步一步建立一个的复杂对象，不一样的具体建造者定义了不一样的建立过程，且具体建造者相互独立，增长新的建造者很是方便，无须修改已有代码，系统具备较好的扩展性。

建造者模式(Builder Pattern)：将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的表示。建造者模式是一种对象建立型模式。

建造者模式一步一步建立一个复杂的对象，它容许用户只经过指定复杂对象的类型和内容就能够构建它们，用户不须要知道内部的具体构建细节。

模式结构图

建造者模式结构图以下所示：

建造者模式结构图中包含以下几个角色:

• Builder（抽象建造者）：它为建立一个产品Product对象的各个部件指定抽象接口，在该接口中通常声明两类方法，一类方法是buildPartX()，它们用于建立复杂对象的各个部件；另外一类方法是getResult()，它们用于返回复杂对象。Builder既能够是抽象类，也能够是接口。

• ConcreteBuilder（具体建造者）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所建立的复杂对象，也能够提供一个方法返回建立好的复杂产品对象。

• Product（产品角色）：它是被构建的复杂对象，包含多个组成部件，具体建造者建立该产品的内部表示并定义它的装配过程。

• Director（指挥者）：指挥者又称为导演类，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，能够在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端通常只须要与指挥者进行交互，在客户端肯定具体建造者的类型，并实例化具体建造者对象（也能够经过配置文件和反射机制），而后经过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。

在建造者模式的定义中提到了复杂对象，那么什么是复杂对象？简单来讲，复杂对象是指那些包含多个非简单类型的成员属性，这些成员属性也称为部件或零件，如汽车包括方向盘、发动机、轮胎等部件，电子邮件包括发件人、收件人、主题、内容、附件等部件。

模式伪代码

定义产品角色，典型代码以下：

public class Product {
    // 定义部件，部件能够是任意类型，包括值类型和引用类型
    private String partA;

    private String partB;

    private String partC;

    // getter、setter方法省略
}

在抽象建造者中定义了产品的建立方法和返回方法，其典型代码以下

public abstract class Builder {
    // 建立产品对象
    protected Product product = new Product();

    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    // 返回产品对象
    public Product getResult() {
        return product;
    }
}

在抽象类Builder中声明了一系列抽象的buildPartX()方法用于建立复杂产品的各个部件，具体建造过程在ConcreteBuilder中实现，此外还提供了工厂方法getResult()，用于返回一个建造好的完整产品。

在ConcreteBuilder中实现了buildPartX()方法，经过调用Product的setPartX()方法能够给产品对象的成员属性设值。不一样的具体建造者在实现buildPartX()方法时将有所区别。

在建造者模式的结构中还引入了一个指挥者类Director，该类主要有两个做用：一方面它隔离了客户与建立过程；另外一方面它控制产品的建立过程，包括某个buildPartX()方法是否被调用以及多个buildPartX()方法调用的前后次序等。指挥者针对抽象建造者编程，客户端只须要知道具体建造者的类型，便可经过指挥者类调用建造者的相关方法，返回一个完整的产品对象。在实际生活中也存在相似指挥者同样的角色，如一个客户去购买电脑，电脑销售人员至关于指挥者，只要客户肯定电脑的类型，电脑销售人员能够通知电脑组装人员给客户组装一台电脑。指挥者类的代码示例以下：

public class Director {

    private Builder builder;

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

    public void setBuilder(Builder builder) {
        this.builder = builer;
    }

    //产品构建与组装方法
    public Product construct() {

        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();

        return builder.getResult();
    }
}

在指挥者类中能够注入一个抽象建造者类型的对象，其核心在于提供了一个建造方法construct()，在该方法中调用了builder对象的构造部件的方法，最后返回一个产品对象。

对于客户端而言，只需关心具体的建造者便可，代码片断以下所示：

public static void main(String[] args) {
    Builder builder = new ConcreteBuilder();

    Director director = new Director(builder);

    Product product = director.construct();
}

模式简化

在有些状况下，为了简化系统结构，能够将Director和抽象建造者Builder进行合并，在Builder中提供逐步构建复杂产品对象的construct()方法。

public abstract class Builder {
    // 建立产品对象
    protected Product product = new Product();

    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    // 返回产品对象
    public Product construct() {
        buildPartA();
        buildPartB();
        buildPartC();
        return product;
    }
}

模式应用

模式在JDK中的应用

java.util.stream.Stream.Builder

public interface Builder<T> extends Consumer<T> {
    /**
     * Adds an element to the stream being built.
     */
    default Builder<T> add(T t) {
        accept(t);
        return this;
    }

    /**
     * Builds the stream, transitioning this builder to the built state
     */
    Stream<T> build();
}

模式在开源项目中的应用

看下Spring是如何构建org.springframework.web.servlet.mvc.method.RequestMappingInfo

/**
 * Defines a builder for creating a RequestMappingInfo.
 * @since 4.2
 */
public interface Builder {
  /**
   * Set the path patterns.
   */
  Builder paths(String... paths);

  /**
   * Set the request method conditions.
   */
  Builder methods(RequestMethod... methods);

  /**
   * Set the request param conditions.
   */
  Builder params(String... params);

  /**
   * Set the header conditions.
   * <p>By default this is not set.
   */
  Builder headers(String... headers);

  /**
   * Build the RequestMappingInfo.
   */
  RequestMappingInfo build();
}

Builder接口的默认实现，以下：

private static class DefaultBuilder implements Builder {

  private String[] paths = new String[0];

  private RequestMethod[] methods = new RequestMethod[0];

  private String[] params = new String[0];

  private String[] headers = new String[0];

  public DefaultBuilder(String... paths) {
    this.paths = paths;
  }

  @Override
  public Builder paths(String... paths) {
    this.paths = paths;
    return this;
  }

  @Override
  public DefaultBuilder methods(RequestMethod... methods) {
    this.methods = methods;
    return this;
  }

  @Override
  public DefaultBuilder params(String... params) {
    this.params = params;
    return this;
  }

  @Override
  public DefaultBuilder headers(String... headers) {
    this.headers = headers;
    return this;
  }
  
  @Override
  public RequestMappingInfo build() {
    ContentNegotiationManager manager = this.options.getContentNegotiationManager();

    PatternsRequestCondition patternsCondition = new PatternsRequestCondition(
        this.paths, this.options.getUrlPathHelper(), this.options.getPathMatcher(),
        this.options.useSuffixPatternMatch(), this.options.useTrailingSlashMatch(),
        this.options.getFileExtensions());

    return new RequestMappingInfo(this.mappingName, patternsCondition,
        new RequestMethodsRequestCondition(this.methods),
        new ParamsRequestCondition(this.params),
        new HeadersRequestCondition(this.headers),
        new ConsumesRequestCondition(this.consumes, this.headers),
        new ProducesRequestCondition(this.produces, this.headers, manager),
        this.customCondition);
  }
}

Spring框架中许多构建类的实例化使用了相似上面方式，总结有如下特色：

1. Builder大可能是构建类的内部类，构建类提供了一个静态建立Builder的方法
2. Builder返回构建类的实例，大多经过build()方法
3. 构建过程有大量参数，除了几个必要参数，用户可根据本身所需选择设置其余参数实例化对象

模式总结

建造者模式的核心在于如何一步步构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不一样的产品，在软件开发中，若是咱们须要建立复杂对象并但愿系统具有很好的灵活性和可扩展性能够考虑使用建造者模式。

建造者模式与抽象工厂模式有点类似，可是建造者模式返回一个完整的复杂产品，而抽象工厂模式返回一系列相关的产品；在抽象工厂模式中，客户端经过选择具体工厂来生成所需对象，而在建造者模式中，客户端经过指定具体建造者类型并指导Director类如何去生成对象，侧重于一步步构造一个复杂对象，而后将结果返回。若是将抽象工厂模式当作一个汽车配件生产厂，生成不一样类型的汽车配件，那么建造者模式就是一个汽车组装厂，经过对配件进行组装返回一辆完整的汽车。

主要优势

1. 将产品自己与产品的建立过程解耦，使得相同的建立过程能够建立不一样的产品对象
2. 能够更加精细地控制产品的建立过程。将复杂产品的建立步骤分解在不一样的方法中，使得建立过程更加清晰，也更方便使用程序来控制建立过程。

适用场景

(1) 须要生成的产品对象有复杂的内部结构，这些产品对象一般包含多个成员属性。

(2) 须要生成的产品对象的属性相互依赖，须要指定其生成顺序。

(3) 隔离复杂对象的建立和使用，并使得相同的建立过程能够建立不一样的产品。