浅谈简单工作流设计——责任链模式配合策略与命令模式的实现

本文以项目中的一个工作流模块，演示责任链模式、策略模式、命令模式的组合实现！

 

流程简介

最近在做的一个项目，涉及到的是一个流程性质的需求。关于工程机械行业的服务流程：服务任务流程和备件发运流程。

项目之初，需求不是很清晰，算是演化模型吧。先出一个简单版本，然后根据用户的使用情况，再进一步探测新需求。所以也就是说这两个流程中的每一步暂时都不是固定的，而应该是可配置、可增减的。

目前暂定的两个流程示意图如下：

           

 

以上为两个流程的大致过程，当然实际过程中，可能还要走其他的流程。

但是，仔细分析，你会看到。不管有多少个中间步骤，它们始终都对应着它们在该流程中所处的状态：

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 服务流程状态枚举  
3.     /// </summary>  
4.     public enum MaintanStateEnum  
5.     {  
6.         non_assign,         //已创建，待分配  
7.         non_accept,         //已分配，待接收  
8.         maintaining,        //已接收，服务中  
9.         non_confirm,        //完成服务，待确认  
10.         non_userConfirm,    //已确认，待客户确认  
11.         non_feedback,       //客户已确认，待回访  
12.         feedbacked,         //回访完成，流程结束  
13.         goback              //退回分配，此为动作，为了方便编码，不对应服务状态  
14.     }  

你会看到non_后面跟的都是一个个动作。在这里分清状态和动作是很重要的，不然就很难理清了。还有有时一个动作对应着前后状态，不要出现重复的状态比如：created(创建完成)和non_assign(待分配)在这里就是所谓的重复状态。

 

这些状态其实就是贯穿着整个流程的主线，类似于一个城市的主干道一样。我们只要抓着这样一天线索来思考，就能够化繁为简。

 

 

每个步骤可配置，各个步骤不相耦合，实现调用端一致性——责任链模式

而责任链模式，正是为此而生的！

在这里，我采用了责任链模式来封装这种步骤的不确定带来的变化。

首先我们有必要先了解一下，什么是责任链模式：

 

职责链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

适用场景：

1、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；

3、处理一个请求的对象集合应被动态指定。

 可以看到无论是上面哪种场景，都存在一个多对一的关系。在这个流程中，一很明显对应着服务流程（说白了就是数据库服务任务的一条记录）。大部分情况下，我们都在完成对一条服务中相关字段的修改，同时置不同的服务状态。而多，在这里应该对应着不同的步骤。

下面来看看实现：

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 维修服务 处理器-抽象基类  
3.     /// </summary>  
4.     public abstract class ServiceHandler  
5.     {  
6.         protected ServiceHandler nextHandler;  
7.   
8.         public virtual void Handle(MaintenanceForm maintenanceForm, object otherParams)  
9.         {  
10.             if (nextHandler!=null)  
11.             {  
12.                 nextHandler.Handle(maintenanceForm, otherParams);  
13.             }  
14.         }  
15.   
16.     }  

这是一个抽象处理器，流程中每个步骤的处理器，会覆写这个处理器的处理方法：

 

创建：

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.    /// 创建服务单流程--应对接线员/服务接收员角色【或者其他具有创建权限的其他角色】  
3.    /// </summary>  
4.   public class CreateHanlder:ServiceHandler  
5.    {  
6.       public override void Handle(MaintenanceForm maintenanceForm, object otherParams)  
7.       {  
8.           //如果已创建(未分配)  
9.           if (maintenanceForm.CurrentState==MaintanStateEnum.non_assign)  
10.           {  
11.               //创建该服务单  
12.                 
13.               return;  
14.           }  
15.           else    //已分配,则传递给下一个流程(假定为分配流程)  
16.           {  
17.               base.Handle(maintenanceForm,otherParams);  
18.           }  
19.       }  
20.   
21.       //设置下一个处理流程  
22.       public ServiceHandler NextHandler  
23.       {  
24.           set  
25.           {  
26.               base.nextHandler = value;  
27.           }  
28.       }  

[csharp] view plain copy

 

 print?

1. }  

 

 

