设计模式 | 建造者模式及典型应用

作者: 小旋锋的简书 | 来源:发表于2019-01-03 23:35 被阅读0次

建造者模式

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

建造者模式一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

角色

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

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

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

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

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

示例

产品角色 Computer

public class Computer {
    private String brand;
    private String cpu;
    private String mainBoard;
    private String hardDisk;
    private String displayCard;
    private String power;
    private String memory;
    // 省略 getter, setter, toString
}

抽象建造者 builder

public abstract class Builder {
    protected Computer computer = new Computer();

    public abstract void buildBrand();
    public abstract void buildCPU();
    public abstract void buildMainBoard();
    public abstract void buildHardDisk();
    public abstract void buildDisplayCard();
    public abstract void buildPower();
    public abstract void buildMemory();
    public Computer createComputer() {
        return computer;
    }
}

具体建造者 DellComputerBuilder，ASUSComputerBuilder，分别建造戴尔电脑和华硕电脑

public class DellComputerBuilder extends Builder {
    @Override
    public void buildBrand() {
        computer.setBrand("戴尔电脑");
    }
    @Override
    public void buildCPU() {
        computer.setCpu("i5-8300H 四核");
    }
    @Override
    public void buildMainBoard() {
        computer.setMainBoard("戴尔主板");
    }
    @Override
    public void buildHardDisk() {
        computer.setHardDisk("1T + 128GB SSD");
    }
    @Override
    public void buildDisplayCard() {
        computer.setDisplayCard("GTX1060 独立6GB");
    }
    @Override
    public void buildPower() {
        computer.setPower("4芯 锂离子电池 180W AC适配器");
    }
    @Override
    public void buildMemory() {
        computer.setMemory("4G + 4G");
    }
}

public class ASUSComputerBuilder extends Builder{
    @Override
    public void buildBrand() {
        computer.setBrand("华硕电脑");
    }
    @Override
    public void buildCPU() {
        computer.setCpu("Intel 第8代 酷睿");
    }
    @Override
    public void buildMainBoard() {
        computer.setMainBoard("华硕主板");
    }
    @Override
    public void buildHardDisk() {
        computer.setHardDisk("256GB SSD");
    }
    @Override
    public void buildDisplayCard() {
        computer.setDisplayCard("MX150 独立2GB");
    }
    @Override
    public void buildPower() {
        computer.setPower("3芯 锂离子电池 65W AC适配器");
    }
    @Override
    public void buildMemory() {
        computer.setMemory("1 x SO-DIMM  8GB");
    }
}

指挥者 ComputerDirector，指挥构建过程

public class ComputerDirector {
    public Computer construct(Builder builder) {
        // 逐步构建复杂产品对象
        Computer computer;
        builder.buildBrand();
        builder.buildCPU();
        builder.buildDisplayCard();
        builder.buildHardDisk();
        builder.buildMainBoard();
        builder.buildMemory();
        builder.buildPower();
        computer = builder.createComputer();
        return computer;
    }
}

客户端测试

public class Test {
    public static void main(String[] args) {
        ComputerDirector director = new ComputerDirector();

        Builder asusBuilder = new ASUSComputerBuilder();
        Computer asusComputer = director.construct(asusBuilder);
        System.out.println(asusComputer.toString());

        Builder dellBuilder = new DellComputerBuilder();
        Computer dellComputer = director.construct(dellBuilder);
        System.out.println(dellComputer.toString());
    }
}

输出

Computer{brand='华硕电脑', cpu='Intel 第8代 酷睿', mainBoard='华硕主板', hardDisk='256GB SSD', displayCard='MX150 独立2GB', power='3芯 锂离子电池 65W AC适配器', memory='1 x SO-DIMM  8GB'}
Computer{brand='戴尔电脑', cpu='i5-8300H 四核', mainBoard='戴尔主板', hardDisk='1T + 128GB SSD', displayCard='GTX1060 独立6GB', power='4芯 锂离子电池 180W AC适配器', memory='4G + 4G'}

可以通过反射机制和配置文件配合，创建具体建造者对象

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        ComputerDirector director = new ComputerDirector();

        // 从数据库或者配置文件中读取具体建造者类名
        Class c = Class.forName("com.designpattern.ASUSComputerBuilder");
        Builder asusBuilder = (Builder) c.newInstance();
        Computer asusComputer = director.construct(asusBuilder);
        System.out.println(asusComputer.toString());
    }
}

