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 <= 8)
            {
                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 <= 16)
            {
                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 <= 24)
            {
                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 <= 48)
            {
                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 <= 96)
            {
                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 <= 1000000)
            {
                context.AuditResult = true;
                context.AuditRemark = "允许请假！";
            }
            else
            {
                base.AuditNext(context);
                //....
            }
        }
    }

前端调用：

                ApplyContext context = new ApplyContext()
                {
                    Id = 1,
                    Name = "aaa",
                    Hour = 100,
                    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