生成器模式

转载自：https://www.jianshu.com/p/f4248525e2d1

生成器模式的核心是 **当构建生成一个对象的时候，需要包含多个步骤，虽然每个步骤具体的实现不同，但是都遵循一定的流程与规则 **

建造者模式也属于创建型模式，它提供了一种创建对象的最佳方式

定义：将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的对象

主要作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。用户只需要给出指定复杂对象的类型和内容,建造者模式负责按顺序创建复杂对象(把内部的建造过程和细节隐藏起来)

在这里插入图片描述

举个例子，我们如果构建生成一台电脑，那么我们可能需要这么几个步骤

需要一个主机
需要一个显示器
需要一个键盘
需要一个鼠标
需要音响等

虽然我们具体在构建一台主机的时候，每个对象的实际步骤是不一样的，比如，有的对象构建了i7cpu的主机，有的对象构建了i5cpu的主机，有的对象构建了普通键盘，有的对象构建了机械键盘等。
但不管怎样，你总是需要经过一个步骤就是构建一台主机，一台键盘。
对于这个例子，我们就可以使用生成器模式来生成一台电脑，他需要通过多个步骤来生成。

所以，我们可以将生成器模式理解为，假设我们有一个对象需要建立，这个对象是由多个组件（Component）组合而成，每个组件的建立都比较复杂，但运用组件来建立所需的对象非常简单，所以我们就可以将构建复杂组件的步骤与运用组件构建对象分离，使用builder模式可以建立。

生成器模式的类图如下：

实现

下面我们就根据这个例子来实现一个生成器模式，生成一台电脑

首先我们需要一个电脑类：

package Builder;public class Computer {public String master;public String screen;public String keyboard;public String mouse;public String audio;public void setMaster(String master) {this.master = master;}public void setScreen(String screen) {this.screen = screen;}public void setKeyboard(String keyboard) {this.keyboard = keyboard;}public void setMouse(String mouse) {this.mouse = mouse;}public void setAudio(String audio) {this.audio = audio;}
}

然后我们建立一个抽象的builder类：

package Builder;public abstract class ComputerBuilder {protected Computer computer;public Computer getComputer() {return computer;}public void buildComputer() {computer = new Computer();System.out.println("生成了一台电脑！！！");}public abstract void buildMaster();public abstract void buildScreen();public abstract void buildKeyboard();public abstract void buildMouse();public abstract void buildAudio();
}

然后我们实现两个具体的builder类，分别是惠普电脑的builder和戴尔电脑的builder

