Fun论设计模式之5：建造者模式（Builder Pattern）

　　建造者模式在程序设计中经常被运用，下面是建造者模式的概述。

　　意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

　　主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

　　何时使用：一些基本部件不会变，而其组合经常变化的时候。

　　如何解决：将变与不变分离开。

　　关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

　　应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

 

　　说来复杂，其实要实现一个也很简单。

　　跟标准模式相似，不同之处是建造者模式可以直接用本身的复杂组合。

　　Java web系统多数都有MySQL表转实体类的组件，直接把生成的实体类的setter返回类型改成实体类本身，返回对象改成本身（this），一个属性也是组合，也能做成一个类builder，跟builder类似的地方是这个对象也可以链式调用改属性的函数；不同的是这个User本身不是单独的builder，且不是延迟build（构造对象）。

public class User {

    private Integer id;

    private String password;

    private String username;

    private Integer userIdentity;

    private String userMobile;
    
    private String classId;

    /**
     * 班级ID
     */
    @Column(name = "`class_id`")
    @ApiModelProperty(value = "班级ID（id1,id2,id3...）",example = "班级ID（id1,id2,id3...）",required = false)
    private String classId;

    public Integer getId() {
        return id;
    }

    public User setId(Integer id) {
        this.id = id;
        return this;
    }

    public String getPassword() {
        return password;
    }

    public User setPassword(String password) {
        this.password = password;
        return this;
    }

    public String getUsername() {
        return username;
    }

    public User setUsername(String username) {
        this.username = username;
        return this;
    }

    public Integer getUserIdentity() {
        return userIdentity;
    }

    public User setUserIdentity(Integer userIdentity) {
        this.userIdentity = userIdentity;
        return this;
    }

    public String getUserMobile() {
        return userMobile;
    }
    
    public User setUserMobile(String userMobile) {
        this.userMobile = userMobile;
        return this;
    }

    public String getClassId() {
        return classId;
    }
    
    public User setClassId(String classId) {
        this.classId = classId;
        return this;
    }
}

　　（当然这里不推荐用这种方式，一般用withXXX这种函数名格式，setXXX用这个不符合规范）

　　

　　当然这么做也有问题。如果这个User不是单纯在本地程序中使用，还需要请求外部返回数据（这里builder化的实体类也可以与MySQL交互），并且返回实体类的数据结构与请求的数据结构不同（很多rest API的请求数据结构就是这样），请求的builder和响应的实体类也要区分开。User的builder就要这样写：

public class UserBuilder {

    private Integer id;

    private String password;

    private String username;

    private Integer userIdentity;

    private String userMobile;
    
    private String classId;

    public User build(){
        User user = new User();
        user.id = id;
        user.password = password;
        user.username = username;
        user.userIdentity = userIdentity;
        user.userMobile = userMobile;
        user.classId = classId;
        return user;
    }
    
    /**
     * 班级ID
     */
    @Column(name = "`class_id`")
    @ApiModelProperty(value = "班级ID（id1,id2,id3...）",example = "班级ID（id1,id2,id3...）",required = false)
    private String classId;

    public Integer getId() {
        return id;
    }

    public User withId(Integer id) {
        this.id = id;
        return this;
    }

    public String getPassword() {
        return password;
    }

    public User withPassword(String password) {
        this.password = password;
        return this;
    }

    public String getUsername() {
        return username;
    }

    public User withUsername(String username) {
        this.username = username;
        return this;
    }

    public Integer getUserIdentity() {
        return userIdentity;
    }

    public User withUserIdentity(Integer userIdentity) {
        this.userIdentity = userIdentity;
        return this;
    }

    public String getUserMobile() {
        return userMobile;
    }
    
    public User withUserMobile(String userMobile) {
        this.userMobile = userMobile;
        return this;
    }

    public String getClassId() {
        return classId;
    }
    
    public User withClassId(String classId) {
        this.classId = classId;
        return this;
    }
}

　　对应的User就可以按照返回的数据结构定制了。

　　

　　还有一种情况，请求的数据结构比较复杂，某些属性下还有字典和数组，这种情况类似于汽车的生产，里面有些部件不是标准的，一定要预先搭建好（对应于某些属性下的字典），有些组件还不止一个（对应于某些属性下的数组），有些组件如果要修改，与之相关的组件也要进行改动（对象内属性关联修改），那时就需要给类设定一次设置好相关属性的函数。

