Head First设计模式——生成器模式和责任链模式

生成器

生成器模式：封装一个产品的构造过程，并允许按步骤构造。

现又一个度假计划指定，需要指定度假每一天的活动、旅馆、用餐、门票等等事情，但是每个客人的度假计划可能不太一样。例如天数、活动类型、用餐等等。

 

 

 

我们需要一个弹性的数据结构，代表客人的规划，以及不同的变化，也需要一系列潜在复杂顺序，创建这样的规划。如何提供一种方式来创建复杂的结构，也不会和创建它的步骤混在一起。迭代器的过程就是封装进一个独立的对象中，向客户隐藏集合的内部表现。这里我们也采用同样的思路：我们将旅游规划的创建过程，封装到一个对象中（此对象称为生成器），然后让客户调用生成器为它创建旅游规划。

设计类图：

 

 

 实现代码：

①存储数据结构类

1     public class Vacation
2     {
3         int Day { get; set; }
4         string Hotel { 5         string Park { 6         string Activity { 7         string Meal { 8     }

②抽象生成器

abstract  AbstractBuilder
void BuildDay(int day);
void Hotel(string hotel);
void Park( park);
void Activity( activity);
void Meal( meal);
8         abstract Vacation GetVacationPlanner();
9     }

③具体生成器，具体生成器可以多个实现。

 1      VacationBuilder : AbstractBuilder
 2  3         private Vacation vacation=new Vacation();
 4 
 5         override  day)
 6         {
 7             vacation.Day = day;
 8         }
 9 
10          hotel)
11 12             vacation.Hotel = hotel;
13 14          activity)
15 16             vacation.Activity = activity;
17 18          meal)
19 20             vacation.Meal = meal;
21 22 
23          park)
24 25             vacation.Park = park;
26 27 
28         override Vacation GetVacationPlanner()
29 30             return vacation;
31 32     }

④客户使用生成器

优点：

1、将复杂对象创建过程封装起来。

2、允许对象通过多个步骤来创建，并且可以改变过程。

3、向客户隐藏产品内部表现。

4、产品的实现可以被替换，因为客户只看到一个抽象的接口。

用途与缺点：

1、经常用来创建组合结构。

2、与工厂模式相比，采用生成器创建对象的客户需要更多的领域知识，才能正确的创建对象。

责任链

责任链模式：让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式。

有这样一个场景，公司专门接受邮件处理的人员需要将每天接收到的邮件进行处理，一类是需要转给部门经理处理的邮件，一类是给自己处理的，还有一类垃圾邮件直接删除。如果这样的一个场景，我们就可以通过责任链模式，为处理创建一个对象链。每个对象依序检查邮件请求，并进行处理，或者将它传递给链中的下一个对象。

设计类图：

实现代码：

 ①责任链抽象类

 1     /// <summary>
 2     /// 邮件类型
 3     </summary>
 4     enum EmailType
 5  6         Self=1, 7         Manager=2 8         Del=3
 9     }
10 
11 
12      Handler
public Handler nextHandler;
15          EmailType type;
16 
17          Handler(EmailType type) {
18             this.type = type;
20 
21         void SetNextHandler(Handler nextHandler)
22 23             this.nextHandler = nextHandler;
25 
26          HandleRequest(EmailType requsetType);
27         
28     }

②责任链处理类

 自己处理
 SelfHandler : Handler
 6         public SelfHandler() : base(EmailType.Self)
 7  HandleRequest(EmailType requsetType)
12             if (EmailType.Self == requsetType)
            {
14                 Console.WriteLine("邮件由自己处理");
            }
16             else
18                 if (nextHandler != null)
                {
20                     nextHandler.HandleRequest(requsetType);
                }
23 24     }

 转发经理
 ManagerHandler : Handler
public ManagerHandler() : (EmailType.Manager)
if (EmailType.Manager ==邮件转到经理处理 删除垃圾邮件
 DelHandler : Handler
public DelHandler() : (EmailType.Del)
if (EmailType.Del ==垃圾邮件已删除24     }

③测试责任链

 Program
static void Main([] args)
 4  5             //组装责任链
 6             Handler handler =  SelfHandler();
 7             Handler handler1 =  ManagerHandler();
 8             Handler handler2 =  DelHandler();
            handler.SetNextHandler(handler1);
10             handler1.SetNextHandler(handler2);
11             测试
12             handler.HandleRequest(EmailType.Del);
            handler.HandleRequest(EmailType.Manager);
14             handler.HandleRequest(EmailType.Self);
15 
16             Console.ReadKey();
18     }

 

 优点：

1、请求的发送者和接收者解耦。

2、简化对象，因为不需要知道链的结构。

3、通过改变链内的成员或调动他们的次序，允许你动态地新增或者删除责任。

用途和缺点：

1、经常被用在窗口系统中，处理鼠标和键盘之类的事件。

2、并不保证请求一定被执行，如果没有任何对象处理它，可能会落到链尾端之外。

3、不容易观察允许特征，不好排查问题。