建造者模式是日常开发中比较常见的设计模式，它的主要作用就是将复杂事物创建的过程抽象出来，该抽象的不同实现方式不同，创建出的对象也不同。

一、前言

今天我们讨论一下 Builder 建造者模式，这个 Builder，其实和模板模式非常的像，但是也有区别，那就是在模板模式中父类对子类中的实现进行操作，在父类之中进行一件事情的处理，但是在 Builder 模式之中，父类和子类都不用关心怎么处理，而是用另一个类来完成对这些方法的有机组合，这个类的职责就是监工，规定了到底要怎么样有机的组合这些方法。在监工类（Director）中，将父类组合进去，然后调用父类的操作来抽象的实现一件事情，这就是面向接口（抽象）变成的妙处了，当然这个 Builder 可以使接口也可以是抽象类，在这里我们使用抽象类。

二、Builder 模式代码

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 实现类

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(""+title+"");
       pw.println("
"+title+"");
   }
   
   public void makeString(String str) {
       pw.println("
"+str+"");
   }

   public void makeItems(String[] items) {
       pw.println(" 
   

     " 
   );
       for(int i=0;i
  
   "
   
"+items[i]+"
");        }        pw.println(
   "");    }    public void 
   close() {        pw.println(
   "");        pw.close();    }    public String 
   getResult(){        
   return filename;    } } 
  

TextBuilder 实现类

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[i]+
   "\n");        }    }    public void 
   close() {        sb.append(
   "=====================");    }        public String 
   getResult(){        
   return sb.toString();    }     } 
  

Director 监工类

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();
   }
}

Main 类

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的子类，只要照着父类的方法进行填充，再加上自己的方法就好了，完全不用修改代码，这也是一种复用，因此这种复用（组件）的思想在设计模式中随处可见，本质就是高内聚低耦合，组件开发，尽量不修改原来的代码，有可扩展性，理解了这一点，我们再看看模板方法，责任全放在了父类里，如果责任需要改变，则必须要修改父类中的责任方法了，这样就修改了原来的代码，不利于复用，这也是两者的本质区别。