和 lvgo 一起学设计模式（五）创建型之建造者模式_综合

build

建造者模式 ?

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

根据建造者模式的定义，我们可以先简单的了解一下建造者模式要解决的问题，它是指将一个复杂对象的构建与它的表示分离，这句话的意思是指一个对象的构建过程与表示不再绝对。即一个构建过程对应多个结果，这取决于客户端如果指挥构建者进行对象的构建。这里的构建者就是我们接下来要讲的建造者模式内容。

理解程序中的建造 ?

对于建造这个词语没什么好说的，在软件程序中建造是什么呢？我相信看到下面这个例子你应该就已经掌握了什么是建造者模式，当然这还不够，让我们慢慢来。

JDK 中的 StringBuilder

public class StringBuilderTest {
    @Testvoid test(){
    StringBuilder stringBuilder = new StringBuilder();stringBuilder.append(1).append("个张三，和").append(4).append("个李四");System.out.println(stringBuilder.toString());}
}

1个张三，和4个李四
Process finished with exit code 0

上面的例子是妇孺皆知的 JDK 中提供的一个为了解决复杂 String 对象的 String 对象生成器。它还有个孪生姐夫StringBuffer用在并发环境下。

Netty 中的 ServerBootstrap

再比如这个，netty 的启动器

        ServerBootstrap bootstrap = new ServerBootstrap();bootstrap.group(parentGroup, childGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 128).childHandler(new NettyProtobufChannelInitializer());try {
    ChannelFuture sync = bootstrap.bind(2333).sync();sync.channel().closeFuture().sync();} catch (InterruptedException e) {
    e.printStackTrace();}

通过建造者 ServerBootstrap 来完成一个启动器的构建，同一个构造过程，却有着千差万别的结果。

lvgo 的 Slient 并发任务处理器

如果建造者被我们自己应用的话，我个人将它使用到了程序插拔配置上了，就像 netty 的启动器一样。

        new TaskHandler<String>(testData) {
    @Overridepublic void run(String s) {
    try {
    Thread.sleep(1000L);} catch (InterruptedException e) {
    e.printStackTrace();}log.info("第" + s + "个任务" + Thread.currentThread());}}.sync(false).overRun(() -> {
    log.debug("我所有的任务执行结束了");}).execute(10);

上面我写的这个组件已发布到 maven 仓库，源码仓库：https://github.com/lvgocc/silent

<dependency><groupId>org.lvgo</groupId><artifactId>silent</artifactId><version>1.0</version>
</dependency>

通过上面的几个例子我们大概知道什么是建造者模式了，它可以通过同一个构造过程来创建出不同的表示对象，比如

StringBuilder 通过不同的参数传入 append 方法，得到结果是不一样的；
ServerBootstrap 的不同参数设置，启动出来的 netty 服务端有着不同作用；
TaskHandler 通过指定不同的参数，可以使任务的执行效果产生不同的变化；

建造者模式类图 ?

注：在 GOF 的原著中对建造模式的理解与本篇差别较大。所以类图看起来会和很多资料中有所差异，望读者知悉。

build-UML

GOF 中定义的建造者类图

gof-build-UML

这里说明一下，GOF 的建造者模式中体现的是将要构建的对象、构建者、具体构建者、指挥者4部分独立开来，可以做很好的水平扩展。而 lvgo 将建造者的抽象类与具体的构建者合成一个，通过参数的方式将具体的构建者体现出来。将指挥者的角色延迟到了客户端，直接由客户端 client 来代替 Director 的工作。

代码 ?

避免篇幅过长，完整代码及单元测试结果点击查看 https://github.com/lvgocc/java-design-patterns/tree/main/build

为了能够更好的去理解 lvgo 与 GOF 中类图的差异，这里准备了两种写法，以诠释上面的说明。

GOF 类图的实现

public abstract class Builder {
    protected PlayerRole playerRole = new PlayerRole();abstract void setHairColor();abstract void setShape();abstract void setSkinColour();PlayerRole build() {
    return playerRole;}
}

public class Director {
    private final Builder builder;public Director(Builder builder) {
    this.builder = builder;}public PlayerRole construct() {
    builder.setHairColor();builder.setShape();builder.setSkinColour();return builder.build();}public PlayerRole construct2() {
    builder.setHairColor();return builder.build();}public PlayerRole construct3() {
    builder.setSkinColour();return builder.build();}
}