分配：

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 服务流程之分配流程--应对服务处长等分配人员角色【或其他具有分配权限的人员】  
3.     /// </summary>  
4.     public class AssignHandler:ServiceHandler  
5.     {  
6.         public override void Handle(Model.MaintenanceForm maintenanceForm, object otherParams)  
7.         {  
8.             //如果当前处于已分配(未接收)状态  
9.             if (maintenanceForm.CurrentState == MaintanStateEnum.non_accept)  
10.             {  
11.                 //进行分配  
12.   
13.                 //记录日志  
14.                 Log(maintenanceForm);  
15.                 return;  
16.             }  
17.             else  
18.             {  
19.                 //进入下一流程  
20.                 base.Handle(maintenanceForm,otherParams);  
21.             }  
22.               
23.         }  
24.   
25.         public ServiceHandler NextHandler  
26.         {  
27.             set  
28.             {  
29.                 base.nextHandler=value;  
30.             }  
31.         }  

其他流程我就不一一贴出代码。下面来分析一下以上这几个处理器，有什么特别之处。首先，我们看出了，它是以状态为导向的（在Handle方法的判断中）。每个步骤都有一个NextHandler属性，用来配置下一个处理器，这就可以串联他们到一个流程中。大家可以看到每个Handle方法最后都有一个"return;"语句。没错，这里我使用了不完整的责任链模式。也就是一个流程不是一次走结束的，因为它们可能不是一个时间上的连贯，也可能不是一个人走完所有的流程，比如某人负责创建任务单，某人负责分配等。

 

下面看看，如何来串联他们到一个流程中：

 

[csharp] view plain copy

 

 print?

1. //初始化服务流程链  
2.         static ServiceHandler InitServiceChain()  
3.         {  
4.             //此处应用责任链模式，这样对维修服务单处理的入口只有一个  
5.             //根据当前的服务所处的状态可以导向到特定的处理流程【流程为链式】  
6.   
7.             CreateHanlder createHandler = new CreateHanlder();  
8.             AssignHandler assignHandler=new AssignHandler();  
9.             FinishHandler finishHandler=new FinishHandler();  
10.             FeedbackHandler feedbackHandler = new FeedbackHandler();  
11.   
12.             //显式指定流程链  
13.             /* 
14.              *注：此处体现流程可增减，可配置【例如写入配置文件】 
15.              */  
16.             createHandler.NextHandler=assignHandler;  
17.             assignHandler.NextHandler=finishHandler;  
18.             finishHandler.NextHandler = feedbackHandler;  
19.             feedbackHandler.NextHandler = null;  
20.   
21.   
22.   
23.             //返回流程启示，类似一个链表结构的头部指针  
24.             return createHandler;  
25.         }  

上面中第二大代码块，即实现了所有处理器的拼装与整合（只是示例，并不完整）

 

 

下面我们来看看客户端调用：

 

[csharp] view plain copy

 

 print?

1. static void Main(string[] args)  
2.         {  
3.             ServiceHandler serviceHandler = InitServiceChain();  
4.             //应用场景：  
5.   
6.             //场景一【演示创建服务单流程】  
7.             //点击新增按钮，弹出窗口，创建维修服务表单  
8.             MaintenanceForm newMaintenanceForm=new MaintenanceForm();  
9.             newMaintenanceForm.Creator = "yh";  
10.             newMaintenanceForm.CreatedTime = DateTime.Now;  
11.             newMaintenanceForm.CurrentState = MaintanStateEnum.non_assign;  
12.   
13.             serviceHandler.Handle(newMaintenanceForm,null);  //创建  
14.   
15.             //场景二【演示分配流程】  
16.             //在未分配维修单列表中选择一条维修单，点击分配  
17.             MaintenanceForm maintenanceForm = new MaintenanceForm();  
18.             maintenanceForm.LastModifiedTime = DateTime.Now;  
19.             maintenanceForm.CurrentState = MaintanStateEnum.non_accept;  
20.   
21.             serviceHandler.Handle(maintenanceForm,null);     //创建(跳过)->分配  
22.   
23.             //场景三【演示已分配被维修人员退回,重新分配流程】  
24.             //在被退回维修单列表中选择一条维修单，点击分配/重新分配  
25.             maintenanceForm.LastModifiedTime = DateTime.Now;  
26.             maintenanceForm.CurrentState = MaintanStateEnum.goback;  
27.   
28.             serviceHandler.Handle(maintenanceForm,null);     //创建(跳过)->分配  
29.   
30.             //场景四【演示接受流程】  
31.             //在已分配待完成表单中，选择一条记录，点击接受任务按钮  
32.             maintenanceForm.LastModifiedTime = DateTime.Now;  
33.             maintenanceForm.CurrentState = MaintanStateEnum.maintaining;  
34.   
35.             serviceHandler.Handle(maintenanceForm,null);     //创建(跳过)->分配(跳过)->接受  
36.   
37.             //场景五【演示回访流程】  
38.             //在已完成待回访表单中，选择一条记录，点击完成回访按钮  
39.             maintenanceForm.LastModifiedTime = DateTime.Now;  
40.             maintenanceForm.CurrentState = MaintanStateEnum.feedbacked;  
41.   
42.             serviceHandler.Handle(maintenanceForm,null);     //创建(跳过)->分配(跳过)->接受(跳过)......->回访  
43.   
44.             Console.Read();  
45.         }  

无论走哪个流程，整个的调用方法只有一个：

 

 

[csharp] view plain copy

 

 print?

1. serviceHandler.Handle(maintenanceForm,null);   

第一个参数为任务的实体，第二个为附带参数（如果没有，可不必传递）。在任务实体会在流程链中传递，实体中当前状态会指引它交给哪个Handler处理。这样无论你流程中步骤如何变化，在调用端的调用方式都是唯一的。而且你增减步骤对其他流程都不产生任何影响，唯一需要改变的就是组装他们的地方。比如，你需要在创建完服务单之后，走一个审核流程，那么增加它就是一个非常简单的动作。

 

这里关于发运流程的做法我就不多举例子了，大同小异。

 

实现每个步骤不同的日志记录方式之——策略模式

这里可能会对日志的记录有多种需求，比如发送Email给远端工程师或者某些领导等，存入数据库或平面文件备份.....

策略模式的细节就不多做介绍了，看实现：

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 日志记录策略抽象类  
3.     /// </summary>  
4.     public abstract class LogStrategy  
5.     {  
6.         public abstract void Log(Object obj);  
7.     }  

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 数据库策略--服务日志记录实现类  
3.     /// </summary>  
4.     public class ServiceDatabaseLogStrategy:LogStrategy  
5.     {  
6.         public override void Log(Object obj)  
7.         {  
8.             if (obj == null)  
9.             {  
10.                 throw new NullReferenceException("obj");  
11.             }  
12.   
13.             MaintenanceForm maintenanceForm = obj as MaintenanceForm;  
14.             //插入数据库  
15.             Console.WriteLine("数据库日志记录");  
16.             Console.WriteLine();  
17.         }  
18.     }  

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// E-mail策略--服务日志记录实现类  
3.     /// 某些不关注细节的角色  
4.     /// (比如领导，他们只关注结果，但他们需要宏观的把握，那么在完成服务步骤，日志可以通过email发送到领导邮箱)  
5.     /// </summary>  
6.     public class ServiceEMailDatabaseLogStrategy:LogStrategy  
7.     {  
8.         public override void Log(object obj)  
9.         {  
10.             if (obj==null)  
11.             {  
12.                 throw new NullReferenceException("obj");  
13.             }  
14.   
15.             MaintenanceForm maintenanceForm = obj as MaintenanceForm;  
16.             //发送到指定邮箱操作  
17.             Console.WriteLine("email日志记录");  
18.             Console.WriteLine();  
19.         }  
20.     }  

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 平面文件策略--服务日志记录实现类  
3.     /// 可以支持文本文档或者XML文档，便于查看和交互  
4.     /// </summary>  
5.     public class ServiceFileDatabaseLogStrategy : LogStrategy  
6.     {  
7.         public override void Log(object obj)  
8.         {  
9.             if (obj==null)  
10.             {  
11.                 throw new NullReferenceException("obj");  
12.             }  
13.             Console.WriteLine("文件日志记录");  
14.             Console.WriteLine();  
15.         }  
16.     }  

上面就是暂定的几个日志记录策略的实现，下面看看如何将它们组合到各个处理器中。首先，其实刚才处理器的抽象基类是有一个记录日志的虚方法的：

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 维修服务 处理器-抽象基类  
3.     /// </summary>  
4.     public abstract class ServiceHandler  
5.     {  
6.         protected ServiceHandler nextHandler;  
7.    
8.         public virtual void Handle(MaintenanceFormmaintenanceForm, object otherParams)  
9.         {  
10.             if (nextHandler != null)  
11.             {  
12.                nextHandler.Handle(maintenanceForm, otherParams);  
13.             }  
14.         }  
15.    
16.         public virtual void Log(MaintenanceFormmaintenanceForm)  
17.         {  
18.             //记录入数据库  
19.    
20.         }  
21.     }  

 

上面的抽象类实现的是，默认记录入数据库

其实，每个步骤的处理器中也都存在日志记录的处理(只是为了不干扰讲解责任链，而省略了)

 

[csharp] view plain copy

 

 print?

1. public classCreateHanlder:ServiceHandler  
2.     {  
3.        public override voidHandle(MaintenanceForm maintenanceForm, object otherParams)  
4.        {  
5.            //如果未分配  
6.            if(maintenanceForm.CurrentState==MaintanStateEnum.non_assign)  
7.            {  
8.    
9.                //记录日志  
10.                Log(maintenanceForm);  
11.                return;  
12.            }  
13.            else    //已分配,则传递给下一个流程(假定为分配流程)  
14.            {  
15.               base.Handle(maintenanceForm,otherParams);  
16.            }  
17.        }  
18.    
19.        //设置下一个处理流程  
20.        public ServiceHandler NextHandler  
21.        {  
22.            set  
23.            {  
24.                base.nextHandler = value;  
25.            }  
26.        }  
27.    
28.        public LogStrategy LogStrategy { get;set; }  
29.    
30.        public override void Log(MaintenanceFormmaintenanceForm)  
31.        {  
32.            //如果没有显式指定日志记录策略，则调用基类记录方法【存入DB】  
33.            if (LogStrategy == null)  
34.            {  
35.                base.Log(maintenanceForm);  
36.            }  
37.            else  
38.            {  
39.               LogStrategy.Log(maintenanceForm);  
40.            }  
41.        }  
42.     }  

 

这里有一个LogStrategy（日志策略基类）类型的属性，用来对外提供配置接口。每个处理器类都覆写了处理器基类的Log方法，逻辑为：如果有日志记录策略，则以日志记录策略来记录，否则用基类的记录方式(DB方式)。

上面在Handle方法返回之前，调用了被覆写的Log方法。

下面看看，外面是如何组装日志记录策略的：

 

[csharp] view plain copy

 

 print?

1. static ServiceHandlerInitServiceChain()  
2.         {  
3.             //此处应用责任链模式，这样对维修服务单处理的入口只有一个  
4.             //根据当前的服务所处的状态可以导向到特定的处理流程【流程为链式】  
5.    
6.             CreateHanlder createHandler = newCreateHanlder();  
7.             AssignHandler assignHandler=newAssignHandler();  
8.             FinishHandler finishHandler=newFinishHandler();  
9.             FeedbackHandler feedbackHandler =new FeedbackHandler();  
10.    
11.             //显式指定流程链  
12.             /* 
13.              *注：此处体现流程可增减，可配置【例如写入配置文件】 
14.              */  
15.            createHandler.NextHandler=assignHandler;  
16.            assignHandler.NextHandler=finishHandler;  
17.             finishHandler.NextHandler =feedbackHandler;  
18.             feedbackHandler.NextHandler = null;  
19.    
20.             //显式指定日志的记录策略  
21.             /* 
22.              * 支持多种日志记录策略(包括DB、Email、File) 
23.              * 如果不配置，缺省记录方式为DB 
24.              * 
25.              * 此处体现可配置性--某些高层只关注结果 
26.              * (也就是说可能他们只关注‘服务完成’流程，那么该流程的日志记录策略就可以设置为email) 
27.              * 
28.              * 配置同样可以写入配置文件,也可支持一个流程多种日志记录方式 
29.              * 
30.              */  
31.    
32.             //日志记录策略示例：  
33.             createHandler.LogStrategy = newServiceDatabaseLogStrategy();          //DB  
34.             assignHandler.LogStrategy = newServiceFileDatabaseLogStrategy();      //File  
35.             finishHandler.LogStrategy = newServiceEMailDatabaseLogStrategy();     //email  
36.             feedbackHandler.LogStrategy = newServiceEMailDatabaseLogStrategy();    //email  
37.    
38.             //返回流程启示，类似一个链表结构的头部指针  
39.             return createHandler;  
40.         }  

 

 

可以看到在组装流程的时候我们同时组装了日志记录的策略。事实上，这里每个流程只对应了一种策略，当然可以为一个流程配置几个日志记录策略啦(修改为List<LogStrategy>，然后在处理器的Log方法中依次调用)。

 

处理数据库处理逻辑调用端的一致性——命令模式

不知道大家平时是否都习惯了用三层架构来应对一般项目。在我们的项目中，BLL层是一个傀儡这是一个事实（不对此进行辩论，无论你的是不是，反正我们的项目是了，至于对与错，大家心里都明白）。这里，我一改往日数据库操作调用端采用的各种繁杂的XXXBLL.XXX()的不一致性。改为采用了命令模式来实现对数据库的增改删查。至于理由——业务都由各个处理器实现，没有采用BLL形式的必要。同时我的数据库操作方法的调用端一直，修改就封装在内部。

看看实现：

 

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 命令接口--可以支持：撤消/重做 操作  
3.     /// </summary>  
4.     public interface ICommand  
5.     {  
6.         //object Undo();     
7.    
8.         object Execute();  
9.    
10.         //object Redo();  
11.     }  

 

 

命令实现：

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 实现创建服务任务单命令--Command模式  
3.     /// </summary>  
4.     public classCreateMaintenanceFormCommand:ICommand  
5.     {  
6.         private MaintenanceFormmaintenanceForm;  
7.         publicCreateMaintenanceFormCommand(MaintenanceForm _maintenanceForm)  
8.         {  
9.             maintenanceForm = _maintenanceForm;  
10.         }  
11.    
12.         public object Execute()  
13.         {  
14.             //string str="insertinto....";  
15.             //DB.ExecuteNonQuery(....);  
16.             return null;  
17.         }  
18.     }  

 

 

 

[csharp] view plain copy

 

 print?

1. /// <summary>  
2.     /// 分配维修任务命令实现  
3.     /// </summary>  
4.     public classAssignMaintenanceFormCommand:ICommand  
5.     {  
6.         private MaintenanceFormmaintenanceForm;  
7.         publicAssignMaintenanceFormCommand(MaintenanceForm _maintenanceForm)  
8.         {  
9.             maintenanceForm = _maintenanceForm;  
10.         }  
11.    
12.         public object Execute()  
13.         {  
14.             //throw new NotImplementedException();  
15.             return null;  
16.         }  
17.     }  

 

 

且看创建服务单处理器中，如何调用：

 

[csharp] view plain copy

 

 print?

1. public classCreateHanlder:ServiceHandler  
2.     {  
3.        public override voidHandle(MaintenanceForm maintenanceForm, object otherParams)  
4.        {  
5.            //如果未分配  
6.            if(maintenanceForm.CurrentState==MaintanStateEnum.non_assign)  
7.            {  
8.    
9.                //构造创建服务单命令，并执行  
10.                ICommand createCommand = newCreateMaintenanceFormCommand(maintenanceForm);  
11.                createCommand.Execute();  
12.    
13.                //记录日志  
14.                Log(maintenanceForm);  
15.                return;  
16.            }  
17.            else    //已分配,则传递给下一个流程(假定为分配流程)  
18.            {  
19.               base.Handle(maintenanceForm,otherParams);  
20.            }  
21.        }