image

建造者模式总结

建造者模式的主要优点如下：

在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合 "开闭原则"。
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

建造者模式的主要缺点如下：

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

适用场景：

需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中。
隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

建造者模式的典型应用和源码分析

java.lang.StringBuilder 中的建造者模式

StringBuilder 的继承实现关系如下所示

StringBuilder的类图

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;
}

StringBuilder 中的 append 方法使用了建造者模式，不过装配方法只有一个，并不算复杂，append 方法返回的是 StringBuilder 自身

public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence {
    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    // ...省略...
}

StringBuilder 的父类 AbstractStringBuilder 实现了 Appendable 接口

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
    int count;
    
    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 void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    // ...省略...
}

我们可以看出，Appendable 为抽象建造者，定义了建造方法，StringBuilder 既充当指挥者角色，又充当产品角色，又充当具体建造者，建造方法的实现由 AbstractStringBuilder 完成，而 StringBuilder 继承了 AbstractStringBuilder

java.lang.StringBuffer 中的建造者方法

StringBuffer 继承与实现关系如下

StringBuffer的类图

这分明就与 StringBuilder 一样嘛！

那它们有什么不同呢？

public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence {
    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }
    //...省略...
}

看 StringBuffer 的源码如上，它们的区别就是： StringBuffer 中的 append 加了 synchronized 关键字，所以StringBuffer 是线程安全的，而 StringBuilder 是非线程安全的

StringBuffer 中的建造者模式与 StringBuilder 是一致的

Google Guava 中的建造者模式

ImmutableSet 不可变Set的主要方法如下

ImmutableSet方法列表

ImmutableSet 类中 of, copyOf 等方法返回的是一个 ImmutableSet 对象，这里是一个建造者模式，所构建的复杂产品对象为 ImmutableSet

ImmutableSet 的内部类 ImmutableSet.Builder 如下所示

public static class Builder<E> extends ArrayBasedBuilder<E> {
    @CanIgnoreReturnValue
    public ImmutableSet.Builder<E> add(E... elements) {
        super.add(elements);
        return this;
    }

    @CanIgnoreReturnValue
    public ImmutableSet.Builder<E> addAll(Iterator<? extends E> elements) {
        super.addAll(elements);
        return this;
    }

    public ImmutableSet<E> build() {
        ImmutableSet<E> result = ImmutableSet.construct(this.size, this.contents);
        this.size = result.size();
        return result;
    }
    //...省略...
}

其中的 add、addAll等方法返回的是 ImmutableSet.Builder 对象本身，而 build 则返回 ImmutableSet 对象，所以 ImmutableSet.Builder 是具体建造者，add、addAll等方法则相当于buildPartX()，是装配过程中的一部分，build 方法则是 getResult()，返回最终创建好的复杂产品对象

ImmutableSet 使用示例如下:

public class Test2 {
    public static void main(String[] args) {
        Set<String> set = ImmutableSet.<String>builder().add("a").add("a").add("b").build();
        System.out.println(set);
        // [a, b]
    }
}

再来看一个，一般创建一个 guava缓存 的写法如下所示

final static Cache<Integer, String> cache = CacheBuilder.newBuilder()
        //设置cache的初始大小为10，要合理设置该值  
        .initialCapacity(10)
        //设置并发数为5，即同一时间最多只能有5个线程往cache执行写入操作  
        .concurrencyLevel(5)
        //设置cache中的数据在写入之后的存活时间为10秒  
        .expireAfterWrite(10, TimeUnit.SECONDS)
        //构建cache实例  
        .build();

这里很明显，我们不用看源码就可以知道这里是一个典型的建造者模式，CacheBuilder.newBuilder() 创建了一个具体建造者，.initialCapacity(10)、.concurrencyLevel(5)、.expireAfterWrite(10, TimeUnit.SECONDS) 则是构建过程，最终的 .build() 返回创建完成的复杂产品对象

看看源码是不是符合我们的猜测

