设计模式之责任链模式

最新推荐文章于 2023-06-07 20:49:07 发布
最新推荐文章于 2023-06-07 20:49:07 发布
阅读量678 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 Filter 责任链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cdu09/article/details/9771989
版权

一

如果要对这样的字符串“大家好:)，<script>，敏感，设计模式，责任链模式”进行过滤，把其中的“:)、<、>、敏感”等字眼过滤掉，那么可以定义一个接口，实现了此接口的类可以对要过滤的字符串进行过滤，接口如下：

public interface Filter {

	public String doFilter(String string);
}

实现此接口用于过滤“:)”的类如下：

public class FaceFilter implements Filter {

	@Override
	public String doFilter(String string) {
		return string.replace(":)", "^V^");
	}

}

用于过滤“<、>”的类如下：

public class HTMLFilter implements Filter {

	@Override
	public String doFilter(String string) {
		return string.replace("<", "[").replaceAll(">", "]");
	}

}

用于过滤“敏感”等敏感字眼儿的类如下：

public class SensitiveFilter implements Filter {

	@Override
	public String doFilter(String string) {
		return string.replace("敏感", "***");
	}

}

再定义一个专门用来进行过滤的处理类如下：

public class MsgProcessor {
	
	private String msg;
	private Filter[] filters;
	
	public MsgProcessor(String msg, Filter[] filters) {
		this.msg = msg;
		this.filters = filters;
	}
	
	public String process() {
		for(Filter filter : this.filters) {
			this.msg = filter.doFilter(this.msg);
		}
		return this.msg;
	}

}

只要传入要过滤的字符串和过滤器就可以实现过滤的效果，如下：

public class Client {

	public static void main(String[] args) {
		String msg = "大家好:)，<script>，敏感，设计模式，责任链模式";
		
		Filter[] filters = new Filter[]{new HTMLFilter(), new SensitiveFilter(), new FaceFilter()};
		MsgProcessor processor = new MsgProcessor(msg, filters);
		
		String result = processor.process();
		System.out.println(result);
	}

}

最后，输出结果为“大家好^V^，[script]，***，设计模式，责任链模式”，即实现了过滤的功能，当然，要真正地实现过滤可不会这么简单，这里只是起到简单的说明作用。

可以发现这里的三个过滤类类似处于一条链条上，有顺序，挨个执行过滤功能，多个过滤器用在一起就形成了过滤器链，如下图所示：

既然多个过滤器用在一起就形成了过滤器链条，那么可以换种方式更直观的体现“链”这个概念，新建一个类叫做"FilterChain"如下：

public class FilterChain {
	
	private List<Filter> filterList = new ArrayList<Filter>();
	
	public FilterChain addFilter(Filter filter) {
		this.filterList.add(filter);
		return this;
	}
	
	public String doFilter(String msg) {
		String result = msg;
		for(Filter filter : this.filterList) {
			result = filter.doFilter(result);
		}
		return result;
	}

}

把多个过滤器先装在一个List中，再做处理，是不是更能体现“链”这个概念了呢？接着，修改上面的MsgProcessor类，如下：

public class MsgProcessor {
	
	private String msg;
	private FilterChain chain;
	
	public MsgProcessor(String msg, FilterChain chain) {
		this.msg = msg;
		this.chain = chain;
	}
	
	public String process() {
		return this.chain.doFilter(this.msg);
	}

}

最后是客户端调用，如下：

public class Client {

	public static void main(String[] args) {
		String msg = "大家好:)，<script>，敏感，设计模式，责任链模式";
		
		FilterChain chain = new FilterChain();
		chain.addFilter(new HTMLFilter())
			 .addFilter(new SensitiveFilter())
			 .addFilter(new FaceFilter());
		MsgProcessor processor = new MsgProcessor(msg, chain);
		
		String result = processor.process();
		System.out.println(result);
	}

}