package Builder;public class HPComputerBuilder extends ComputerBuilder {@Overridepublic void buildMaster() {// TODO Auto-generated method stubcomputer.setMaster("i7,16g,512SSD,1060");System.out.println("(i7,16g,512SSD,1060)的惠普主机");}@Overridepublic void buildScreen() {// TODO Auto-generated method stubcomputer.setScreen("1080p");System.out.println("(1080p)的惠普显示屏");}@Overridepublic void buildKeyboard() {// TODO Auto-generated method stubcomputer.setKeyboard("cherry 青轴机械键盘");System.out.println("(cherry 青轴机械键盘)的键盘");}@Overridepublic void buildMouse() {// TODO Auto-generated method stubcomputer.setMouse("MI 鼠标");System.out.println("(MI 鼠标)的鼠标");}@Overridepublic void buildAudio() {// TODO Auto-generated method stubcomputer.setAudio("飞利浦 音响");System.out.println("(飞利浦 音响)的音响");}
}

package Builder;public class DELLComputerBuilder extends ComputerBuilder {@Overridepublic void buildMaster() {// TODO Auto-generated method stubcomputer.setMaster("i7,32g,1TSSD,1060");System.out.println("(i7,32g,1TSSD,1060)的戴尔主机");}@Overridepublic void buildScreen() {// TODO Auto-generated method stubcomputer.setScreen("4k");System.out.println("(4k)的dell显示屏");}@Overridepublic void buildKeyboard() {// TODO Auto-generated method stubcomputer.setKeyboard("cherry 黑轴机械键盘");System.out.println("(cherry 黑轴机械键盘)的键盘");}@Overridepublic void buildMouse() {// TODO Auto-generated method stubcomputer.setMouse("MI 鼠标");System.out.println("(MI 鼠标)的鼠标");}@Overridepublic void buildAudio() {// TODO Auto-generated method stubcomputer.setAudio("飞利浦 音响");System.out.println("(飞利浦 音响)的音响");}}

然后我们实现一个director类：

package Builder;public class Director {private ComputerBuilder computerBuilder;public void setComputerBuilder(ComputerBuilder computerBuilder) {this.computerBuilder = computerBuilder;}public Computer getComputer() {return computerBuilder.getComputer();}public void constructComputer() {computerBuilder.buildComputer();computerBuilder.buildMaster();computerBuilder.buildScreen();computerBuilder.buildKeyboard();computerBuilder.buildMouse();computerBuilder.buildAudio();}}

最后我们测试一下代码：

package Builder;public class ComputerCustomer {public static void main(String[] args) {// TODO Auto-generated method stubDirector director = new Director();ComputerBuilder hp = new HPComputerBuilder();director.setComputerBuilder(hp);director.constructComputer();//get the pcComputer pc = director.getComputer();}
}

生成器模式的优缺点

建造者模式优点：

产品的建造和表示分离，实现了解耦。使用建造者模式可以使客户端不必知道产品内部组成的细节
将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
具体的建造者类之间是相互独立的，这有利于系统的扩展。增加新的具体建造者无需修改原有类库的代码，符合“开闭原则”

建造者模式缺点：

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

应用场景:

需要生成的产品对象有复杂的内部结构，这些产品对象具备共性;
隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
适合于一个具有较多属性的类的创建过程。

生成器模式的实际应用

Builder pattern has been used in a lot of libraries. However, there is a common mistake here. Consider the following example of StringBuilder which is a class from Java standard library. Does it utilize the Builder pattern?

生成器模式在许多类库中都使用了。但是严格来说，却有些错误。
比如这个例子，我们考虑java标准库中的StringBuilder类，它使用了生成器模式么？

StringBuilder strBuilder= new StringBuilder();
strBuilder.append("one");
strBuilder.append("two");
strBuilder.append("three");
String str= strBuilder.toString();

在标准库中，StringBuilder继承自AbstractStringBuilder
append方法是这个生成过程中的一步，就像我们构建电脑时，先构建主机这样的步骤一样。
toString方法也是生成过程中的一步，而且是构建过程中的最后一步。然而，这里的不同是没有director，所以严格来说这不是一个标准的生成器模式。我们程序的调用者好像就是director可以生成我们自己的String。

生成器模式与工厂模式的不同

与抽象工厂模式相比,建造者模式返回-个组装好的完整产品，而抽象工厂模式返回一系列相关的产品（某个厂商生产的手机、路由器），这些产品位于不同的产品等级结构，构成了一个产品族（例如小米生态中的各种产品）
在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象；而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象
如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车

生成器模式的特殊用法

该示例是Builder模式的常规用法，导演类 Director 在 Builder 模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制构建产品的先后次序，并向调用者返回完整的产品类，但是如果要自定义创建一个连接池的时候，我们需要再自定义一个 Worker 类，再通过 Director 去构建，非常麻烦，有些情况下需要简化系统结构，可以把Director和抽象建造者进行结合。

写一个 Demo2，把 Director 的权利交给用户，让用户自己按照需求构建

ConnectionPool 类，在 demo1 基础上赋予了初始值：

public class ConnectionPool {private Integer maxConnNum = 20; //最大连接数量private Integer minConnNum = 1; //最小连接数量private Integer initialSize = 5; //初始化连接数量private Long maxAliveTime = 10000L; //连接存活时间// 四个属性的 get、set 方法，这里省略...@Overridepublic String toString() {...}
}

Builder 抽象类，在 demo1 基础上修改方法返回值为自身，方法需传入参数：

public abstract class Builder {abstract Builder settingMaxConnNum(Integer maxConnNum);abstract Builder settingMinConnNum(Integer minConnNum);abstract Builder settingInitialSize(Integer initialSize);abstract Builder settinMaxAliveTime(Long maxAliveTime);abstract ConnectionPool getConnectionPool();}

Worker 类：

public class Worker extends Builder{private ConnectionPool pool;public Worker(){pool = new ConnectionPool();}@OverrideBuilder settingMaxConnNum(Integer maxConnNum) {pool.setMaxConnNum(maxConnNum);return this;}@OverrideBuilder settingMinConnNum(Integer minConnNum) {pool.setMinConnNum(minConnNum);return this;}@OverrideBuilder settingInitialSize(Integer initialSize) {pool.setInitialSize(initialSize);return this;}@OverrideBuilder settinMaxAliveTime(Long maxAliveTime) {pool.setMaxAliveTime(maxAliveTime);return this;}@OverrideConnectionPool getConnectionPool() {return pool;}
}

测试类与结果：

public class Test {public static void main(String[] args) {//初始化一个连接池Worker worker = new Worker();ConnectionPool pool1 = worker.getConnectionPool();System.out.println(pool1);//初始化一个自定义的连接池ConnectionPool pool2 = worker.settingMaxConnNum(30).settingMinConnNum(5).settingInitialSize(10).settinMaxAliveTime(20000L).getConnectionPool();System.out.println(pool2);}
}