设计模式之责任链模式

最新推荐文章于 2023-09-28 09:48:37 发布
最新推荐文章于 2023-09-28 09:48:37 发布
阅读量1.0k 收藏
点赞数 1
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sundacheng1989/article/details/50441165
版权

责任链模式，Chain ofResponsibility,就是说有一系列的处理过程，这些处理过程有先后顺序，就跟ASP.NET Framework的Pipeline事件一样，挨个对request进行处理。

 

下面我们用一个简单的例子来说说这种设计模式。我们假设一种场景，有一条message（字符串）要从A传送到B，但是这个过程中会有多个处理过程，比如说过滤掉敏感字符("government"),并且把"haha"替换成笑脸"-^^-".

 

1.我们可以设定一个IFilter接口，然后让所有的处理过程都实现这个接口。然后我们设置一个Filter的集合，把所有的Filter都放到这个集合里边来。

class Program
    {
        static void Main(string[] args)
        {
            Message message = new Message()
            {
                ID = 1,
                Content = "Our government is good. haha"
            };

            FilterChain chain = new FilterChain();
            chain.AddFilter(new SensitiveWordsFilter());
            chain.AddFilter(new EmotionFaceFilter());

            chain.doFilter(message);

            Console.WriteLine(message.Content);
            Console.ReadLine();
        }
    }


    public class Message
    {
        public int ID { get; set; }

        public String Content { get; set; }
    }

    public interface IFilter
    {
        void doFilter(Message message);
    }

    public class SensitiveWordsFilter : IFilter
    {
        public void doFilter(Message message)
        {
            message.Content = message.Content.Replace("government", "***");
        }
    }

    public class EmotionFaceFilter : IFilter
    {
        public void doFilter(Message message)
        {
            message.Content = message.Content.Replace("haha", "-^^-");
        }
    }

    public class FilterChain
    {
        private readonly IList<IFilter> list;

        public void AddFilter(IFilter filter)
        {
            this.list.Add(filter);
        }

        public FilterChain()
        {
            this.list = new List<IFilter>();
        }

        public void doFilter(Message message)
        {
            foreach (var filter in list)
            {
                filter.doFilter(message);
            }
        }

    }

这段代码的运行结果如下图所示，一切按计划进行。



2.此时，我们的需求不仅仅局限在往一个Chain集合中加入Filter，现在我们需要向一个Chain集合中加入另一个Chain集合。这时候我们怎么办？我们可以让FilterChain也实现IFitler接口，那么我们就可以直接调用FilterChain的Add方法了。

class Program
    {
        static void Main(string[] args)
        {
            Message message = new Message()
            {
                ID = 1,
                Content = "Our government is good. haha  five"
            };

            FilterChain chain = new FilterChain();
            chain.AddFilter(new SensitiveWordsFilter());
            chain.AddFilter(new EmotionFaceFilter());

            FilterChain chain2 = new FilterChain();
            chain2.AddFilter(new NumberFilter());

            chain.AddFilter(chain2);
            chain.doFilter(message);

            Console.WriteLine(message.Content);
            Console.ReadLine();
        }
    }


    public class Message
    {
        public int ID { get; set; }

        public String Content { get; set; }
    }

    public interface IFilter
    {
        void doFilter(Message message);
    }

    public class SensitiveWordsFilter : IFilter
    {
        public void doFilter(Message message)
        {
            message.Content = message.Content.Replace("government", "***");
        }
    }

    public class EmotionFaceFilter : IFilter
    {
        public void doFilter(Message message)
        {
            message.Content = message.Content.Replace("haha", "-^^-");
        }
    }

    public class NumberFilter : IFilter
    {
        public void doFilter(Message message)
        {
            message.Content = message.Content.Replace("five", "5");
        }
    }

    public class FilterChain : IFilter
    {
        private readonly IList<IFilter> list;

        public void AddFilter(IFilter filter)
        {
            this.list.Add(filter);
        }

        public FilterChain()
        {
            this.list = new List<IFilter>();
        }

        public void doFilter(Message message)
        {
            foreach (var filter in list)
            {
                filter.doFilter(message);
            }
        }

    }