一样起到了过滤的效果，注意观察FilterChain类中有一个与Filter接口中定义的方法同名的doFilter方法，这并不是偶然，这是有好处的，FilterChain中的处理方法也叫做doFilter是因为当FilterChain类也实现了Filter方法时，不用更改方法名，就能实现往已经存在的过滤器链中加入新的过滤器链，形成一个新的过滤器链，如下图，让FilterChain类实现Filter接口：

/**
 * 让FilterChain类也实现Filter接口，不仅能往过滤器链条中加入新的过滤器，
 * 还能实现往已存在的过滤器链中加入新的过滤器链条
 * @author Administrator
 *
 */
public class FilterChain implements Filter{
	
	private List<Filter> filterList = new ArrayList<Filter>();
	
	public FilterChain addFilter(Filter filter) {
		this.filterList.add(filter);
		return this;
	}
	
	@Override
	public String doFilter(String msg) {
		String result = msg;
		for(Filter filter : this.filterList) {
			result = filter.doFilter(result);
		}
		return result;
	}

}

客户端在已存在的过滤器链中加入新的过滤器链：

public class Client {

	public static void main(String[] args) {
		String msg = "大家好:)，<script>，敏感，设计模式，责任链模式";
		
		FilterChain chain01 = new FilterChain();  //过滤器链01
		chain01.addFilter(new HTMLFilter())
			 .addFilter(new SensitiveFilter());
		
		FilterChain chain02 = new FilterChain();  //过滤器链02
		chain02.addFilter(new FaceFilter());
		 
		chain01.addFilter(chain02);   //往过滤器链01中加入过滤器链02形成新的过滤器链
		
		MsgProcessor processor = new MsgProcessor(msg, chain01);
		
		String result = processor.process();
		System.out.println(result);
	}

}

二

以上的过程中实现的都是单向的过滤，如果要模拟“客户端对服务器端的请求”和“服务器端处理客户端请求并返回”，在请求和返回的过程中都进行过滤，又该怎么办呢？新建两个类Request和Response，用于模拟请求对象和返回对象，如下：

Request类：

public class Request {

	private String requestMsg;
	
	public String getRequestMsg() {
		return requestMsg;
	}

	public void setRequestMsg(String requestMsg) {
		this.requestMsg = requestMsg;
	}

	public Request(String requestMsg) {
		this.requestMsg = requestMsg;
	}
	
}

Response类：

public class Response {

	private String responseMsg;
	
	public String getResponseMsg() {
		return responseMsg;
	}

	public void setResponseMsg(String responseMsg) {
		this.responseMsg = responseMsg;
	}

	public Response(String responseMsg) {
		this.responseMsg = responseMsg;
	}
	
}

注意：这里要实现的并不是对请求和返回进行同时过滤，而是当对请求过滤完毕后再对返回进行过滤，且过滤执行的顺序的相反的，如下图：

既然是实现对请求过滤完毕后再对返回进行过滤，那么在执行一个过滤器完毕后应该继续调用下一个过滤器继续对请求进行过滤，而不能当一个过滤器对请求过滤完毕后马上执行对返回的过滤，所以上一个过滤器应该知道下一个过滤器；而且现在处理的是双向的过滤，而不是之前单向的过滤，所以应该修改Filter接口，如下：

public interface Filter {

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

当然，之前实现此接口的过滤器也要修改，首先是FilterChain类，现在这个类的功能是判断到底还有没有下一个过滤器，如果有取出来并执行它就实现了过滤器调用下一个过滤器，如果没有了，那么说明执行到了过滤器链的最后，说明对一个方向的过滤已过滤完毕，那么应该对另一个方向进行过滤了，所以返回，将控制权交给调用它的那个过滤器，执行对另一个方向的过滤开始，如下：

/**
 * 让FilterChain类也实现Filter接口，不仅能往过滤器链条中加入新的过滤器，
 * 还能实现往已存在的过滤器链中加入新的过滤器链条
 * @author Administrator
 *
 */
public class FilterChain implements Filter{
	/**
	 * 用于判断下一个过滤器
	 */
	private int index;
	private List<Filter> filterList = new ArrayList<Filter>();
	
