23种设计模式之责任链模式（Chain of Responsibility Pattern）

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了

优点： 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。

缺点： 1、不能保证请求一定被接收。 2、在找到正确的处理对象之前，所有的条件判定都要执行一遍，当责任链过长时，可能会引起性能的问题。 3、可能不容易观察运行时的特征，有碍于除错。

应用实例： 1、JS 中的事件冒泡。2、在现实生活中，有很多请求并不是一个人说了就算的，例如面试时的工资，低于1万的薪水可能技术经理就可以决定了，但是1万~1万5的薪水可能技术经理就没这个权利批准，可能就需要请求技术总监的批准，所以在面试的完后，经常会有面试官说，你这个薪水我这边觉得你这技术可以拿这个薪水的，但是还需要技术总监的批准等的话。

主要涉及两个角色：

• 抽象处理者角色（Handler）：定义出一个处理请求的接口。这个接口通常由接口或抽象类来实现。
• 具体处理者角色（ConcreteHandler）：具体处理者接受到请求后，可以选择将该请求处理掉，或者将请求传给下一个处理者。因此，每个具体处理者需要保存下一个处理者的引用，以便把请求传递下去

实现代码：

     public abstract class AbstractAuditor
     {
         public string Name { get; set; }
         public abstract void Audit(ApplyContext context);

         private AbstractAuditor _NextAuditor = null;
         public void SetNext(AbstractAuditor auditor)
         {
             this._NextAuditor = auditor;
         }
         protected void AuditNext(ApplyContext context)
         {
             if (this._NextAuditor != null)
             {
                 this._NextAuditor.Audit(context);
             }
             else
             {
                 context.AuditResult = false;
                 context.AuditRemark = "不允许请假！";
             }
         }
     }

     /// <summary>
     /// 请假申请，
     /// Context--上下文环境，保存业务处理中参数-中间结果-最终结果
     /// 行为型设计模式常用的标配
     /// 把行为转移，
     /// </summary>
     public class ApplyContext
     {
         public int Id { get; set; }
         public string Name { get; set; }
         /// <summary>
         /// 请假时长
         /// </summary>
         public int Hour { get; set; }
         public string Description { get; set; }
         public bool AuditResult { get; set; }
         public string AuditRemark { get; set; }
     }

     /// <summary>
     /// 职责问题：
     /// 1 权限范围内，审批通过
     /// 2 权限范围外，交给下一环节审批
     /// 写的代码又多了一个，指定下一环节
     /// 甩锅大法
     /// </summary>
     public class PM : AbstractAuditor
     {
         public override void Audit(ApplyContext context)
         {
             Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
             if (context.Hour <= )
             {
                 context.AuditResult = true;
                 context.AuditRemark = "允许请假！";
             }
             else
             {
                 base.AuditNext(context);
             }
         }
     }

     public class Charge: AbstractAuditor
     {
         public override void Audit(ApplyContext context)
         {
             Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
             if (context.Hour <= )
             {
                 context.AuditResult = true;
                 context.AuditRemark = "允许请假！";
             }
             else
             {
                 base.AuditNext(context);
             }
         }
     }

     public class Manager : AbstractAuditor
     {
         public override void Audit(ApplyContext context)
         {
             Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
             if (context.Hour <= )
             {
                 context.AuditResult = true;
                 context.AuditRemark = "允许请假！";
             }
             else
             {
                 base.AuditNext(context);
             }
         }
     }

     public class Chief : AbstractAuditor
     {
         public override void Audit(ApplyContext context)
         {
             Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
             if (context.Hour <= )
             {
                 context.AuditResult = true;
                 context.AuditRemark = "允许请假！";
             }
             else
             {
                 base.AuditNext(context);
                 //....
             }
         }
     }

     public class CEO : AbstractAuditor
     {
         public override void Audit(ApplyContext context)
         {
             Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
             if (context.Hour <= )
             {
                 context.AuditResult = true;
                 context.AuditRemark = "允许请假！";
             }
             else
             {
                 base.AuditNext(context);
                 //....
             }
         }
     }

     public class ChiarMan : AbstractAuditor
     {
         public override void Audit(ApplyContext context)
         {
             Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
             if (context.Hour <= )
             {
                 context.AuditResult = true;
                 context.AuditRemark = "允许请假！";
             }
             else
             {
                 base.AuditNext(context);
                 //....
             }
         }
     }

前端调用：

                 ApplyContext context = new ApplyContext()
                 {
                     Id = ,
                     Name = "aaa",
                     Hour = ,
                     Description = "我想...",
                     AuditResult = false,
                     AuditRemark = ""
                 };
                     //流程的可扩展

                     AbstractAuditor auditor = AuditorBuilder.Build();
                     auditor.Audit(context);
                     if (!context.AuditResult)
                     {
                         Console.WriteLine("不干了！");
                     }
                     //把流程环节逻辑从业务类转移了

     public class AuditorBuilder
     {
         /// <summary>
         /// 那就反射+配置文件
         /// 链子的组成都可以通过配置文件
         /// </summary>
         /// <returns></returns>
         public static AbstractAuditor Build()
         {
             AbstractAuditor pm = new PM()
             {
                 Name = "bbb"
             };
             AbstractAuditor charge = new Charge()
             {
                 Name = "ccc"
             };
             AbstractAuditor manager = new Manager()
             {
                 Name = "ddd"
             };
             AbstractAuditor chief = new Chief()
             {
                 Name = "eee"
             };
             AbstractAuditor ceo = new CEO()
             {
                 Name = "fff"
             };

             pm.SetNext(charge);
             charge.SetNext(manager);
             //pm.SetNext(manager);
             manager.SetNext(chief);
             chief.SetNext(ceo);
             ceo.SetNext(new ChiarMan()
             {
                 Name = "ggg"
             });
             return pm;
         }
     }

代码中存在多个if-else语句的情况下，此时可以考虑使用责任链模式来对代码进行重构

本文参考文档：

https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html

https://www.cnblogs.com/zhili/p/ChainOfResponsibity.html

https://www.cnblogs.com/abcdwxc/archive/2007/09/25/905622.html