运行结果如下图所示。



对于第2种方式总结一下，就是如何能够让一个责任链加入到另一个责任链中。当然我们可以依次遍历这个责任链集合，然后一个个的加到另外的责任链中。但这种方法很繁琐。最简单方法是这样做，我们让FilterChain也实现IFilter接口，把它看成一个大个的Filter，然后FilterChain中进行处理的方法要与NumberFilter,SensitiveWordsFilter等这些具体的Filter中的方法同名，并且都是实现IFilter接口中的方法。

 

另外，还有一种链式编程的技巧。在FilterChain中，我们让每次AddFilter之后，都让其返回自身。这样我们所以的Add方法都能在一行代码中完成。

	public FilterChain AddFilter(IFilter filter)
        {
            this.list.Add(filter);
            return this;
        }

在使用的时候，就可以这样。

FilterChain chain = new FilterChain();chain.AddFilter(new SensitiveWordsFilter()).AddFilter(new EmotionFaceFilter());

3.现在我们的需求又变了。我们希望我们的责任链处理器能向ASP.NET Pipeline那样，去的时候按先后顺序处理Request,回来的时候按照顺序处理Repsone.

class Program
    {
        static void Main(string[] args)
        {
            Request request = new Request()
            {
                ID = 1,
                Content = "This is the orginal request string. "
            };

            Response response = new Response()
            {
                ID = 1,
                Content = "This is the orginal response string. "
            };

            FilterChain chain = new FilterChain();
            chain.AddFilter(new SensitiveWordsFilter())
                .AddFilter(new EmotionFaceFilter());

            FilterChain chain2 = new FilterChain();
            chain2.AddFilter(new NumberFilter());

            chain.AddFilter(chain2);
            chain.doFilter(request, response);

            Console.WriteLine(request.Content);
            Console.WriteLine();
            Console.WriteLine(response.Content);
            Console.ReadLine();
        }
    }


    public class Request
    {
        public int ID { get; set; }

        public String Content { get; set; }
    }

    public class Response
    {
        public int ID { get; set; }

        public String Content { get; set; }
    }

    public interface IFilter
    {
        void doFilter(Request request, Response response);
    }

    public class SensitiveWordsFilter : IFilter
    {
        public void doFilter(Request request, Response response)
        {
            request.Content = request.Content + " --SensitiveFilter In-- ";
            response.Content = response.Content + " --SensitiveFilter Out-- ";
        }
    }

    public class EmotionFaceFilter : IFilter
    {
        public void doFilter(Request request, Response response)
        {
            request.Content = request.Content + " --EmotionFaceFilter In-- ";
            response.Content = response.Content + " --EmotionFaceFilter Out-- ";
        }
    }

    public class NumberFilter : IFilter
    {
        public void doFilter(Request request, Response response)
        {
            request.Content = request.Content + " --NumberFilter In-- ";
            response.Content = response.Content + " --NumberFilter Out-- ";
        }
    }

    public class FilterChain : IFilter
    {
        private readonly IList<IFilter> list;

        public FilterChain AddFilter(IFilter filter)
        {
            this.list.Add(filter);
            return this;
        }

        public FilterChain()
        {
            this.list = new List<IFilter>();
        }

        public void doFilter(Request request, Response response)
        {
            foreach (var filter in list)
            {
                filter.doFilter(request, response);
            }
        }

    }

运行结果如下图所示。




但是这不太符合要求。因为进去的时候SensitiveFilter是第一个进行处理的，那么response出来的时候，这个应该是最后一个进行处理才对。

 

我们可以在FilterChain集合中设置一个变量index,然后一层层的调用。具体代码如下。