public class PlayerRoleBuilder extends Builder {
    @Overridevoid setHairColor() {
    playerRole.setHairColor("褐色");}@Overridevoid setShape() {
    playerRole.setShape("健硕");}@Overridevoid setSkinColour() {
    playerRole.setSkinColour("古铜色");}
}

public class PlayerRole {
    private String hairColor;private String shape;private String skinColour;
}

测试类

    void build() {
    Builder playerRoleBuilder = new PlayerRoleBuilder();Director playerRoleBuildDirector = new Director(playerRoleBuilder);PlayerRole construct = playerRoleBuildDirector.construct();}

结果

construct = PlayerRole{
    hairColor='褐色', shape='健硕', skinColour='古铜色'}

个人觉得这种写法稍为复杂，不过他的水平扩展性和隔离性都比较好。

lvgo 整理的写法如下

public class PlayerRole {
    private String hairColor;private String shape;private String skinColour;
}

public class PlayerRoleBuilder {
    private final PlayerRole playerRole = new PlayerRole();PlayerRoleBuilder hairColor(String color) {
    playerRole.setHairColor(color);return this;}PlayerRoleBuilder shape(String shape) {
    playerRole.setShape(shape);return this;}PlayerRoleBuilder skinColour(String skinColour) {
    playerRole.setSkinColour(skinColour);return this;}PlayerRole build() {
    return playerRole;}
}

测试

    @Testvoid test(){
    PlayerRoleBuilder playerRoleBuilder = new PlayerRoleBuilder();playerRoleBuilder.hairColor("红色").shape("健硕").skinColour("古铜色");PlayerRole build = playerRoleBuilder.build();System.out.println("build = " + build);}

结果

build = PlayerRole{
    hairColor='红色', shape='健硕', skinColour='古铜色'}

总结 ???

相同的资源，不同的结果是我对建造者模式创建对象的理解。就像建造我们的人生，提供了相同的世界，相同的空气，每个个体的表现均不同。

通过使用建造者模式，我们可以更加灵活的去处理一个构建过程复杂的对象。将它的构建过程与表示分离开。例如如果你正在为一长串的 set 方法苦恼的时候可以考虑一下建造者模式。它使代码更整洁，可读性更好。

xxx.setA();
xxx.setB();
xxx.setC();
xxx.setD();
xxx.setE();

xxx.A().B().C().D().E().build();

当你想要给一个对象组装一个特有的结果的时候，不妨试试 GOF 的思路，很不错的。

缺点：

建造者模式因为需要维护一个单独的建造者类，同时要为每个属性单独维护一个方法，当类中有属性调整的时候，要一起调整对应建造者中的方法，这也是随它的优势而带来的一些副作用。但如果有需要它的地方尽管去用。没有什么比混沌的代码更糟糕的事情了。

案例应用

这里为了应读者要求，想有对应的案例可以参考，不然不清楚设计模式到底在什么地方用。

餐饮系统有23道素材、18道荤菜，老板今天推出 8 种 2素 1 荤套餐，你如何实现？
试想一下在我的世界（mc）中，提供了各种不同的道具，相同的道具组合，你做出来的房子和我做出来的房子看起来不那么一样。
在塔防类游戏中，同一个射手，每次攒钱给他升级，最终有的变成了单体攻击高的神射手，有的变成散射群里攻击低的散箭手。

返璞归真

我认为学习设计模式的过程就像拿到一台游戏机，玩到最后，我都会拆开看看里面是什么，而早已不关心游戏好不好玩了。

知识也是一样，知其然而知其所以然。

我们为了学会使用某种东西看他的操作手册就可以了；

我们如果想要学会修某种东西就需要看他的设计手册；

当我们想要创造某种东西，你就需要掌握很多很多设计手册，将他们的经验进行吸收、消化、提炼。才能有更好的结果。

当然，如果你只想会用，有一份差不多的操作指南也就够了。

抱歉这一篇说了一些题外话。

写在最后

Java 设计模式专题，共23 种设计模式。内容来自个人学习理解消化的结果，谈不上教程，只望记录于此同你分享。希望能够和大家一起进步、成长。为了梦想，学习技术。如果你觉得文章对你有帮助，希望随便点赞、关注、分享、给个 star 支持一下。感激涕零?。

?https://github.com/lvgocc/java-design-patterns

星尘的一个朋友 亦或繁星、亦或尘埃。星尘，为了梦想，学习技术。

关注公众号，回复“加群”，和 lvgo 一起学习设计模式。坚决维护群内环境，给大家提供一个良好的学习交流环境。

星尘的一个朋友