　　像连接kubernetes创建副本控制器（replicationController）的builder，就使用了批量设置复杂对象的函数。

　　创建副本控制器的builder：

package io.kubernetes.client.models;

import io.kubernetes.client.fluent.*;

public class V1ReplicationControllerBuilder extends V1ReplicationControllerFluentImpl<V1ReplicationControllerBuilder> implements VisitableBuilder<V1ReplicationController, V1ReplicationControllerBuilder>
{
    V1ReplicationControllerFluent<?> fluent;
    Boolean validationEnabled;
    
    public V1ReplicationControllerBuilder() {
        this(Boolean.valueOf(true));
    }
    
    public V1ReplicationControllerBuilder(final Boolean validationEnabled) {
        this(new V1ReplicationController(), validationEnabled);
    }
    
    public V1ReplicationControllerBuilder(final V1ReplicationControllerFluent<?> fluent) {
        this(fluent, Boolean.valueOf(true));
    }
    
    public V1ReplicationControllerBuilder(final V1ReplicationControllerFluent<?> fluent, final Boolean validationEnabled) {
        this(fluent, new V1ReplicationController(), validationEnabled);
    }
    
    public V1ReplicationControllerBuilder(final V1ReplicationControllerFluent<?> fluent, final V1ReplicationController instance) {
        this(fluent, instance, true);
    }
    
    public V1ReplicationControllerBuilder(final V1ReplicationControllerFluent<?> fluent, final V1ReplicationController instance, final Boolean validationEnabled) {
        (this.fluent = fluent).withApiVersion(instance.getApiVersion());
        fluent.withKind(instance.getKind());
        fluent.withMetadata(instance.getMetadata());
        fluent.withSpec(instance.getSpec());
        fluent.withStatus(instance.getStatus());
        this.validationEnabled = validationEnabled;
    }
    
    public V1ReplicationControllerBuilder(final V1ReplicationController instance) {
        this(instance, Boolean.valueOf(true));
    }
    
    public V1ReplicationControllerBuilder(final V1ReplicationController instance, final Boolean validationEnabled) {
        ((V1ReplicationControllerFluentImpl<V1ReplicationControllerFluent>)(this.fluent = this)).withApiVersion(instance.getApiVersion());
        this.withKind(instance.getKind());
        this.withMetadata(instance.getMetadata());
        this.withSpec(instance.getSpec());
        this.withStatus(instance.getStatus());
        this.validationEnabled = validationEnabled;
    }
    
    @Override
    public V1ReplicationController build() {
        final V1ReplicationController buildable = new V1ReplicationController();
        buildable.setApiVersion(this.fluent.getApiVersion());
        buildable.setKind(this.fluent.getKind());
        buildable.setMetadata(this.fluent.getMetadata());
        buildable.setSpec(this.fluent.getSpec());
        buildable.setStatus(this.fluent.getStatus());
        return buildable;
    }
    
    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        if (!super.equals(o)) {
            return false;
        }
        final V1ReplicationControllerBuilder that = (V1ReplicationControllerBuilder)o;
        Label_0088: {
            if (this.fluent != null && this.fluent != this) {
                if (this.fluent.equals(that.fluent)) {
                    break Label_0088;
                }
            }
            else if (that.fluent == null || this.fluent == this) {
                break Label_0088;
            }
            return false;
        }
        if (this.validationEnabled != null) {
            if (this.validationEnabled.equals(that.validationEnabled)) {
                return true;
            }
        }
        else if (that.validationEnabled == null) {
            return true;
        }
        return false;
    }
}

　　这里只声明了构造函数和build函数，属性的变更是继承ReplicationController的：

package io.kubernetes.client.models;

import com.google.gson.annotations.*;
import io.swagger.annotations.*;
import java.util.*;

@ApiModel(description = "ReplicationController represents the configuration of a replication controller.")
public class V1ReplicationController
{
    @SerializedName("apiVersion")
    private String apiVersion;
    @SerializedName("kind")
    private String kind;
    @SerializedName("metadata")
    private V1ObjectMeta metadata;
    @SerializedName("spec")
    private V1ReplicationControllerSpec spec;
    @SerializedName("status")
    private V1ReplicationControllerStatus status;
    
