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

时间  2020-12-22
标签 java sql 数据库 apache 编程 设计模式 缓存 安全 bash 微信 栏目 Java 繁體版
原文   原文链接

建造者模式

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

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

角色

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

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

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
}

抽象建造者 builderbash

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());
    }
}
示例.建造者模式类图

建造者模式总结

建造者模式的主要优势以下：

  • 在建造者模式中，客户端没必要知道产品内部组成的细节，将产品自己与产品的建立过程解耦，使得相同的建立过程能够建立不一样的产品对象。

  • 每个具体建造者都相对独立，而与其余的具体建造者无关，所以能够很方便地替换具体建造者或增长新的具体建造者，用户使用不一样的具体建造者便可获得不一样的产品对象。因为指挥者类针对抽象建造者编程，增长新的具体建造者无须修改原有类库的代码，系统扩展方便，符合 "开闭原则"。

  • 能够更加精细地控制产品的建立过程。将复杂产品的建立步骤分解在不一样的方法中，使得建立过程更加清晰，也更方便使用程序来控制建立过程。

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

  • 建造者模式所建立的产品通常具备较多的共同点，其组成部分类似，若是产品之间的差别性很大，例如不少组成部分都不相同，不适合使用建造者模式，所以其使用范围受到必定的限制。

  • 若是产品的内部变化复杂，可能会致使须要定义不少具体建造者类来实现这种变化，致使系统变得很庞大，增长系统的理解难度和运行成本。

适用场景：

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

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

  • 对象的建立过程独立于建立该对象的类。在建造者模式中经过引入了指挥者类，将建立过程封装在指挥者类中，而不在建造者类和客户类中。

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

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

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版  
慕课网java设计模式精讲 Debug 方式+内存分析


本文分享自微信公众号 - 小旋锋（whirlysBigData）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程