	public FilterChain addFilter(Filter filter) {
		this.filterList.add(filter);
		return this;
	}
	
	@Override
	public void doFilter(Request request, Response response, FilterChain chain) {
		if(this.index == this.filterList.size()) {
			return;
		}
		Filter filter = this.filterList.get(this.index++);
		filter.doFilter(request, response, chain);
	}

}

然后继续修改其他实现了Filter接口的过滤器类：

HTMLFilter类：

public class HTMLFilter implements Filter {

	@Override
 	public void doFilter(Request request, Response response, FilterChain chain) {
  		request.setRequestMsg(
    			request.getRequestMsg().replace("<", "[").replaceAll(">", "]")
  		);//对请求进行过滤
  
  		chain.doFilter(request, response, chain); //继续对请求进行过滤，执行下一个过滤器
  
  		//当对请求过滤完毕后，控制前交到当前过滤器，才会执行对返回的过滤
  		response.setResponseMsg(response.getResponseMsg() + "-->HTMLFilter");
	}
}

SensitiveFilter类：

public class SensitiveFilter implements Filter {

	@Override
 	public void doFilter(Request request, Response response, FilterChain chain) {
  		request.setRequestMsg(
			request.getRequestMsg().replace("敏感", "***")
  		);//对请求进行过滤
  
  		chain.doFilter(request, response, chain); //继续对请求进行过滤，执行下一个过滤器
  
  		//当对请求过滤完毕后，控制前交到当前过滤器，才会执行对返回的过滤
  		response.setResponseMsg(response.getResponseMsg() + "-->SensitiveFilter");
	}
}

FaceFilter类：

public class FaceFilter implements Filter {

	@Override
 	public void doFilter(Request request, Response response, FilterChain chain) {
  		request.setRequestMsg(
    			request.getRequestMsg().replace(":)", "^V^")
  		);//对请求进行过滤
    
  		chain.doFilter(request, response, chain); //继续对请求进行过滤，执行下一个过滤器
  
  		//当对请求过滤完毕后，控制前交到当前过滤器，才会执行对返回的过滤
  		response.setResponseMsg(response.getResponseMsg() + "-->FaceFilter");
	}
}

修改MsgProcessor类：

public class MsgProcessor {
	
	private Request request;
	private Response response;
	private FilterChain chain;
	
	public MsgProcessor(Request request, Response response, FilterChain chain) {
		this.request = request;
		this.response = response;
		this.chain = chain;
	}
	
	public void process() {
		this.chain.doFilter(this.request, this.response, this.chain);
	}

}

最后，即是客户端调用：

public class Client {

	public static void main(String[] args) {
		Request request = new Request("大家好:)，<script>，敏感，设计模式，责任链模式");
		Response response = new Response("对返回过滤开始");
		
		FilterChain chain01 = new FilterChain();  //过滤器链01
		chain01.addFilter(new HTMLFilter())
			 .addFilter(new SensitiveFilter());
		
		FilterChain chain02 = new FilterChain();  //过滤器链02
		chain02.addFilter(new FaceFilter());
		 
		chain01.addFilter(chain02);   //往过滤器链01中加入过滤器链02形成新的过滤器链
		
		MsgProcessor processor = new MsgProcessor(request, response, chain01);
		
		processor.process();
		
		System.out.println(request.getRequestMsg());
		System.out.println(response.getResponseMsg());
	}

}

输入如下：

可以发现，对请求和返回过程均实现了过滤，且是先对请求过滤完毕后，再返回进行过滤。

如果在某个过滤器中发现了某个条件不满足，那么还可以直接返回而不继续向下执行，以上代码不变，修改SensitiveFilter如下：

public class SensitiveFilter implements Filter {