    public V1ReplicationController() {
        this.apiVersion = null;
        this.kind = null;
        this.metadata = null;
        this.spec = null;
        this.status = null;
    }
    
    public V1ReplicationController apiVersion(final String apiVersion) {
        this.apiVersion = apiVersion;
        return this;
    }
    
    @ApiModelProperty("APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources")
    public String getApiVersion() {
        return this.apiVersion;
    }
    
    public void setApiVersion(final String apiVersion) {
        this.apiVersion = apiVersion;
    }
    
    public V1ReplicationController kind(final String kind) {
        this.kind = kind;
        return this;
    }
    
    @ApiModelProperty("Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds")
    public String getKind() {
        return this.kind;
    }
    
    public void setKind(final String kind) {
        this.kind = kind;
    }
    
    public V1ReplicationController metadata(final V1ObjectMeta metadata) {
        this.metadata = metadata;
        return this;
    }
    
    @ApiModelProperty("If the Labels of a ReplicationController are empty, they are defaulted to be the same as the Pod(s) that the replication controller manages. Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata")
    public V1ObjectMeta getMetadata() {
        return this.metadata;
    }
    
    public void setMetadata(final V1ObjectMeta metadata) {
        this.metadata = metadata;
    }
    
    public V1ReplicationController spec(final V1ReplicationControllerSpec spec) {
        this.spec = spec;
        return this;
    }
    
    @ApiModelProperty("Spec defines the specification of the desired behavior of the replication controller. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status")
    public V1ReplicationControllerSpec getSpec() {
        return this.spec;
    }
    
    public void setSpec(final V1ReplicationControllerSpec spec) {
        this.spec = spec;
    }
    
    public V1ReplicationController status(final V1ReplicationControllerStatus status) {
        this.status = status;
        return this;
    }
    
    @ApiModelProperty("Status is the most recently observed status of the replication controller. This data may be out of date by some window of time. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status")
    public V1ReplicationControllerStatus getStatus() {
        return this.status;
    }
    
    public void setStatus(final V1ReplicationControllerStatus status) {
        this.status = status;
    }
    
    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        final V1ReplicationController v1ReplicationController = (V1ReplicationController)o;
        return Objects.equals(this.apiVersion, v1ReplicationController.apiVersion) && Objects.equals(this.kind, v1ReplicationController.kind) && Objects.equals(this.metadata, v1ReplicationController.metadata) && Objects.equals(this.spec, v1ReplicationController.spec) && Objects.equals(this.status, v1ReplicationController.status);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(this.apiVersion, this.kind, this.metadata, this.spec, this.status);
    }
    
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("class V1ReplicationController {\n");
        sb.append("    apiVersion: ").append(this.toIndentedString(this.apiVersion)).append("\n");
        sb.append("    kind: ").append(this.toIndentedString(this.kind)).append("\n");
        sb.append("    metadata: ").append(this.toIndentedString(this.metadata)).append("\n");
        sb.append("    spec: ").append(this.toIndentedString(this.spec)).append("\n");
        sb.append("    status: ").append(this.toIndentedString(this.status)).append("\n");
        sb.append("}");
        return sb.toString();
    }
    
    private String toIndentedString(final Object o) {
        if (o == null) {
            return "null";
        }
        return o.toString().replace("\n", "\n    ");
    }
}

　　本例子中，副本控制器包含了以下属性：

Kind
ApiVersion
Metadata
--labelMap
--name
Spec
--Replicas
--labelMap
--template
----Metadata
------labelMap
--------labelSelector
------name
----podSpec
------containers
------volumes

　　里面有好些属性是重复的，如果不用建造者模式控制会造成某些地方的属性不一致；并且，创建副本控制器的参数多且杂，如果全部平摊成单独属性，改变某些组属性要一行行改，很繁琐，且容易出错。使用建造者模式，像上面的标签集就不用一个个传，对于批量创建某些标签集类似的容器的场合很方便。

　　这样既可实现比较简单的builder，又无需重复编写代码，复用对应的实体类函数。

　　优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

　　缺点： 1、产品必须有共同点，范围有限制。（像本例的副本控制器，换了品类就得推到重来） 2、如内部变化复杂，会有很多的建造类。（还好本例只有一种副本控制器）

　　使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

　　注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。