设计模式——责任链模式_设计模式学生向辅导员请假

责任链模式

定义

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

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

解释

上图为学校请假的流程。对于一个学生，在企业微信中提交请假请求，首先由辅导员进行处理，辅导员如果没有权限则交由学院领导处理，学院领导如果没有权限处理则交由学校领导处理。蓝色的为请求方，黄色的为处理方。

这种模式的特点是对于请求方，只要把相应的请求交给某个固定的人即可，而不需要关心最终是谁处理的；而对于处理方只要知道当前的请求能否处理，如果能则处理返回，如果不能，则交由上级处理。

优缺点

优点：可以减少请求方的决定，请求方仅需将请求交给指定的人即可；可以降低耦合度，将请求的发送者和接受者解耦；各个环节相互独立，即每一个处理者仅知道上一级处理者和下一级处理者，而不知道整个流程。

缺点：降低系统性能，比如我要请假一个学期，那么我可以直接将请求发送给学校管理员而不是辅导员。

代码Demo

public abstract class Handler
    {
        private Handler _nextHandler;

        public Response HandleMessage(Request request)
        {
            Response response = null;
            //判断是否是自己的处理级别
            if (request.GetRequestLevel().Equals(this.GetHandlerLevel()))
            {
                response = Echo(request);
            }
            else
            {                //不属于自己的处理级别，判断是否有下一个处理者
                if (_nextHandler != null)
                {
                    response = _nextHandler.HandleMessage(request);
                }
            }

            return response;
        }
        //设置下一个处理者
        public void SetNextHandler(Handler handler)
        {
            _nextHandler = handler;
        }
        //每个处理者都必须实现处理任务
        protected abstract Response Echo(Request request);
        //每个处理者都有一个处理级别
        protected abstract Level GetHandlerLevel();
    }

    public class ConcreteHandler1 : Handler
    {
        /// <summary>
        /// 定义自己的业务逻辑
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected override Response Echo(Request request)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 设置自己的处理级别
        /// </summary>
        /// <returns></returns>
        protected override Level GetHandlerLevel()
        {
            throw new NotImplementedException();
        }
    }

    public class ConcreteHandler2 : Handler
    {
        /// <summary>
        /// 定义自己的业务逻辑
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected override Response Echo(Request request)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 设置自己的处理级别
        /// </summary>
        /// <returns></returns>
        protected override Level GetHandlerLevel()
        {
            throw new NotImplementedException();
        }
    }

    public class ConcreteHandler3 : Handler
    {
        /// <summary>
        /// 定义自己的业务逻辑
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected override Response Echo(Request request)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 设置自己的处理级别
        /// </summary>
        /// <returns></returns>
        protected override Level GetHandlerLevel()
        {
            throw new NotImplementedException();
        }
    }

    class Program
    {

        private static void Main(string[] args)
        {            //声明所有的处理节点 
            Handler handler1 = new ConcreteHandler1();

            Handler handler2 = new ConcreteHandler2();

            Handler handler3 = new ConcreteHandler3();
            //设置链中的阶段顺序
            handler1.SetNextHandler(handler2);

            handler2.SetNextHandler(handler3);
            //提交请求，返回结果
            handler1.HandleMessage(new Request());

            Console.ReadKey();
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120