04 设计模式之生成器模式

我是陈皮，一个在互联网 Coding 的 ITer，微信搜索「陈皮的JavaLib」第一时间阅读最新文章，回复【资料】，即可获得我精心整理的技术资料，电子书籍，一线大厂面试资料和优秀简历模板。

1 背景

我们知道，构建一辆汽车是极其复杂，部件繁多的。假设我们现在需要构建一辆汽车，为方便演示，我们假设构建一辆汽车只需要发动机，车轮，方向盘。那如何去构建一辆汽车呢？假设构建一辆车的顺序为安装发动机，安装车轮，安装方向盘。

首先，需要定义三个部件（发动机，车轮，方向盘），将它们定义为单独的类。

package com.chenpi.builder; /** * @Description 发动机 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class Engine { // 品牌 private String brand; public Engine(String brand) { this.brand = brand; } public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } }

package com.chenpi.builder; /** * @Description 车轮 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class Wheel { // 车轮类型 private String type; public Wheel(String type) { this.type = type; } public String getType() { return type; } public void setType(String type) { this.type = type; } }

package com.chenpi.builder; /** * @Description 方向盘 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class SteeringWheel { // 方向盘颜色 private String color; public SteeringWheel(String color) { this.color = color; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } }

然后定义汽车类，并且由以上三种部件组成。

package com.chenpi.builder; /** * @Description 汽车 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class Car { // 发动机 private Engine engine; // 方向盘 private SteeringWheel steeringWheel; // 车轮 private Wheel wheel; public Car(Engine engine, SteeringWheel steeringWheel, Wheel wheel) { this.engine = engine; this.steeringWheel = steeringWheel; this.wheel = wheel; } // 省略 getter / setter 方法 }

最后客户端负责生产各个汽车组件，并组装构建一辆汽车。

package com.chenpi.builder; /** * @Description 客户端 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class ChenPiClient { public static void main(String[] args) { Engine engine = new Engine("沃尔沃"); Wheel wheel = new Wheel("175/70R"); SteeringWheel steeringWheel = new SteeringWheel("Black"); Car car = new Car(engine, steeringWheel, wheel); System.out.println(car); } } // 输出结果如下 Car{engine=Engine{brand='沃尔沃'}, steeringWheel=SteeringWheel{color='Red'}, wheel=Wheel{type='175/70R'}}

此时，如果我们需要创建另外一种类型的汽车，那我们就需要重写客户端代码，再进行生产，组装构建一辆新汽车。

Engine engine = new Engine("蔚来"); Wheel wheel = new Wheel("255/55 R19"); SteeringWheel steeringWheel = new SteeringWheel("Black"); Car car = new Car(engine, steeringWheel, wheel);

你会发现客户端不仅要清楚整辆汽车的外观表示，还需要清楚汽车组件的装配细节，然后按顺序组装构建汽车对象，这对客户端的使用是不友好的，使用比较麻烦。而且这演示的只是简单的几个属性的赋值，如果对象属性比较多，构建过程复杂就更不用说了。

对于客户端来说，它不应该知道汽车内部在装配细节，它就只想要一辆完整的汽车来使用。

2 生成器模式（Builder Pattern）

生成器模式（也叫建造者模式）是一种创建型设计模式，它将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

即有些对象的创建流程是一样的，但是创建出来的对象一些自身特性可以是不一样的，所以需要将对象的表示（外观）和对象具体的构建分开来。

生成器模式把对象的构建步骤抽象成生成器（builder），指导类（director）对所有生成步骤的先后顺序进行控制。客户端使用指导类并传入相应的生成器，通过指导类的接口便可以得到相应的对象。

Builder：生成器接口，定义了创建一个 Product 对象所需的各个部件的操作，以及获取产品的方法。

ConcreteBuilder：生成器接口具体实现类，实现各个部件的创建并负责组装，并返回构建好的产品对象。

Director：指导者，使用 Builder 接口，以一个统一的过程来构建所需要的 Product 对象。

Product：产品，被生成器构建的复杂对象，包含多个部件。

现在我们使用生成器模式改写开头的例子，我们首先需要定义一个生成器接口。

package com.chenpi.builder; /** * @Description 汽车生成器接口 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public interface CarBuilder { Car builder(); void buildEngine(); void buildWheel(); void buildSteeringWheel(); }

假设我们现在需要沃尔沃的汽车，那么就定义一个沃尔沃的生成器接口实现类。

package com.chenpi.builder; /** * @Description 沃尔沃汽车生成器 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class VolvoCarBuilder implements CarBuilder { private Car car = new Car(); @Override public Car builder() { return car; } @Override public void buildEngine() { car.setEngine(new Engine("沃尔沃")); } @Override public void buildWheel() { car.setWheel(new Wheel("175/70R")); } @Override public void buildSteeringWheel() { car.setSteeringWheel(new SteeringWheel("Black")); } }

再定义汽车指导者，负责指导汽车产品的构建。

package com.chenpi.builder; /** * @Description 汽车指导者 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class CarDirector { private CarBuilder builder; public CarDirector(CarBuilder builder) { this.builder = builder; } public void buildCar() { builder.buildEngine(); builder.buildWheel(); builder.buildSteeringWheel(); } public Car getCar() { return builder.builder(); } }

最后，客户端就选择特定的生成器实现类对象，传递给指导类对象，让它生产我们需要的产品对象即可。

package com.chenpi.builder; /** * @Description 客户端 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class ChenPiClient { public static void main(String[] args) { CarDirector director = new CarDirector(new VolvoCarBuilder()); director.buildCar(); Car car = director.getCar(); System.out.println(car); } } // 输出结果如下 Car{engine=Engine{brand='沃尔沃'}, steeringWheel=SteeringWheel{color='Black'}, wheel=Wheel{type='175/70R'}}

3 生成器模式简化版

生成器模式的主要功能是构建复杂的产品，而且是细化的、分步骤的构建产品，也就是生成器模式重在一步一步解决构造复杂对象的问题。

你是否发现上述的生成器模式会比较复杂，定义太多的接口和类等。其实实际使用中会根据情况进行调整。例如上述的生成器对象和被构建的对象是分开的，那其实客户端可以直接使用 new 被构建对象的方式来创建产品对象，这样就导致生成器模式荒废了，所以我们可以将生成器对象合并到被构建的对象中去，称为它的一个内部类。

而且我们也可以不再需要指导类，直接让客户端使用生成器对象进行构建最终产品。

假设我们现在需要一个 Mongo 客户端参数选项对象，来进行 Mongo 客户端的配置，那我们就可以定义一个客户端参选选项类，存放各种参数，并且将生成器定义为它的内部类，用来构建 Mongo 客户端参数选项对象。

实际开发中，Mongo 客户端配置参数是很多的，可达十几二十多个，为方便演示，我们只定义几个。这些参数值通过生成器来进行配置构建，并对参数合理值进行校验。

而且我们将 MongoClientOptions 类的构造方法定义为私有的，所以外部只能通过生成器来构建 MongoClientOptions 对象。

package com.chenpi.builder.mongo; /** * @Description mongo客户端参数选项 * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class MongoClientOptions { private final int maxWaitTime; private final int maxConnectionIdleTime; private final int maxConnectionLifeTime; private final int connectTimeout; private final int socketTimeout; private MongoClientOptions(final Builder builder) { maxWaitTime = builder.maxWaitTime; maxConnectionIdleTime = builder.maxConnectionIdleTime; maxConnectionLifeTime = builder.maxConnectionLifeTime; connectTimeout = builder.connectTimeout; socketTimeout = builder.socketTimeout; } // 创建一个生成器对象 public static Builder builder() { return new Builder(); } public static class Builder { private int maxWaitTime = 1000 * 60 * 2; private int maxConnectionIdleTime = 0; private int maxConnectionLifeTime = 0; private int connectTimeout = 1000 * 10; private int socketTimeout = 0; public Builder maxWaitTime(final int maxWaitTime) { this.maxWaitTime = maxWaitTime; return this; } public Builder maxConnectionIdleTime(final int maxConnectionIdleTime) { this.maxConnectionIdleTime = maxConnectionIdleTime; return this; } public Builder maxConnectionLifeTime(final int maxConnectionLifeTime) { this.maxConnectionLifeTime = maxConnectionLifeTime; return this; } public Builder connectTimeout(final int connectTimeout) { if (connectTimeout < 0) { throw new RuntimeException("connectTimeout must be >= 0"); } this.connectTimeout = connectTimeout; return this; } public Builder socketTimeout(final int socketTimeout) { this.socketTimeout = socketTimeout; return this; } // 构建一个最终的mongo客户端选项对象 public MongoClientOptions build() { return new MongoClientOptions(this); } } }

接下来，我们演示如何使用生成器来构建一个 MongoClientOptions 对象。使用链式编程的方式，很简单轻松的就构建出我们需要的对象了。

package com.chenpi.builder.mongo; /** * @Description * @Author 陈皮 * @Date 2021/8/8 * @Version 1.0 */ public class ChenPiClient { public static void main(String[] args) { MongoClientOptions mongoClientOptions = MongoClientOptions.builder().connectTimeout(1000) .maxConnectionIdleTime(60000) .maxConnectionLifeTime(600000).maxWaitTime(1000).socketTimeout(5000).build(); } }

本次分享到此结束啦~~

如果觉得文章对你有帮助，、、关注、评论，您的支持就是我创作最大的动力！

Java

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。