背景：要把<script>等<>html标签替换掉；把敏感词屏蔽或者替换等；
1.刚开始可能这么写：
public class Main {
public static void main(String[] args) {
String msg = "大家好:),<script>,敏感，被就业，撒的合法了思考的环境法拉盛看到回复";
MsgProcessor mp = new MsgProcessor();
mp.setMsg(msg);
String result = mp.processor();
System.out.println(result);
}
}
public class MsgProcessor {
private String msg;
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String processor(){
//process the html tag<>
String r = msg.replace('<', '[').replace('>', ']');
//process the sensitive words
r = r.replace("被就业", "就业")
.replace("敏感","");
return r;
}
}
但是上面写的缺点：
如果还有其他的逻辑，其他的替换，那么又要在processor里面写其他的替换法则，不利于扩展；
2.于是换成下面写法：
定义接口Filter：
public interface Filter {
String doFilter(String str);
}
处理html tag的类：
public class HTMLFilter implements Filter {
@Override
public String doFilter(String str) {
//process the html tag<>
String r = str.replace('<', '[').replace('>', ']');
return r;
}
}
处理敏感词的类：
public class SensitiveFilter implements Filter {
@Override
public String doFilter(String str) {
//process the sensitive words
String r = str.replace("被就业", "就业")
.replace("敏感","");
return r;
}
}
MsgProcessor：
public class MsgProcessor {
private String msg;
private Filter[] filters = {new HTMLFilter(), new SensitiveFilter()};
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String processor(){
String r = msg;
for(Filter f : filters){
r = f.doFilter(r);
}
return r;
}
}
运行测试main，正确得到结果；
这样做的好处是：
新添加的规则可以放在filters数组的任意顺序上；
新添加的过滤规则可以任意扩展，只要实现Filter接口，并且实现方法，再添加进filters数组就可以了；
但是现在考虑一个问题：
如果已经存在一个过滤器链了，要想把这整个过滤器链加到原来的逻辑里面，怎么做呢？
3.修改为如下：
FilterChain.java:
public class FilterChain implements Filter{
List<Filter> filters = new ArrayList<Filter>();
public FilterChain addFilter(Filter f){
this.filters.add(f);
return this;
}
public String doFilter(String str){
String r = str;
for(Filter f: filters){
r = f.doFilter(r);
}
return r;
}
}
MsgProcessor:
public class MsgProcessor {
private String msg;
private FilterChain fc;
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public FilterChain getFc() {
return fc;
}
public void setFc(FilterChain fc) {
this.fc = fc;
}
public String processor(){
return fc.doFilter(this.msg);
}
}
Main:
public class Main {
public static void main(String[] args) {
String msg = "大家好:),<script>,敏感，被就业，撒的合法了思考的环境法拉盛看到回复";
MsgProcessor mp = new MsgProcessor();
FilterChain fc = new FilterChain();
//设置好过滤规则链
fc.addFilter(new HTMLFilter())
.addFilter(new FaceFilter());
FilterChain fc2 = new FilterChain();
fc2.addFilter(new SensitiveFilter());
fc.addFilter(fc2);
mp.setMsg(msg);
mp.setFc(fc);
String result = mp.processor();
System.out.println(result);
}
}
运行main，打印：
大家好^_^,[script],，就业，撒的合法了思考的环境法拉盛看到回复
4.既处理发送到服务端，也处理从服务端返回到客户端：
现在只是消息从一头发往另一头进行的过滤，而现实之中往往是消息从客户端发往服务器端，服务器端也有一个反馈，
现在想做这样一个过滤器，既可以过滤从客户端发往服务器端的消息，也可以过滤从服务器端返回来的消息；
怎么做呢？
正如struts2的interceptor和tomcat等容器的filter都是这样做的；既处理过去的消息，也处理回来的消息；
把request、response交给过滤器的话，过滤器既能把request对象处理，也能把response对象处理掉；
处理request的过滤器的顺序和处理response的过滤器的顺序正好是相反的：
这里简单使用Request中包含一个string、Response中包含一个string来简单模拟：
上代码：
Request：
package com.cy.dp.filter;
public class Request {
String requestStr;
public String getRequestStr() {
return requestStr;
}
public void setRequestStr(String requestStr) {
this.requestStr = requestStr;
}
}
Response：
package com.cy.dp.filter;
public class Response {
String responseStr;
public String getResponseStr() {
return responseStr;
}
public void setResponseStr(String responseStr) {
this.responseStr = responseStr;
}
}
Filter：
package com.cy.dp.filter;
public interface Filter {
void doFilter(Request request, Response response, FilterChain chain);
}
HTMLFilter：
package com.cy.dp.filter;
public class HTMLFilter implements Filter {
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
//process the html tag<>
request.requestStr = request.requestStr.replace('<', '[').replace('>', ']') + "----HTMLFilter()";
chain.doFilter(request, response, chain);
response.responseStr += "----HTMLFilter()";
}
}
SensitiveFilter：
package com.cy.dp.filter;
public class SensitiveFilter implements Filter {
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
//process the sensitive words
request.requestStr = request.requestStr.replace("被就业", "就业").replace("敏感","") + "----SensitiveFilter()";
chain.doFilter(request, response, chain);
response.responseStr += "----SensitiveFilter()";
}
}
FaceFilter：
package com.cy.dp.filter;
public class FaceFilter implements Filter {
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
//process the face
request.requestStr = request.requestStr.replace(":)", "^_^") + "----FaceFilter()";
chain.doFilter(request, response, chain);
response.responseStr += "----FaceFilter()";
}
}
FilterChain：
package com.cy.dp.filter; import java.util.ArrayList;
import java.util.List; public class FilterChain implements Filter{
List<Filter> filters = new ArrayList<Filter>();
int index = 0; public FilterChain addFilter(Filter f){
this.filters.add(f);
return this;
} @Override
public void doFilter(Request request, Response response, FilterChain chain) {
if(index==filters.size()) return; Filter f = filters.get(index);
index ++;
f.doFilter(request, response, chain);
}
}
测试代码Main：
package com.cy.dp.filter;
public class Main {
public static void main(String[] args) {
String msg = "大家好:),<script>,敏感，被就业，撒的合法了思考的环境法拉盛看到回复";
Request request = new Request();
request.setRequestStr(msg);
Response response = new Response();
response.setResponseStr("response");
//设置好过滤规则链
FilterChain fc = new FilterChain();
fc.addFilter(new HTMLFilter())
.addFilter(new SensitiveFilter())
.addFilter(new FaceFilter());
fc.doFilter(request, response, fc);
System.out.println(request.getRequestStr());
System.out.println(response.getResponseStr());
}
}
运行结果：
大家好^_^,[script],，就业，撒的合法了思考的环境法拉盛看到回复----HTMLFilter()----SensitiveFilter()----FaceFilter()
response----FaceFilter()----SensitiveFilter()----HTMLFilter()