设计模式：Builder模式
一、前言
今天我们讨论一下Builder建造者模式，这个Builder，其实和模板模式非常的像，但是也有区别，那就是在模板模式中父类对子类中的实现进行操作，在父类之中进行一件事情的处理，但是在Builder模式之中，父类和子类都不用关心怎么处理，而是用另一个类来完成对这些方法的有机组合，这个类的职责就是‘监工’，规定了到底要怎么样有机的组合这些方法。在监工类（Director）中，将父类组合进去，然后调用父类的操作来抽象的实现一件事情，这就是面向接口（抽象）变成的妙处了，当然这个Builder可以使接口也可以是抽象类，在这里我们使用抽象类。
二、Builder模式代码
Builder 抽象类：
1 package zyr.dp.builder; 2 3 public abstract class Builder { 4 5 public abstract void makeString(String str); 6 public abstract void makeTitle(String title); 7 public abstract void makeItems(String[] items); 8 public abstract void close(); 9 10 }
HtmlBuilder 实现类：
1 package zyr.dp.builder; 2 3 import java.io.FileWriter; 4 import java.io.IOException; 5 import java.io.PrintWriter; 6 7 public class HtmlBuilder extends Builder { 8 9 private String filename; 10 private PrintWriter pw; 11 public void makeTitle(String title) { 12 filename="D:\"+title+".html"; 13 try { 14 pw=new PrintWriter(new FileWriter(filename)); 15 } catch (IOException e) { 16 e.printStackTrace(); 17 } 18 pw.println("<html><head><title>"+title+"</title></head><body>"); 19 pw.println("<h1>"+title+"</h1>"); 20 } 21 22 public void makeString(String str) { 23 pw.println("<p>"+str+"</p>"); 24 } 25 26 public void makeItems(String[] items) { 27 pw.println("<ul>"); 28 for(int i=0;i<items.length;i++){ 29 pw.println("<li>"+items[i]+"</li>"); 30 } 31 pw.println("</ul>"); 32 } 33 34 public void close() { 35 pw.println("</body></html>"); 36 pw.close(); 37 } 38 public String getResult(){ 39 return filename; 40 } 41 }
TextBuilder实现类：
1 package zyr.dp.builder; 2 3 public class TextBuilder extends Builder { 4 5 StringBuffer sb=new StringBuffer(); 6 7 public void makeTitle(String title) { 8 sb.append("====================="); 9 sb.append("["+title+"]"+" "); 10 } 11 12 public void makeString(String str) { 13 sb.append("@"+str+" "); 14 } 15 16 public void makeItems(String[] items) { 17 for(int i=0;i<items.length;i++){ 18 sb.append(" ."+items[i]+" "); 19 } 20 } 21 22 public void close() { 23 sb.append("====================="); 24 } 25 26 public String getResult(){ 27 return sb.toString(); 28 } 29 30 }
Director监工类：
1 package zyr.dp.builder; 2 3 public class Director { 4 private Builder builder; 5 public Director(Builder builder){ 6 this.builder=builder; 7 } 8 public void construct(){ 9 String [] items1=new String[]{"奏国歌","升国旗"}; 10 String [] items2=new String[]{"观众鼓掌","有序撤离"}; 11 builder.makeTitle("今日头条"); 12 builder.makeString("毕业典礼"); 13 builder.makeItems(items1); 14 builder.makeString("典礼结束"); 15 builder.makeItems(items2); 16 builder.close(); 17 } 18 }
Main类：
1 package zyr.dp.builder; 2 3 public class Main { 4 5 public static void main(String[] args) { 6 //String choice="plain"; 7 String choice="html"; 8 if(choice=="plain"){ 9 TextBuilder t=new TextBuilder(); 10 Director d=new Director(t); 11 d.construct(); 12 System.out.println(t.getResult()); 13 }else if(choice=="html"){ 14 HtmlBuilder html=new HtmlBuilder(); 15 Director d=new Director(html); 16 d.construct(); 17 System.out.println(html.getResult()); 18 }else{ 19 usage(); 20 } 21 22 } 23 24 private static void usage() { 25 System.out.println("使用 plain，编辑文本文件"); 26 System.out.println("使用 html，编辑网页文件"); 27 } 28 29 }
运行结果：
或者：
三、总结
关于Builder模式，我们一定要分清和模板方法的区别，其实就是到底谁承担了“监工”的责任，在模板方法中父类承担了这个责任，而在Builder中，有另外一个专门的类来完成这样的操作，这样做的好处是类的隔离，比如说在Main中，用户根本就不知道有Builder这个抽象类，同样的Director这个监工的根本就不管到底是哪一个实现类，因为任何一个都会被转换为父类，然后进行处理（面向抽象编程的思想），因此很好的实现了隔离，同样的这样设计的好处是复用了，隔离的越好复用起来就越方便，我们完全可以思考，假如还有另外一个监工，使用了不同的construct方法来组装这些复杂的事件，那么对于原来的代码我们不用做任何的修改，只用增加这样的一个监工类，然后定义好相应的方法就好了，之后再Main中使用，这样的一种思想使得我们不用修改源代码，复用（Builder以及其子类）就很方便了，同样的，如果想增加一个新的Builder的子类，只要照着父类的方法进行填充，再加上自己的方法就好了，完全不用修改代码，这也是一种复用，因此这种复用（组件）的思想在设计模式中随处可见，本质就是高内聚低耦合，组件开发，尽量不修改原来的代码，有可扩展性，理解了这一点，我们再看看模板方法，责任全放在了父类里，如果责任需要改变，则必须要修改父类中的责任方法了，这样就修改了原来的代码，不利于复用，这也是两者的本质区别。