`

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

阅读更多

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

 

流程简介

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

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

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

           

 

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

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

 

[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.        }  
分享到:
评论

相关推荐

    浅谈医疗环境景观设计——以厦门马銮湾医院景观设计为例.pdf

    《浅谈医疗环境景观设计——以厦门马銮湾医院景观设计为例》 医疗环境景观设计在现代医疗领域中扮演着至关重要的角色。它不仅提升了医院的整体形象,更关键的是,良好的医疗环境景观能够对病人的身心健康产生积极的...

    设计模式浅谈1——策略模式

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件工程中,我们经常遇到需要根据不同条件或场景动态地改变算法的情况。策略模式就是为了解决这类问题而诞生的,它允许我们用不同的策略(即算法)...

    深入浅出设计模式一——Duck设计(策略模式)

    《深入浅出设计模式一——Duck设计(策略模式)》 在软件开发中,设计模式是一种被广泛接受并重复使用的解决方案,它针对特定问题提供了一种通用的、可复用的设计方案。策略模式是其中一种行为设计模式,用于定义...

    java设计模式

    第34章 命令模式+责任链模式 34.1 搬移UNIX的命令 34.2 混编小结 第35章 工厂方法模式+策略模式 35.1 迷你版的交易系统 35.2 混编小结 第36章 观察者模式+中介者模式 36.1 事件触发器的开发 36.2 混编小结 第37章 ...

    计算机网络安全的威胁-[浅谈网络安全的灵魂——安全策略].docx

    计算机网络安全的威胁-[浅谈网络安全的灵魂——安全策略].docx

    浅谈四等水准测量——测绘、测量毕业论文设计.doc

    浅谈四等水准测量——测绘、测量毕业论文设计.doc

    浅谈基于项目驱动教学课程设计——以《机械制图与CAD》教学为例.pdf

    此模式包含设计、组织、实施和评估四个主要过程,其中项目的设计是基础,也是能否顺利实施项目教学的关键。 二、课程项目设计思路 为了更好地实施项目驱动教学法,课程项目的设计需要遵循以下几个原则: 1. 项目...

    设计模式——刘伟

    刘伟先生在讲解设计模式时,通常会深入浅出地介绍这些模式的原理、应用场景以及如何有效地在实际编程中应用它们。设计模式并不是具体的代码或库,而是一种经验总结,是软件开发人员在长期实践中形成的通用解决方案的...

    深入浅出设计模式二——WeatherData设计(观察者模式)实现一

    在本文中,我们将深入探讨设计模式中的一个经典案例——观察者模式(Observer Pattern),通过具体的实现来理解其工作原理。观察者模式是一种行为设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生...

    浅谈数控技术发展趋势———智能化数控系统.pdf

    浅谈数控技术发展趋势———智能化数控系统.pdf

    design-pattern-java.pdf

    基础知识 基础知识设计模式概述 从招式与内功谈起——设计模式概述(一) 从招式与内功谈起——设计模式概述(二) 从招式与内功谈起——设计模式概述(三) 面向对象设计原则 面向对象设计原则之单一职责原则 面向...

    深入浅出设计模式二——WeatherData设计(观察者模式)实现二

    在本文中,我们将深入探讨设计模式中的"观察者模式",并以`WeatherData`为例进行具体实现。观察者模式是一种行为设计模式,它允许我们定义一个订阅机制,当对象状态发生变化时,可以通知所有依赖它的观察者。这种...

    很好的编程资料——C#设计模式

    本资料包"很好的编程资料——C#设计模式"包含了23种经典的设计模式,每种模式都有对应的C#实现,是C#开发者学习和应用设计模式的宝贵资源。 1. **单例模式**:保证一个类只有一个实例,并提供一个全局访问点。在C#...

    深入浅出设计模式三——Beverage实现(装饰者模式)

    "深入浅出设计模式三——Beverage实现(装饰者模式)"这一标题指出,我们将探讨如何使用装饰者模式来实现一个饮品系统。装饰者模式是一种结构型设计模式,它允许我们在运行时向对象添加新的行为或职责,而无需修改对象...

    模式举例代码——设计模式和举例代码

    - 责任链模式:将请求沿着处理者链传递,直到某个处理者处理请求。 - 命令模式:将命令封装为对象,以便使用不同的请求、队列或日志来参数化其他对象。 - 解释器模式:定义语言的文法,并提供一个解释器来处理...

    浅谈煤矿管理——托管模式

    随着东部煤炭资源逐渐枯竭、国家产业结构和布局的调整,东部与西部资源的结合是发展的必然趋势。采取怎样的结合方式,是矿权所有企业思考的重点。不同的管理模式具有不同特点,适应的对象也不同,合作的广度和深度也有较...

Global site tag (gtag.js) - Google Analytics