public final class CacheBuilder<K, V> {
    // 创建一个具体建造者
    public static CacheBuilder<Object, Object> newBuilder() {
        return new CacheBuilder();
    }
    // 建造过程之一
    public CacheBuilder<K, V> initialCapacity(int initialCapacity) {
        Preconditions.checkState(this.initialCapacity == -1, "initial capacity was already set to %s", this.initialCapacity);
        Preconditions.checkArgument(initialCapacity >= 0);
        this.initialCapacity = initialCapacity;
        return this;
    }
    // 建造过程之一
    public CacheBuilder<K, V> concurrencyLevel(int concurrencyLevel) {
        Preconditions.checkState(this.concurrencyLevel == -1, "concurrency level was already set to %s", this.concurrencyLevel);
        Preconditions.checkArgument(concurrencyLevel > 0);
        this.concurrencyLevel = concurrencyLevel;
        return this;
    }
    // 建造过程之一
    public CacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) {
        Preconditions.checkState(this.expireAfterWriteNanos == -1L, "expireAfterWrite was already set to %s ns", this.expireAfterWriteNanos);
        Preconditions.checkArgument(duration >= 0L, "duration cannot be negative: %s %s", duration, unit);
        this.expireAfterWriteNanos = unit.toNanos(duration);
        return this;
    }
    // 建造完成，返回创建完的复杂产品对象
    public <K1 extends K, V1 extends V> Cache<K1, V1> build() {
        this.checkWeightWithWeigher();
        this.checkNonLoadingCache();
        return new LocalManualCache(this);
    }
    // ...省略...
}

很明显符合我们的猜测，initialCapacity()、concurrencyLevel()、expireAfterWrite() 等方法对传进来的参数进行处理和设置，返回 CacheBuilder 对象本身，build 则把 CacheBuilder 对象作为参数，new 了一个 LocalManualCache 对象返回

mybatis 中的建造者模式

我们来看 org.apache.ibatis.session 包下的 SqlSessionFactoryBuilder 类

SqlSessionFactoryBuilder的方法

里边很多重载的 build 方法，返回值都是 SqlSessionFactory，除了最后两个所有的 build 最后都调用下面这个 build 方法

    public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
            ErrorContext.instance().reset();
            try {
                reader.close();
            } catch (IOException var13) {
                ;
            }
        }
        return var5;
    }

其中最重要的是 XMLConfigBuilder 的 parse 方法，代码如下

public class XMLConfigBuilder extends BaseBuilder {
    public Configuration parse() {
        if (this.parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        } else {
            this.parsed = true;
            this.parseConfiguration(this.parser.evalNode("/configuration"));
            return this.configuration;
        }
    }
    
    private void parseConfiguration(XNode root) {
        try {
            Properties settings = this.settingsAsPropertiess(root.evalNode("settings"));
            this.propertiesElement(root.evalNode("properties"));
            this.loadCustomVfs(settings);
            this.typeAliasesElement(root.evalNode("typeAliases"));
            this.pluginElement(root.evalNode("plugins"));
            this.objectFactoryElement(root.evalNode("objectFactory"));
            this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
            this.settingsElement(settings);
            this.environmentsElement(root.evalNode("environments"));
            this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            this.typeHandlerElement(root.evalNode("typeHandlers"));
            this.mapperElement(root.evalNode("mappers"));
        } catch (Exception var3) {
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
        }
    }
    // ...省略...
}

parse 方法最终要返回一个 Configuration 对象，构建 Configuration 对象的建造过程都在 parseConfiguration 方法中，这也就是 Mybatis 解析 XML配置文件 来构建 Configuration 对象的主要过程

所以 XMLConfigBuilder 是建造者 SqlSessionFactoryBuilder 中的建造者，复杂产品对象分别是 SqlSessionFactory 和 Configuration

后记

欢迎评论、转发、分享，您的支持是我最大的动力

更多内容可访问我的个人博客：http://laijianfeng.org

关注【小旋锋】微信公众号，及时接收博文推送

关注_小旋锋_微信公众号

设计模式 | 建造者模式及典型应用

建造者模式

角色

示例

建造者模式总结

建造者模式的典型应用和源码分析

java.lang.StringBuilder 中的建造者模式

java.lang.StringBuffer 中的建造者方法

Google Guava 中的建造者模式

mybatis 中的建造者模式

后记

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

设计模式