internal class Program
    {
        private static void Main(string[] args)
        {
            Request request = new Request()
            {
                ID = 1,
                Content = "This is the orginal request string. "
            };

            Response response = new Response()
            {
                ID = 1,
                Content = "This is the orginal response string. "
            };

            FilterChain chain = new FilterChain();
            chain.AddFilter(new SensitiveWordsFilter())
                .AddFilter(new EmotionFaceFilter());

            FilterChain chain2 = new FilterChain();
            chain2.AddFilter(new NumberFilter());

            chain.AddFilter(chain2);
            chain.doFilter(request, response, chain);

            Console.WriteLine(request.Content);
            Console.WriteLine();
            Console.WriteLine(response.Content);
            Console.ReadLine();
        }
    }


    public class Request
    {
        public int ID { get; set; }

        public String Content { get; set; }
    }

    public class Response
    {
        public int ID { get; set; }

        public String Content { get; set; }
    }

    public interface IFilter
    {
        void doFilter(Request request, Response response, FilterChain chain);
    }

    public class SensitiveWordsFilter : IFilter
    {
        public void doFilter(Request request, Response response, FilterChain chain)
        {
            request.Content = request.Content + " --SensitiveFilter In-- ";
            chain.doFilter(request, response, chain);
            response.Content = response.Content + " --SensitiveFilter Out-- ";
        }
    }

    public class EmotionFaceFilter : IFilter
    {
        public void doFilter(Request request, Response response, FilterChain chain)
        {
            request.Content = request.Content + " --EmotionFaceFilter In-- ";
            chain.doFilter(request, response, chain);
            response.Content = response.Content + " --EmotionFaceFilter Out-- ";
        }
    }

    public class NumberFilter : IFilter
    {
        public void doFilter(Request request, Response response, FilterChain chain)
        {
            request.Content = request.Content + " --NumberFilter In-- ";
            chain.doFilter(request, response, chain);
            response.Content = response.Content + " --NumberFilter Out-- ";
        }
    }

    public class FilterChain : IFilter
    {
        private readonly IList<IFilter> list;
        private int index = 0;

        public FilterChain AddFilter(IFilter filter)
        {
            this.list.Add(filter);
            return this;
        }

        public FilterChain()
        {
            this.list = new List<IFilter>();
        }

        public void doFilter(Request request, Response response, FilterChain chain)
        {
            if (index == list.Count)
            {
                return;
            }
            IFilter filter = list[index];
            index++;
            filter.doFilter(request, response, chain);
        }
    }

运行结果如图。符合最终的要求。



综合来讲，责任链模式，就是对于同一个对象进行有序的先后处理的一些工具类的集合。本文文字比较简单，但是代码很详细，希望大家能够从分析代码中有些收获。




