设计模式篇章，源于网课的学习，以及个人的整理
在我们接收用户提交的字符时，常常会使用到过滤，在学习责任链模式前，我们是这样做的
1.定义一个类
public class MsgProcesser {
String msg;
public MsgProcesser(String msg) {
this.msg=msg;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String process() {
String r=msg.replace("<", "[").replaceAll(">", "]");
r=r.replaceAll("被就业", "就业");
r=r.replaceAll("敏感", "");
return r;
}
}
测试
public static void main(String[] args) {
String message="大家好:),<script>,敏感,被就业,网络授课没感觉,因为看不见大家伙儿";
MsgProcesser mp=new MsgProcesser(message);
System.out.println(mp.process());
}
往往添加数据会很不方便，于是，借用责任链的方式，我们可以这样写
1.定义一个接口，内部有抽象方法doFilter
package com.littlepage.testChainOfResponsibility;
public interface Filter {
String doFilter(String str);
}
2.定义一些不同的过滤器类实现过滤器接口，类似HTMLFilter，SensitiveFilter
package com.littlepage.testChainOfResponsibility;
public class HTMLFilter implements Filter{
@Override
public String doFilter(String str) {
return str.replaceAll("<", "[").replaceAll(">", "]");
}
}
package com.littlepage.testChainOfResponsibility;
public class SensitiveFilter implements Filter{
@Override
public String doFilter(String str) {
return str.replaceAll("敏感", "*");
}
}
3.进行主要链条的编写，就是新建一个类叫MsgProcesser，该类将这些方法进行串起来，使用foreach循环进行迭代进行过滤，在后续情况下，也就是说，你需要再添加过滤的关键字，就可以直接新建一个链条上的小块（也就是一个类），进行添加，而不用再去写其他东西
package com.littlepage.testChainOfResponsibility;
public class MsgProcesser {
Filter[] filter= {new HTMLFilter(),new SensitiveFilter()};
String msg;
public MsgProcesser(String msg) {
this.msg=msg;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String process() {
String r=msg;
for(Filter f:filter) {
r=f.doFilter(r);
}
return r;
}
}
图示：
或者说，你依然可以定义一个责任链类（FilterChain）用来代替MsgProcesser类，里面用ArrayList容器盛放filter
该代码为：
package com.littlepage.testChainOfResponsibility; import java.util.ArrayList;
import java.util.List; public class FilterChain {
List<Filter> filters=new ArrayList<>();
public FilterChain addFilter(Filter f) {
filters.add(f);
return this;
}
public String doFilter(String str) {
String r=str;
for (Filter filter : filters) {
r=filter.doFilter(r);
}
return r;
}
}
主方法的调用改为
package com.littlepage.testChainOfResponsibility;
public class Main {
public static void main(String[] args) {
String message="大家好:),<script>,敏感,被就业,网络授课没感觉,因为看不见大家伙儿";
FilterChain fc=new FilterChain();
fc.addFilter(new HTMLFilter()).addFilter(new SensitiveFilter());
System.out.println(fc.doFilter(message));
}
}
若该FilterChain也实现Filter接口，那么就可以自己添加自己的FilterChain了，很巧妙
由此可以拓展出，tomcat下可以加上request和response过滤器
代码如下：
package top.littlepage.designPattern.responsibilityChain;
public interface Filter {
void doFilter(Request req,Response res,FilterChain fc);
}
package top.littlepage.designPattern.responsibilityChain; import java.util.ArrayList;
import java.util.List; public class FilterChain implements Filter {
List<Filter> filters = new ArrayList<>();
int index = -; public FilterChain addFilter(Filter f) {
filters.add(f);
return this;
} public void doFilter(Request req, Response res, FilterChain fc) {
if (index == filters.size()-)
return;
index++;
filters.get(index).doFilter(req, res, fc); } }
package top.littlepage.designPattern.responsibilityChain;
public class HTTPFilter implements Filter{
@Override
public void doFilter(Request req, Response res,FilterChain fc) {
req.setRequestStr(req.getRequestStr().replaceAll("<", "[").replaceAll(">", "]"));
System.out.println("after reqHttp:"+req);
fc.doFilter(req, res, fc);
res.setResponseStr(res.getResponseStr().replaceAll("//", "pp"));
System.out.println("after resHttp:"+res);
}
}
package top.littlepage.designPattern.responsibilityChain;
public class Request {
private String requestStr;
public Request() {
requestStr="";
}
public Request(String requestStr) {
this.requestStr = requestStr;
}
public String getRequestStr() {
return requestStr;
}
public void setRequestStr(String requestStr) {
this.requestStr = requestStr;
}
@Override
public String toString() {
return "Request [requestStr=" + requestStr + "]";
}
}
package top.littlepage.designPattern.responsibilityChain;
public class Response {
private String responseStr;
public Response() {
responseStr="";
}
public Response(String responseStr) {
this.responseStr = responseStr;
}
public String getResponseStr() {
return responseStr;
}
public void setResponseStr(String responseStr) {
this.responseStr = responseStr;
}
@Override
public String toString() {
return "Response [responseStr=" + responseStr + "]";
}
}
package top.littlepage.designPattern.responsibilityChain;
public class SensitiveFilter implements Filter{
@Override
public void doFilter(Request req, Response res,FilterChain fc) {
req.setRequestStr(req.getRequestStr().replaceAll("sensitive", "***"));
System.out.println("after reqSen:"+req);
fc.doFilter(req, res, fc);
res.setResponseStr(res.getResponseStr().replaceAll("mingan", "notmingan"));
System.out.println("after resSen:"+res);
}
}
package top.littlepage.designPattern.responsibilityChain;
public class Test {
public static void main(String[] args) {
String str="<script>//abbbmingansensitive";
Request req=new Request(str);
Response res=new Response(str);
FilterChain fc=new FilterChain();
fc.addFilter(new HTTPFilter());
fc.addFilter(new SensitiveFilter());
fc.doFilter(req, res, fc);
}
}
控制台打印如下
可以看出，首先接收端进行接收request分别执行Http进行过滤req，执行Sensitive进行过滤req
到达服务端，开始原路返回，先执行Sensitive过滤器进行过滤，然后执行Http过滤器进行过滤，
这一系列变成了一个链条，将各个过滤器穿在一起，也就成了所说的责任链设计模式。
由于是一步一步进行拦截，所以说，也可以称作拦截器模式
由此可见：原理和tomcat的filter的大致原理一样，先原线路进行依次对请求值进行过滤，然后
再对客户端的返回值进行过滤