建造者模式

时间：2019-01-12 00:22:46 阅读：201 评论：0 收藏：0 [点我收藏+]

标签：实例代码很多 cname 大量 convert 共同点设置提取 elements

模式动机

无论是在现实世界中还是在软件系统中，都存在一些复杂的对象，它们拥有多个组成部分，如汽车，它包括车轮、方向盘、发送机等各种部件。而对于大多数用户而言，无须知道这些部件的装配细节，也几乎不会使用单独某个部件，而是使用一辆完整的汽车，可以通过建造者模式对其进行设计与描述，建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

在软件开发中，也存在大量类似汽车一样的复杂对象，它们拥有一系列成员属性，这些成员属性中有些是引用类型的成员对象。而且在这些复杂对象中，还可能存在一些限制条件，如某些属性没有赋值则复杂对象不能作为一个完整的产品使用；有些属性的赋值必须按照某个顺序，一个属性没有赋值之前，另一个属性可能无法赋值等。

复杂对象相当于一辆有待建造的汽车，而对象的属性相当于汽车的部件，建造产品的过程就相当于组合部件的过程。由于组合部件的过程很复杂，因此，这些部件的组合过程往往被“外部化”到一个称作建造者的对象里，建造者返还给客户端的是一个已经建造完毕的完整产品对象，而用户无须关心该对象所包含的属性以及它们的组装方式，这就是建造者模式的模式动机。

模式定义

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

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。根据中文翻译的不同，建造者模式又可以称为生成器模式。

模式结构

建造者模式包含如下角色：

? Builder：抽象建造者

? ConcreteBuilder：具体建造者

? Director：指挥者

? Product：产品角色

模式分析

典型的复杂对象其类代码示例如下：

1 public class Product 
2 {
3     private String partA; //可以是任意类型
4     private String partB;
5     private String partC;
6     //partA的Getter方法和Setter方法省略
7     //partB的Getter方法和Setter方法省略
8     //partC的Getter方法和Setter方法省略
9 }

抽象建造者类中定义了产品的创建方法和返回方法，其典型代码如下：

 1 public abstract class Builder
 2 {
 3     protected Product product=new Product();
 4     
 5     public abstract void buildPartA();
 6     public abstract void buildPartB();
 7     public abstract void buildPartC();
 8     
 9     public Product getResult()
10     {
11         return product;
12     }
13 }

建造者模式的结构中还引入了一个指挥者类Director，该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象。

指挥者类的代码示例如下：

 1 public class Director
 2 {
 3     private Builder builder;
 4     
 5     public Director(Builder builder)
 6     {
 7         this.builder=builder;
 8     }
 9     
10     public void setBuilder(Builder builder)
11     {
12         this.builder=builer;
13     }
14     
15     public Product construct()
16     {
17         builder.buildPartA();
18         builder.buildPartB();
19         builder.buildPartC();
20         return builder.getResult();
21     }
22 }

客户端类代码片段：

1 ……
2 Builder builder = new ConcreteBuilder();
3 Director director = new Director(builder);
4 Product product = director.construct();
5 ……

在客户端代码中，无须关心产品对象的具体组装过程，只需确定具体建造者的类型即可，建造者模式将复杂对象的构建与对象的表现分离开来，这样使得同样的构建过程可以创建出不同的表现。

建造者模式实例与解析

实例：KFC套餐

? 建造者模式可以用于描述KFC如何创建套餐：套餐是一个复杂对象，它一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整的套餐，然后返回给顾客。

实例代码(JAVA)：

  1 //组件类 Meal
  2 public class Meal
  3 {
  4     //food和drink是部件
  5     private String food;
  6     private String drink;
  7     
  8     public void setFood(String food) {
  9         this.food = food; 
 10     }
 11 
 12     public void setDrink(String drink) {
 13         this.drink = drink; 
 14     }
 15 
 16     public String getFood() {
 17         return (this.food); 
 18     }
 19 
 20     public String getDrink() {
 21         return (this.drink); 
 22     }
 23 }
 24 
 25 //抽象建造者类 MealBuilder
 26 public abstract class MealBuilder
 27 {
 28     protected Meal meal=new Meal();
 29     public abstract void buildFood();
 30     public abstract void buildDrink();
 31     public Meal getMeal()
 32     {
 33         return meal;
 34     }
 35 }
 36 
 37 //具体建造者类 SubMealBuilderA
 38 public class SubMealBuilderA extends MealBuilder
 39 {
 40     public void buildFood()
 41     {
 42         meal.setFood("一个鸡腿堡");
 43     }
 44     public void buildDrink()
 45     {
 46         meal.setDrink("一杯可乐");
 47     }
 48 }
 49 
 50 //具体建造者类 SubMealBuilderB
 51 public class SubMealBuilderB extends MealBuilder
 52 {
 53     public void buildFood()
 54     {
 55         meal.setFood("一个鸡肉卷");
 56     }
 57     public void buildDrink()
 58     {
 59          meal.setDrink("一杯果汁");
 60     }
 61 }
 62 
 63 //指挥者类 KFCWriter
 64 public class KFCWaiter
 65 {
 66     private MealBuilder mb;
 67     public void setMealBuilder(MealBuilder mb)
 68     {
 69         this.mb=mb;
 70     }
 71     public Meal construct()
 72     {
 73         mb.buildFood();
 74         mb.buildDrink();
 75         return mb.getMeal();
 76     }
 77 }
 78 
 79 //配置文件 config.xml
 80 <?xml version="1.0"?>
 81 <config>
 82     <className>SubMealBuilderB</className>
 83 </config>
 84 
 85 //通过反射获得具体创建者的实例 XMLUtil
 86 import javax.xml.parsers.*;
 87 import org.w3c.dom.*;
 88 import org.xml.sax.SAXException;
 89 import java.io.*;
 90 public class XMLUtil
 91 {
 92 //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
 93     public static Object getBean()
 94     {
 95         try
 96         {
 97             //创建文档对象
 98             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
 99             DocumentBuilder builder = dFactory.newDocumentBuilder();
100             Document doc;                            
101             doc = builder.parse(new File("config.xml")); 
102         
103             //获取包含类名的文本节点
104             NodeList nl = doc.getElementsByTagName("className");
105             Node classNode=nl.item(0).getFirstChild();
106             String cName=classNode.getNodeValue();
107             
108             //通过类名生成实例对象并将其返回
109             Class c=Class.forName(cName);
110               Object obj=c.newInstance();
111             return obj;
112            }   
113                catch(Exception e)
114                {
115                    e.printStackTrace();
116                    return null;
117                }
118         }
119 }
120 
121 //客户端类
122 public class Client
123 {
124     public static void main(String args[])
125     {
126         //动态确定套餐种类
127         MealBuilder mb=(MealBuilder)XMLUtil.getBean();
128         //服务员是指挥者
129         KFCWaiter waiter=new KFCWaiter();
130         //服务员准备套餐
131         waiter.setMealBuilder(mb);
132         //客户获得套餐
133         Meal meal=waiter.construct();
134         
135         System.out.println("套餐组成：");
136         System.out.println(meal.getFood());
137         System.out.println(meal.getDrink());
138     }
139 }