孙大诚_SunRobin
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA设计模式之责任链模式详解
09-03
责任链模式（Chain of Responsibility）是一种行为设计模式，它的核心思想是将一系列处理请求的对象串联成一条链，每个对象称为处理者（Handler），并包含处理请求的逻辑以及将请求传递给下家的能力。请求沿着链传递...
C++设计模式之职责链模式
09-04
职责链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象能够处理该请求。在C++中，职责链模式通常用于解耦发送者和接收者，使得系统更加...
行为型设计模式——责任链模式
最新发布
庄小焱
09-28 2151
责任链模式(Chain of responsibility pattern): 通过责任链模式, 你可以为某个请求创建一个对象链. 每个对象依序检查此请求并对其进行处理或者将它传给链中的下一个对象。
责任链模式
每一天都为明天的博客
10-08 1463
SpringBoot之责任链模式
学习JavaScript设计模式之责任链模式
10-22
责任链模式是一种行为设计模式，它的核心思想是让多个对象有机会处理同一个请求，而不是将这个请求直接发送给特定的对象。这样做的好处是降低了请求发送者与接收者之间的耦合，使得系统更加灵活。在JavaScript中，...
JavaScript设计模式之职责链模式应用示例
10-18
职责链模式是一种行为设计模式，它的核心思想是建立一个处理请求的对象链，每个对象都包含对请求的处理逻辑，以及将请求传递给下一个对象的能力。这样，请求可以在链上逐个传递，直到某个对象处理它。这种模式可以...
请让责任链模式优雅起来
爱琴孩的博客
07-10 1942
责任链模式是一种行为设计模式， 允许你将请求沿着处理者链进行发送。收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。责任链的使用场景还是比较多的多条件流程判断：权限控制ERP 系统流程审批：总经理、人事经理、项目经理Java 过滤器 的底层实现 Filter如果不使用该设计模式，那么当需求有所改变时，就会使得代码臃肿或者难以维护，例如下面的例子假设现在有一个闯关游戏，进入下一关的条件是上一关的分数要高于xx游戏一共 3 个关卡进入第二关需要第一关的游戏得分大于等于 80进入第三关需
Android中的设计模式之责任链模式
weixin_33973600的博客
08-19 194
参考 《设计模式：可复用面向对象软件的基础 》5.1 Chain of responsibility 职责链 对象行为型模式 《Android源码设计模式解析与实战》第9章 使编程更有灵活性--责任链模式 意图 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链...
设计模式 - 责任链模式
STRANGE-P 的博客
04-22 815
责任链接的核心类，就是抽象类 IHandler、抽象类的子实现子类、还有就是业务类。当然在具体的使用前，我们需要根据业务场景灵活使用。对于每个抽象类的实现类，只需要关注自己的业务逻辑，抽象类的实现类只专注怎样做事，具体自己需要处理哪一种事，那就交给父类去决定。抽象类实现了请求传递的功能，抽象类实现请求的处理，这也是设计模式单一职责原则的体现。举例：银行里面有存款业务，然后也有很多币种类型（人民币、美元、日元）。
设计模式-责任链模式
养歌的博客
12-21 199
在设计模式系列的文章中之前已经为大家分享了创建型设计模式，感兴趣的小伙伴们可以再去翻看之前的分享。接下来开始分享设计模式三大类型中的行为型模式了，今天要分享的是责任链模式。 什么是责任链模式 责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。使多个对象都有机会处理请求，从而避免
设计模式第6讲——责任链模式（Chain）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-05 2464
责任链模式属于行为型模式。一、什么是责任链模式 二、组成 三、优缺点 四、应用场景4.1 应用实例4.2 程序场景 五、代码实现5.0 UML类图5.1 Approver（审批者）5.2 Master（校长）5.3 GradeLeader(年级组长）5.4 ClassAdviser（班主任）5.5 LeaveRequest(请假信息)5.6TestChain5.7 总结
.net设计模式-责任链模式
aifan2109的博客
09-16 248
行为型设计模式:关注对象与行为的分离 责任链模式:解决一个请求需要多个环节处理，环节还可能扩展 、变化、调整顺序等问题 下面是模拟一个审批的流程,context 是记录这一流程的上下文环境,如果按照最基本的写法为 1 //一个请假申请 2 ApplyContext context = new ApplyContext() 3 ...
Commons-chain:责任链框架
深入一点
06-28 2797
    Commons-chain是apache commons中的一个子项目,主要被使用在"责任链"(执行链)的场景中,struts中action的调用过程,就是使用了"chain"框架做支撑.如果你的项目中,也有基于此种场景的需求,可以考虑使用它.     所谓"责任链"就是:一系列有序的command能够按照顺序执行,并能够互相交换或者传递执行结果;和我们常说的"责任链"模式类似. ...
设计模式：责任链模式（Chain of Responsibility）
朱小厮的博客
04-04 5360
使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，知道有一个对象处理它为止。 责任链模式的角色： 1. 抽象处理者角色（Handler）：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的
理解与应用：设计模式之职责链模式解析
"设计模式之职责链模式" 职责链模式是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象处理这个请求。这种模式的关键在于，请求的发送者并不直接知道哪个对象会处理请求，而是将请求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值