共计 3268 个字符，预计需要花费 9 分钟才能阅读完成。
| 导读 | Builder 模式是代码编写过程中经常会用到的一类设计模式。目的是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 |
今天我们讨论一下 Builder 建造者模式，这个 Builder，其实和模板模式非常的像，但是也有区别，那就是在模板模式中父类对子类中的实现进行操作，在父类之中进行一件事情的处理，但是在 Builder 模式之中，父类和子类都不用关心怎么处理，而是用另一个类来完成对这些方法的有机组合，这个类的职责就是监工，规定了到底要怎么样有机的组合这些方法。在监工类（Director）中，将父类组合进去，然后调用父类的操作来抽象的实现一件事情，这就是面向接口（抽象）变成的妙处了，当然这个 Builder 可以使接口也可以是抽象类，在这里我们使用抽象类。
| Builder.java | |
| public abstract class Builder {public abstract void makeString(String str); | |
| public abstract void makeTitle(String title); | |
| public abstract void makeItems(String[] items); | |
| public abstract void close();} |
HtmlBuilder.java
| import java.io.FileWriter; | |
| import java.io.IOException; | |
| import java.io.PrintWriter; | |
| public class HtmlBuilder extends Builder { | |
| private String filename; | |
| private PrintWriter pw; | |
| public void makeTitle(String title) { | |
| filename="D:\\"+title+".html"; | |
| try { | |
| pw=new PrintWriter(new FileWriter(filename)); | |
| } catch (IOException e) { | |
| e.printStackTrace(); | |
| } | |
| pw.println("<html><head><title>"+title+"</title></head><body>"); | |
| pw.println("<h1>"+title+"</h1>"); | |
| } | |
| public void makeString(String str) { | |
| pw.println("<p>"+str+"</p>"); | |
| } | |
| public void makeItems(String[] items) { | |
| pw.println("<ul>"); | |
| for(int i=0;i<items.length;i++){ | |
| pw.println("<li>"+items[i]+"</li>"); | |
| } | |
| pw.println("</ul>"); | |
| } | |
| public void close() { | |
| pw.println("</body></html>"); | |
| pw.close(); | |
| } | |
| public String getResult(){ | |
| return filename; | |
| } | |
| } |
TextBuilder.java
| public class TextBuilder extends Builder { | |
| StringBuffer sb=new StringBuffer(); | |
| public void makeTitle(String title) { | |
| sb.append("====================="); | |
| sb.append("["+title+"]"+"\n"); | |
| } | |
| public void makeString(String str) { | |
| sb.append("@"+str+"\n"); | |
| } | |
| public void makeItems(String[] items) { | |
| for(int i=0;i<items.length;i++){ | |
| sb.append(" ."+items[i]+"\n"); | |
| } | |
| } | |
| public void close() { | |
| sb.append("====================="); | |
| } | |
| public String getResult(){ | |
| return sb.toString(); | |
| } | |
| } |
Director.java
| public class Director { | |
| private Builder builder; | |
| public Director(Builder builder){ | |
| this.builder=builder; | |
| } | |
| public void construct(){ | |
| String [] items1=new String[]{"奏国歌 "," 升国旗"}; | |
| String [] items2=new String[]{"观众鼓掌 "," 有序撤离"}; | |
| builder.makeTitle("今日头条"); | |
| builder.makeString("毕业典礼"); | |
| builder.makeItems(items1); | |
| builder.makeString("典礼结束"); | |
| builder.makeItems(items2); | |
| builder.close(); | |
| } | |
| } |
Director.java
| public class Main { | |
| public static void main(String[] args) { | |
| //String choice="plain"; | |
| String choice="html"; | |
| if(choice=="plain"){ | |
| TextBuilder t=new TextBuilder(); | |
| Director d=new Director(t); | |
| d.construct(); | |
| System.out.println(t.getResult()); | |
| }else if(choice=="html"){ | |
| HtmlBuilder html=new HtmlBuilder(); | |
| Director d=new Director(html); | |
| d.construct(); | |
| System.out.println(html.getResult()); | |
| }else{ | |
| usage(); | |
| } | |
| } | |
| private static void usage() { | |
| System.out.println("使用 plain，编辑文本文件"); | |
| System.out.println("使用 html，编辑网页文件"); | |
| } | |
| } |
运行结果
关于 Builder 模式，我们一定要分清和模板方法的区别，其实就是到底谁承担了 ” 监工 ” 的责任，在模板方法中父类承担了这个责任，而在 Builder 中，有另外一个专门的类来完成这样的操作，这样做的好处是类的隔离，比如说在 Main 中，用户根本就不知道有 Builder 这个抽象类，同样的 Director 这个监工的根本就不管到底是哪一个实现类，因为任何一个都会被转换为父类，然后进行处理（面向抽象编程的思想），因此很好的实现了隔离，同样的这样设计的好处是复用了，隔离的越好复用起来就越方便，我们完全可以思考，假如还有另外一个监工，使用了不同的 construct 方法来组装这些复杂的事件，那么对于原来的代码我们不用做任何的修改，只用增加这样的一个监工类，然后定义好相应的方法就好了，之后再 Main 中使用，这样的一种思想使得我们不用修改源代码，复用（Builder 以及其子类）就很方便了，同样的，如果想增加一个新的 Builder 的子类，只要照着父类的方法进行填充，再加上自己的方法就好了，完全不用修改代码，这也是一种复用，因此这种复用（组件）的思想在设计模式中随处可见，本质就是高内聚低耦合，组件开发，尽量不修改原来的代码，有可扩展性，理解了这一点，我们再看看模板方法，责任全放在了父类里，如果责任需要改变，则必须要修改父类中的责任方法了，这样就修改了原来的代码，不利于复用，这也是两者的本质区别。
