设计模式系列 — 建造者模式

点赞再看，养成习惯，公众号搜一搜【一角钱技术】关注更多原创技术文章。
本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。

前言

• 23种设计模式速记
• 单例（singleton）模式
• 工厂方法（factory method）模式
• 抽象工厂（abstract factory）模式

23种设计模式快速记忆的请看上面第一篇，本篇和大家一起来学习建造者模式相关内容。

模式定义

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

1. 用户只需要给出指定复杂对象的类型和内容；
2. 建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来)

解决的问题

1. 降低创建复杂对象的复杂度
2. 隔离了创建对象的构建过程 & 表示

从而：

• 方便用户创建复杂的对象（不需要知道实现过程）
• 代码复用性 & 封装性（将对象构建过程和细节进行封装 & 复用）

模式组成

1. 指挥者（Director）直接和客户（Client）进行需求沟通；
2. 沟通后指挥者将客户创建产品的需求划分为各个部件的建造请求（Builder）；
3. 将各个部件的建造请求委派到具体的建造者（ConcreteBuilder）；
4. 各个具体建造者负责进行产品部件的构建；
5. 最终构建成具体产品（Product）。

实例说明

实例概况

• 背景
  小张希望去中关村买一台组装的台式主机
• 过程

1. 中关村老板（Diretor）和小张（Client）进行需求沟通（买来打游戏？学习？看片？）
2. 了解需求后，电脑城老板将小张需要的主机划分为各个部件（Builder）的建造请求（CPU、主板......）
3. 指挥装机人员（ConcreteBuilder）去构建组件；
4. 将组件组装起来成小张需要的电脑（Product）

使用步骤

步骤1：定义具体产品类（Product）：电脑

class Computer{

    //电脑组件的集合
    private List parts = new ArrayList();

    //用于将组件组装到电脑里
    public void Add(String part){
        parts.add(part);
    }

    public void Show(){
        for (int i = 0;i

步骤2：定义组装的过程（Builder）：组装电脑的过程

abstract class Builder {

    //第一步：装CPU
    //声明为抽象方法，具体由子类实现
    public abstract void  BuildCPU();

    //第二步：装主板
    //声明为抽象方法，具体由子类实现
    public abstract void BuildMainboard();

    //第三步：装硬盘
    //声明为抽象方法，具体由子类实现
    public abstract void BuildHD();

    //返回产品的方法：获得组装好的电脑
    public abstract Computer GetComputer();
}

步骤3： 中关村老板委派任务给装机人员（Director）

class Director{
    //指挥装机人员组装电脑
    public void Construct(Builder builder){
        builder. BuildCPU();
        builder.BuildMainboard();
        builder.BuildHD();
    }
}

步骤4： 创建具体的建造者（ConcreteBuilder）:装机人员

class ConcreteBuilder extends Builder{
    //创建产品实例
    Computer computer = new Computer();

    //组装产品
    @Override
    public void  BuildCPU(){
        computer.Add("组装CPU");
    }

    @Override
    public void  BuildMainboard() {
        computer.Add("组装主板");
    }

    @Override
    public void  BuildHD() {
        computer.Add("组装主板");
    }

    //返回组装成功的电脑
    @Override
    public  Computer GetComputer(){
        return computer;
    }
}

步骤5：客户端调用-小张到电脑城找老板买电脑

public class BuilderPattern {

    public static void main(String[] args) {
        // 步骤5：客户端调用-小张到电脑城找老板买电脑

        //逛了很久终于发现一家合适的电脑店
        //找到该店的老板和装机人员
        Director director = new Director();

        Builder builder = new ConcreteBuilder();

        //沟通需求后，老板叫装机人员去装电脑
        director.Construct(builder);

        //装完后，组装人员搬来组装好的电脑
        Computer computer = builder.GetComputer();
        //组装人员展示电脑给小张看
        computer.Show();
    }
}

输出结果

组件CPU装好了
组件主板装好了
组件硬盘装好了
电脑组装完成，请验收

优点

1. 良好的封装性：建造者对客户端屏蔽了产品内部组成的细节，客户端不用关心每一个具体的产品内部是如何实现的。
2. 符合开闭原则
3. 便于控制细节风险：由于建造者是相互独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

缺点

1. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
2. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

应用场景

1. 需要生成的对象具有复杂的内部结构
2. 需要生成的对象内部属性本身相互依赖
3. 与不可变对象配合使用

与工厂方法模式的区别

建造者模式最主要的功能是基本方法的调用顺序安排，基本方法已经实现，我们可以理解为零件的装配，顺序不同产生的对象也不同；而工厂方法的注重点是创建，创建零件是其主要职责，不关心组装顺序。

源码中的应用

# jdk
java.lang.StringBuilder
# Spring源码
org.springframework.web.servlet.mvc.method.RequestMappingInfo
org.springframework.beans.factory.support.BeanDefinitionBuilder
......

StringBuilder源码分析

在jdk中StringBuilder类的实现中，采用建造者模式的思想。具体分析如下：

StringBuilder类继承自AbstractStringBuilder，而AbstractStringBuilder实现了Appendable接口。AbstractStringBuilder虽然是一个抽象类，但是它实现了Appendable接口中的各个append()方法，因此在这里Appendable接口是一个抽象建造者，而AbstractStringBuilder是建造者，只是不能实例化。对于StringBuilder类，它既充当了指挥者角色，同时充当了具体的建造者，建造方法的具体实现是由AbstractStringBuilder完成，StringBuilder继承了AbstractStringBuilder。

Appendable接口

public interface Appendable {
    Appendable append(CharSequence csq) throws IOException;
    Appendable append(CharSequence csq, int start, int end) throws IOException;
    Appendable append(char c) throws IOException;
}

AbstractStringBuilder类

abstract class AbstractStringBuilder implements Appendable, CharSequence {
 
    char[] value;//The value is used for character storage.
    int count;//The count is the number of characters used.

    AbstractStringBuilder() { }

    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

    private AbstractStringBuilder appendNull() {
        int c = count;
        ensureCapacityInternal(c + 4);
        final char[] value = this.value;
        value[c++] = 'n';
        value[c++] = 'u';
        value[c++] = 'l';
        value[c++] = 'l';
        count = c;
        return this;
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

    public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }
    // 此次省略......

}

StringBuilder类：

public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence {
    //虽说是重写，但还是调用的AbstractStringBuilder方法
   @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
}

PS：以上代码提交在 Github ：https://github.com/Niuh-Study/niuh-designpatterns.git

文章持续更新，可以公众号搜一搜「 一角钱技术 」第一时间阅读。
本文 GitHub org_hejianhui/JavaStudy 已经收录，欢迎 Star。