java设计模式之建造者模式

定义

建造者模式(Builder Pattern)：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
比如KFC的套餐由不同的产品构成。

角色构成

• （抽象建造者）Builder：为创建一个产品对象的各个部件指定抽象接口。
• （实际建造者） ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
• （监督者）Director：构造一个使用Builder接口的对象，指导构建过程。
• （产品）Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

下面以创建人类的方式来完成 build pattern 的演示：

代码实现

抽象的人类建造者接口 Builder：

public interface PersonBuilder {  
     void buildHead();  
     void buildBody();  
     void buildFoot();  
     Person buildPerson();  
} 

实际建造者 ConcreteBuilder：

public class ManBuilder implements PersonBuilder {  
     Person person;  
     public ManBuilder() {  
          person = new Man();  
     }  
     public void buildbody() {  
          person.setBody("建造男人的身体");  
     }  
     public void buildFoot() {  
          person.setFoot("建造男人的脚");  
     }  
     public void buildHead() {  
          person.setHead("建造男人的头");  
     }  
     public Person buildPerson() {  
          return person;  
     }  
} 

public class WomanBuilder implements PersonBuilder {  
     Person person;  
     public WomanBuilder() {  
          person = new Woman();  
     }  
     public void buildbody() {  
          person.setBody(“建造女人的身体");  
     }  
     public void buildFoot() {  
          person.setFoot(“建造女人的脚");  
     }  
     public void buildHead() {  
          person.setHead(“建造女人的头");  
     }  
     public Person buildPerson() {  
          return person;  
     }  
} 

角色Director

public class PersonDirector {  
     public Person constructPerson(PersonBuilder pb) {  
          pb.buildHead();  
          pb.buildBody();  
          pb.buildFoot();  
          return pb.buildPerson();  
     }  
} 

角色Product：

public class Person {  
     private String head;  
     private String body;  
     private String foot;  
  
     public String getHead() {  
          return head;  
     }  
     public void setHead(String head) {  
          this.head = head;  
     }  
     public String getBody() {  
          return body;  
     }  
     public void setBody(String body) {  
          this.body = body;  
     }  
     public String getFoot() {  
          return foot;  
     }  
     public void setFoot(String foot) {  
          this.foot = foot;  
     }  
}  
public class Man extends Person {  
     public Man(){  
          System.out.println("开始建造男人");  
     }  
}  
public class Woman extends Person {  
     public Woman(){  
          System.out.println("开始建造女人");  
     }  
} 

测试

public class Test{  
     public static void main(String[] args) {  
          PersonDirector pd = new PersonDirector();  
          Person womanPerson = pd.constructPerson(new ManBuilder());  
          Person manPerson = pd.constructPerson(new WomanBuilder());  
     }  
}  

优点

• 在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
• 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象 。
• 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
• 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

缺点

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

适用环境

在以下情况下可以使用建造者模式：

• 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
• 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
• 对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中。
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

模式应用

如：Android系统中AlertDialog的创建。

模式扩展

建造者模式的简化:

省略抽象建造者角色：如果系统中只需要一个具体建造者的话，可以省略掉抽象建造者。
省略指挥者角色：在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略指挥者角色，让Builder角色扮演指挥者与建造者双重角色。
在《Effective Java》书中第二条，就提到**“遇到多个构造器参数时要考虑用构建器”**，其实这里的构建器就属于建造者模式，只是里面把四个角色都放到具体产品里面了。

上面例子如果只制造男人，演化后如下：

public class Man {  
     private String head;  
     private String body;  
     private String foot;  
  
     public String getHead() {  
          return head;  
     }  
     public void setHead(String head) {  
          this.head = head;  
     }  
     public String getBody() {  
          return body;  
     }  
     public void setBody(String body) {  
          this.body = body;  
     }  
     public String getFoot() {  
          return foot;  
     }  
     public void setFoot(String foot) {  
          this.foot = foot;  
     }  
}  

public class ManBuilder{  
     Man man;  
     public ManBuilder() {  
          man = new Man();  
     }  
     public void buildbody() {  
          man.setBody("建造男人的身体");  
     }  
     public void buildFoot() {  
          man.setFoot("建造男人的脚");  
     }  
     public void buildHead() {  
          man.setHead("建造男人的头");  
     }  
     public Man builderMan() {  
          buildHead();  
          buildBody();  
          buildFoot();  
          return man;  
     }  
}

建造者模式与抽象工厂模式的比较

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