实例代码(C++)：

  1 // 建造者模式
  2 #include <iostream>
  3 #include <string>
  4 using namespace std;
  5 
  6 //组件类 Meal
  7 class Meal
  8 {
  9 private:
 10     string food;
 11     string drink;
 12 public:
 13     void setFood(string food)
 14     {
 15         this->food = food;
 16     }
 17     void setDrink(string drink)
 18     {
 19         this->drink = drink;
 20     }
 21     string getFood()
 22     {
 23         return this->food;
 24     }
 25     string getDrink()
 26     {
 27         return this->drink;
 28     }
 29 };
 30 
 31 //抽象建造者类
 32 class MealBuilder
 33 {
 34 protected:
 35     Meal* meal = new Meal();
 36 public:
 37     virtual void buildFood() = 0;
 38     virtual void buildDrink() = 0;
 39     Meal* getMeal()
 40     {
 41         return meal;
 42     }
 43 };
 44 
 45 //具体建造者类 SubMealBuilderA
 46 class subMealBuilderA:public MealBuilder
 47 {
 48 public:
 49     void buildFood() override
 50     {
 51         meal->setFood("一个鸡腿堡");
 52     }
 53     void buildDrink() override
 54     {
 55         meal->setDrink("一杯可乐");
 56     }
 57 };
 58 
 59 //具体建造者类 SubMealBuilderB
 60 class subMealBuilderB:public MealBuilder
 61 {
 62 public:
 63     void buildFood() override
 64     {
 65         meal->setFood("一个鸡肉卷");
 66     }
 67     void buildDrink() override
 68     {
 69         meal->setDrink("一杯果汁");
 70     }
 71 };
 72 
 73 //指挥者类 KFCWriter
 74 class KFCWriter
 75 {
 76 private:
 77     MealBuilder* mb;
 78 public:
 79     void setMealBuilder(MealBuilder* mb)
 80     {
 81         this->mb = mb;
 82     }
 83     Meal* construct()
 84     {
 85         mb->buildFood();
 86         mb->buildDrink();
 87         return mb->getMeal();
 88     }
 89 };
 90 
 91 //客户端
 92 int main()
 93 {
 94     KFCWriter* writer = new KFCWriter();
 95 
 96     MealBuilder* mba = new subMealBuilderA();
 97     writer->setMealBuilder(mba);
 98     Meal* meala = writer->construct();
 99     cout << "套餐A组成:" << meala->getFood() << "/" << meala->getDrink() << endl;
100     
101     MealBuilder* mbb = new subMealBuilderB();
102     writer->setMealBuilder(mbb);
103     Meal* mealb = writer->construct();
104     cout << "套餐B组成:" << mealb->getFood() << "/" << mealb->getDrink() << endl;
105     return 0;
106 }

模式优缺点

优点

? 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

? 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

? 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

? 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

缺点

? 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

? 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

模式适用环境

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

? 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。

? 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。

? 对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中。

? 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

模式应用

(1) JavaMail（一步一步构造一个完整的邮件对象，然后发送）

 1 ……
 2 //由邮件会话对象新建一个邮件消息对象
 3 MimeMessage message=new MimeMessage(session); 
 4 //设置邮件地址
 5 InternetAddress from=new InternetAddress("sunny@test.com");
 6 message.setFrom(from);//设置发件人
 7 InternetAddress to=new InternetAddress(to_mail);
 8 message.setRecipient(Message.RecipientType.TO,to);//设置收件人，并设置其接收类型为TO
 9 message.setSubject(to_title);//设置主题
10 message.setText(to_content);//设置信件内容
11 message.setSentDate(new Date());//设置发信时间
12 message.saveChanges();//存储邮件信息
13 Transport transport=session.getTransport("smtp");
14 transport.connect("smtp.test.com","test","test");
15 transport.sendMessage(message,message.getAllRecipients());
16 ……