读书笔记11：建造者模式

1、概念

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2、角色

产品（Product）——根据不同建造者建造的结果；

抽象建造者（Builder）——包含详细的建造步骤；

指挥者（Director）——安排如何建造，如何安排步骤的先后顺序；

具体的建造者——根据不同的需求，实现Builder的步骤，每一步骤如何实现是不同的，但是Builder中的所有步骤必须都要有。

 3、模型

各角色的实现

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4.   
5. namespace BuilderPattern  
6. {  
7.     public class Product//产品  
8.     {  
9.         List<string> parts = new List<string>();  
10.         public void Add(string part)  
11.         {  
12.             parts.Add(part);  
13.         }  
14.   
15.         public void ShowProductStep()  
16.         {  
17.             Console.WriteLine(@"开始创建产品:");  
18.             foreach (string part in parts)  
19.             {  
20.                 Console.WriteLine(part);  
21.             }  
22.         }  
23.     }  
24.   
25.    
26.     public abstract class Builder//抽象建造者  
27.     {  
28.          public abstract void BuilderStep1();  
29.          public abstract void BuilderStep2();  
30.          public abstract void BuilderStep3();  
31.         // ... 根据不同的需求，该产品生产时所需的所有步骤。  
32.          public abstract Product GetProduct();  
33.     }  
34.     
35.     public class ProductBuilder1 : Builder//具体建造者1  
36.     {  
37.         private Product product = new Product();  
38.         public override void BuilderStep1()  
39.         {  
40.             product.Add("第一步 -- ");  
41.         }  
42.         public override void BuilderStep2()  
43.         {  
44.   
45.             product.Add("第二步 -- ");  
46.         }  
47.   
48.         public override void BuilderStep3()  
49.         {  
50.             product.Add("第三步");  
51.         }  
52.    
53.         public override Product GetProduct()  
54.         {  
55.             return product;  
56.         }  
57.     }  
58.   
59.     public class ProductBuilder2 : Builder//具体建造者2，具体建造者的具体步骤是不同的，但是有哪些步骤，这是统一的。  
60.     {  
61.         private Product product = new Product();  
62.         public override void BuilderStep1()  
63.         {  
64.             product.Add("第1步 -- ");  
65.         }  
66.   
67.          public override void BuilderStep2()  
68.         {  
69.             product.Add("第2步 -- ");  
70.         }  
71.   
72.         public override void BuilderStep3()  
73.         {  
74.             product.Add("第3步");  
75.         }  
76.   
77.         public override Product GetProduct()  
78.        {  
79.             return product;  
80.   
81.         }  
82.   
83.     }  
84.   
85.     public class Derector//指挥者  
86.     {  
87.   
88.         public void Construct(Builder builder)  
89.         {  
90.             builder.BuilderStep1();  
91.   
92.             builder.BuilderStep2();  
93.   
94.             builder.BuilderStep3();  
95.         }  
96.     }  
97. }  

客户端调用

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;   
4.   
5. namespace BuilderPattern  
6. {  
7.     class Program  
8.     {  
9.         static void Main(string[] args)  
10.         {  
11.             Derector derector = new Derector();  
12.             Builder builder1 = new ProductBuilder1();  
13.             Builder builder2 = new ProductBuilder2();  
14.    
15.             //建造产品1  
16.             derector.Construct(builder1);  
17.             Product product1 = builder1.GetProduct();  
18.             product1.ShowProductStep();  
19.             //建造产品2  
20.             derector.Construct(builder2);  
21.             Product product2 = builder2.GetProduct();  
22.             product2.ShowProductStep();  
23.   
24.             Console.ReadKey();  
25.   
26.         }  
27.     }  
28. }  

结果

 

建造者模式强调的是步骤，就是得到的结果必须保证产生这个结果的流程都是统一的，而且也是的算法和表示分离，这一点类似于策略模式，不同的算法来实现这个策略。但是建造者模式更强调的是步骤。同时从指挥者这部分看又有些类似于外观模式，定义一个高层接口使子系统更加容易使用。但是建造者模式中，这部分的特点是指挥者决定步骤的顺序，它指挥如何建造，而且经过它指挥的产生的结果在流程上是一样的。