定义
将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。细化、分步骤的构建复杂的产品。
它存在着两个部分，一个部分是部件构造和产品装配，另一个部分是整体构建的算法。在生成器模式中，强调的是固定整体的构建的算法，而灵活扩展和切换部件的具体构造和产品装配的方式。
本质
分离整体构建算法和部件构造
登场角色
-
Builder（建造者）
抽象类，定义了生成实例会用到的所有的方法。
-
ConcreteBuilder（具体的构建者）
实现了生层实例会用到的所有的方法。
-
Director（监工）
指导者，用来使用Builder接口，以一个统一的过程来构建所需要的对象。
-
Client（使用者）
使用Builder接口。
示例代码
/**
* 建造者抽象类，用于定义生成对象所需要的所有的方法
*/
public abstract class Builder{
public abstract void makeTitle(String title);
public abstract void makeString(String string);
public abstract void makeItems(String item);
public abstract void close();
}
/**
* 指导者，用于使用Builder接口并基于统一的过程生成实例
*/
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
/**
* 定义的生成对象的统一的过程
*/
public void construct(){
builder.makeTitle("Greeting");
builder.makeString("从早上到晚上");
builder.makeTitle("早上好");
builder.makeString("晚上");
builder.makeItems("晚上好");
builder.close();
}
}
/**
* 具体的构建者1
*/
public class HtmlBuidler extends Builder{
private StringBuffer stringBuffer = new StringBuffer();
@Override
public void makeTitle(String title) {
stringBuffer.append("<body>\r\n");
stringBuffer.append("<title>" + title + "</title>\r\n");
}
@Override
public void makeString(String string) {
stringBuffer.append("<p>" + string + "</p>\r\n");
}
@Override
public void makeItems(String item) {
stringBuffer.append("<ul><li>" + item + "</li></ul>\r\n");
}
public StringBuffer getStringBuffer() {
return stringBuffer;
}
@Override
public void close() {
stringBuffer.append("</body>\r\n");
}
}
/**
* 具体的构建者2
*/
public class TextBuilder extends Builder{
private StringBuffer stringBuffer = new StringBuffer("");
@Override
public void makeTitle(String title) {
stringBuffer.append("================");
stringBuffer.append("[" + title + "]");
stringBuffer.append("\r\n");
}
@Override
public void makeString(String string) {
stringBuffer.append("#####" + string + "\r\n");
}
@Override
public void makeItems(String item) {
stringBuffer.append("@@@ " + item + "\r\n");
}
@Override
public void close() {
stringBuffer.append("================");
}
public StringBuffer getStringBuffer() {
return stringBuffer;
}
}
/**
* 使用者
*/
public class Client {
public static void main(String[] args){
TextBuilder textBuilder = new TextBuilder();
Director director = new Director(textBuilder);
director.construct();
StringBuffer stringBuffer = textBuilder.getStringBuffer();
System.out.println("this is the textBuilder");
System.out.println(stringBuffer);
HtmlBuidler htmlBuidler = new HtmlBuidler();
director = new Director(htmlBuidler);
director.construct();
stringBuffer = htmlBuidler.getStringBuffer();
System.out.println("this is the htmlBuilder");
System.out.println(stringBuffer);
}
}
运行结果
this is the textBuilder
================[Greeting]
#####从早上到晚上
================[早上好]
#####晚上
@@@ 晚上好
================
this is the htmlBuilder
<body>
<title>Greeting</title>
<p>从早上到晚上</p>
<body>
<title>早上好</title>
<p>晚上</p>
<ul><li>晚上好</li></ul>
</body>
功能
生成器模式的功能主要是构建复杂的产品，而且是细化的、分步骤的构建产品，生成器模式重在一步一步的解决构建复杂对象的问题，更为重要的是，这个构建的过程是统一的、固定不变的，变化的部分放到生成器部分了，只要配置不同的生成器，那么同样的构建过程，就能构建出不同的产品来。
优点
- 松散耦合。可以用同一个构建算法构建出表现出完全不同的产品，实现产品的构建和产品表现上的分离。生成器模式正是把产品构建的过程独立出来，是它和具体产品的表现松散耦合，从而使得构建算法可以复用，而具体产品表现也可以灵活地、方便地扩展和切换。
- 可以很容易的改变产品的内部表示。在生成器模式中，由于Builder对象只是提供给Director使用，那么具体的部件创建和装配方式是被Builder接口隐藏了的，Director并不知道具体的实现细节，这样一来，想要改变产品的内部表示，只需要切换Builder的具体表示即可。
- 更好的复用性。生成器模式很好的实现了构建算法和具体产品实现的分离，这样一来，使得构建算法可以复用，同样的道理，具体产品的实现也可以复用，同一个产品实现，可以配合不同的构建算法使用。
生成器模式和模板方法模式
在功能上比较相似，模板方法模式时固定算法框架，把算法中的某些步骤延迟到子类中实现。在生成器模式中，Director定义整体的构建算法，把算法中涉及到具体部件对象的创建和装配过程委托给具体的Builder实现。所以实质上两个模式很相似，都是固定算法框架，然后把算法中的某些具体步骤交给其他类来实现，都能实现整体算法和某些具体步骤的实现的分离。
但是两个模式也有很大的区别。首先是模式的目的，生成器模式是用来构建复杂的对象，而模板方法模式是用来固定算法的框架的，侧重点不同。其次是使用的复杂度上，生成器模式需要组合Director和Builder对象，然后才能开始构建，要等构建完成后，才能获得最终的对象，而模板方法模式就没有这么麻烦，直接使用子类对象即可。
网友评论