	@Override
 	public void doFilter(Request request, Response response, FilterChain chain) {
  		request.setRequestMsg(
   			 request.getRequestMsg().replace("敏感", "***")
  		);//对请求进行过滤
  
  		if(request.getRequestMsg().contains("123")) {//条件
   			chain.doFilter(request, response, chain); //继续对请求进行过滤，执行下一个过滤器
  		}
  
  		//当对请求过滤完毕后，控制前交到当前过滤器，才会执行对返回的过滤
  		response.setResponseMsg(response.getResponseMsg() + "-->SensitiveFilter");
 	}
}

输出如下：可以发现，如果SensitiveFilter后面还有需要执行的逻辑或者过滤器，当条件不满足时就直接返回了，根本不会执行后面的逻辑或过滤器

三、总结

以上就是有关责任链模式的设计，最后的Filter接口是不是和Servlet中的Filter接口类似呢？大笑



 

漂流在深圳
关注
专栏目录
java常用设计模式
anyudong1016的博客
04-25 237
设计模式分为三种类型，共23种： 创建型模式：单例模式、建造者模式、工厂模式、原型模式 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式 行为型模式：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式 以下主要讲解： 创建型模式：单例模式、建造者模式、工厂模式 结构型模式：适配器模式、代理模式 行为型模式：模板方法模式、策略模式 一、创建型模式例子 单例模式： 对应的类: SingleTon.java 参考博客：h
设计模式-适配器
qq_44928217的博客
08-27 170
摘自 java编程思想 177p 需求: 现有处理器类Processor.滤波器类型Waveform,filter,两者的接口方法类似,名字相同,返回值不同. 因为Apply.process方法和Processor耦合过紧,滤波器无法复用. 适配器:维护一个已有的接口(在本例中为Fliter接口),为了能够服用Apply.process方法,需要适配器实现(implements)目标接口. 解决方...
设计模式（策略模式详解）Java实现
flower_boboji的博客
12-24 394
public class Processor { public String name(){ return getClass().getSimpleName(); } Object process (Object input){ return input; } }
设计模式——职责链模式
看不懂的男孩的博客
08-24 235
职责链模式应用场景，Spring中的过滤器源码分析，在其他框架中职责链模式的实现
spring用到的设计模式
weixin_42274562的博客
10-31 164
个人总结
JAVA设计模式之责任链模式详解
09-03
责任链模式（Chain of Responsibility）是一种行为设计模式，它的核心思想是将一系列处理请求的对象串联成一条链，每个对象称为处理者（Handler），并包含处理请求的逻辑以及将请求传递给下家的能力。请求沿着链传递...
C++设计模式之职责链模式
09-04
职责链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象能够处理该请求。在C++中，职责链模式通常用于解耦发送者和接收者，使得系统更加...
Python设计模式之职责链模式原理与用法实例分析
01-20
本文实例讲述了Python设计模式之职责链模式原理与用法。分享给大家供大家参考，具体如下： 职责链模式(Chain Of Responsibility):使多个对象都有机会处理请求，从而避免发送者和接收者的耦合关系。将对象连成链并...
php设计模式之职责链模式定义与用法经典示例
01-02
* @desc php设计模式之职责链模式（责任链模式） 定义：顾名思义，责任链模式为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。 在...
c++-设计模式之责任链模式(Chain of Responsibility Pattern)
最新发布
09-20
责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许将请求的发送者和接收者解耦。通过将请求沿着处理链传递，直到有对象处理该请求为止，这种模式避免了请求发送者与具体处理者之间的紧...
策略设计模式
zhaoyingkun的专栏
03-05 396
package Interface; //这是一般方法，Test_Exercise11B将用返回值为斜边类型的方法，结合多态实现 //这是完全解耦这一节的第一个例题，这是自己写的，B是书本上的方法 import static Test_purview.print.*; public class Test_Exercise11A { public static void main(String[]
Spring 框架中常见的九种设计模式
qq_69531342的博客
06-07 247
source 接口是具体资源访问策略的抽象，也是所有资源访问类所实现的接口。定位并打开资源，返回资源对应的输入流。每次调用都返回新的输入流。调用者必须负责关闭输入流。返回 Resource 所指向的资源是否存在。返回资源文件是否打开，如果资源文件不能多次读取，每次读取结束应该显式关闭，以防止资源泄漏。返回资源的描述信息，通常用于资源处理出错时输出该信息，通常是全限定文件名或实际 URL。返回资源对应的 File 对象。返回资源对应的 URL 对象。
【设计模式】策略模式
南瓜的博客
05-31 204
具体代码 public interface ActionInterface { /** * 吃喝拉撒 接口 */ void eat(); void drink(); void put(); void sleep(); } public class Dog implements ActionInterface { @Override public void eat() { System.out.println(“狗吃”); } @Override public void drink() { S.
Java中的设计模式之抽象工厂模式
u013208623的博客
12-22 1327
抽象工厂模式是一种创建型设计模式，它提供了一种方法来创建一组相关或依赖的对象，而无需指定他们的具体类。
Java设计模式之责任链模式（简单易懂）
热门推荐
小天狼星的博客
10-29 1万+
前言： 责任链模式（Chain of Responsibility）: 使多个对象都有机会处理同一请求，从而避免请求的发送者和接受者之间的耦合关系，每个对象都是一个处理节点，将这些对象连成一条链，并沿着这条链传递该请求。 网上有很多朋友已经对该模式介绍的非常详细了，也有案例帮助理解，可参考 Java设计模式之职责链模式 一篇文章搞懂Java设计模式之责任链模式_lzy_tinyjoy-CSDN博客_java责任链模式 ...
Camel中的几个重要概念之 Processor
Willem's Blog
01-22 1589
Processor Processor接口是用来表示一个处理消息的类， 这个接口的定义如下。 Processor package org.apache.camel; public interface Processor {     void process(Exchange exchange) throws Exception; } 注意Process()方法中的参数是一个Exchange而...
设计模式之——策略模式
Water的博客
05-01 1232
转载请注明出处：http://blog.csdn.net/binbinqq86/article/details/71023871 今天要讲解的是设计模式之——策略模式(Strategy)。理论概念性的东西先不讲，下面先上场景和案例： 小明所在的公司想要设计一款交通出行帮助系统，提供全方位的详细出行说明帮助，包含具体路线，花费，耗时等等。。。由于小明是公司主程，毫无疑问，主管把这个艰巨而光荣的任务交给了他，小明拍着
设计模式（一）：策略模式+简单工厂模式
花无名
04-06 1118
策略模式：      对同一个动作，在不同的时间有不同的算法；      对客户端隐藏算法的具体实现，彼此独立。 简单工厂模式：      通过一个类来确定产生哪一个实例。 接下来这个例子是对图像进行旋转，缩放，平移的操作。这个是策略模式和简单工厂模式的结合应用。 在对图像进行着三种操作的时候，读入图片，获取图像像素矩阵，显示图片，这些动作是都要进行的，因此提取出来，作为父类的
命令处理器模式(Command Processor)的思考
beafather的专栏
01-23 4130
命令处理器模式(Command Processor)的思考 1.Command Processor模式的概述 具体请参考GOF或者POSA1。 2.思考 1.对于每个命令要求的参数怎么处理？ 对于这个问题，一开始我看到这个模式的时候总感觉不理解，因为每个命令千差万别，尤其是每个命令对于参数的要求是不同的，为什么在定义命令的excecute()函数的时候总是没有参数呢？转而又想，不
理解与应用：设计模式之职责链模式解析
"设计模式之职责链模式" 职责链模式是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象处理这个请求。这种模式的关键在于，请求的发送者并不直接知道哪个对象会处理请求，而是将请求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值