【设计模式】责任链4-链接链

紧接着上一个问题来：

为了不要跟原来的代码冲突，又新建了一个工程，将所有代码放在一起。
代码清单：(为了测试简洁，去掉了FaceFilter.java)
Filter.java
FilterChain.java
HTMLFilter.java
Main.java
MsgProcessor.java
Request.java
Response.java
SesitiveFilter.java

因为新加入了Response和Request类，我们要改写几个类：
改写Filter.java:

package cn.edu.hpu.filter.web;

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

参数该成request和response

改写FilterChian：

package cn.edu.hpu.filter.web;


import java.util.List;
import java.util.ArrayList;


public class FilterChain implements Filter{
	List<Filter> filters=new ArrayList<Filter>();
	
	//返回值是FilterChain只为了在Main中满足链条式的编程
	public FilterChain addFilter(Filter f) {
		this.filters.add(f);
		return this;
	}
	
	@Override
	public void doFilter(Request request,Response response) {
		for(Filter f:filters){
			f.doFilter(request,response);
		}
	}
}

具体的各种Filter我们就应该这么做了(先处理request请求)：
HTMLFilter：

package cn.edu.hpu.filter.web;


public class SesitiveFilter implements Filter {
	@Override
	public void doFilter(Request request, Response response) {
		String r=request.getRequestStr().replace("偷盗", "和谐")
		   .replace("抢劫", "帮助");
		request.setRequestStr(r);
	}
}

HTMLFilter：

package cn.edu.hpu.filter.web;

public class HTMLFilter implements Filter {


	@Override
	public void doFilter(Request request, Response response) {
		//先处理带尖括号的信息
		String str=request.getRequestStr().replace('<', '[')
                    .replace('>', ']');
		request.setRequestStr(str);
	}


}

如果我们既想处理request又想处理response，处理反馈这种东西，应该在所有请求处理完毕之后，
再来处理我们这个反馈。因为我们反馈的信息肯定是根据请求最后处理的结果来决定的。

我们先删除掉MsgProcessor.java（因为现在这个类有些多余，不如将东西都放在Main类中去做）

在Main中：

package cn.edu.hpu.filter.web;


public class Main {
	public static void main(String[] args) {
		String msg="大家好：),<script>，偷盗，抢劫，我们要把设计模式学好";
		Request request=new Request();
		request.setRequestStr(msg);
		Response response=new Response();
		//response对象无反馈信息之前先设一个暂时的信息"response"
		response.setResponseStr("response");
		FilterChain fc=new FilterChain();
		fc.addFilter(new HTMLFilter())
		  .addFilter(new SesitiveFilter());//链条式写法


		fc.doFilter(request, response);
		System.out.println(request.getRequestStr());
		System.out.println(response.getResponseStr());
	}
}

测试结果：
大家好：),[script]，和谐，帮助，我们要把设计模式学好
response

现在我们只处理了request的信息，还没有处理response的信息

对于request和response我们要求的顺序是这样的：
当我们的一个request传过来的时候，被第一个Filter处理，接下来被第二、第三个Filter处理，
处理完成之后，会有response对象从服务器端反馈信息给我，这个反馈信息被处理的过程是，首先
被第三个进行处理，接下来被第二个处理，最后被第一个处理(有些像堆栈)。

上面说的实现起来要需要一些技巧。

我们先给HTMLFilter和SesitiveFilter类的request和response处理分别加上标记，
来观察一下过滤链的运行顺序：
HTMLFilter：

package cn.edu.hpu.filter.web;


public class HTMLFilter implements Filter {


	@Override
	public void doFilter(Request request, Response response) {
		//先处理带尖括号的信息
		String str=request.getRequestStr().replace('<', '[')
                    .replace('>', ']');
		request.setRequestStr(str+"----HTMLFilter");
		
		str=response.getResponseStr()+"----HTMLFilter";
		response.setResponseStr(str);
	}


}

SesitiveFilter：

package cn.edu.hpu.filter.web;


public class SesitiveFilter implements Filter {
	@Override
	public void doFilter(Request request, Response response) {
		String r=request.getRequestStr().replace("偷盗", "和谐")
		   .replace("抢劫", "帮助");
		request.setRequestStr(r+"----SesitiveFilter");
		
		r=response.getResponseStr()+"----SesitiveFilter";
		response.setResponseStr(r);
	}
}

Main的测试结果：
大家好：),[script]，和谐，帮助，我们要把设计模式学好----HTMLFilter----SesitiveFilter
response----HTMLFilter----SesitiveFilter

对于request请求这个过滤顺序是对的，但是对于response这个过滤顺序就不是刚刚我们所说的想要的
那种顺序，说明我们不可以在处理request的下面去直接处理response。想要完成这个功能，就需要一些扎实的编程技巧。

我们在Filter接口的doFilter方法中加入FilterChain的参数，这样一来，我们就可以在doFilter方法
中去控制使用FilterChain中各种Filter的顺序了。
Filter：

package cn.edu.hpu.filter.web;


public interface Filter {
	
	void doFilter(Request request,Response response,FilterChain fc);
}

其他各类加上此参数即可。
当我们处理完request信息之后，我可以拿FilterChain使用。
要改写一下FilterChain，好让它能去主动一个一个调用Filter，而不是像之前
的一次遍历着去处理信息：

package cn.edu.hpu.filter.web;

import java.util.List;
import java.util.ArrayList;


public class FilterChain implements Filter{
	List<Filter> filters=new ArrayList<Filter>();
	//记录运行到哪一个Filter了
	int index=0;
	
	//返回值是FilterChain只为了在Main中满足链条式的编程
	public FilterChain addFilter(Filter f) {
		this.filters.add(f);
		return this;
	}
	
	@Override
	public void doFilter(Request request,Response response,FilterChain fc) {
		if(index==filters.size()) return;
		
		Filter f=filters.get(index);
		index++;
		f.doFilter(request, response, fc);
		
	}
}

处理完request之后我们马上让FilterChain去调用下一个Filter：

package cn.edu.hpu.filter.web;

public class SesitiveFilter implements Filter {
	@Override
	public void doFilter(Request request, Response response,FilterChain fc) {
		String r=request.getRequestStr().replace("偷盗", "和谐")
		   .replace("抢劫", "帮助");
		request.setRequestStr(r+"----SesitiveFilter");
		
		fc.doFilter(request, response, fc);
		
		r=response.getResponseStr()+"----SesitiveFilter";
		response.setResponseStr(r);
	}
}

package cn.edu.hpu.filter.web;

public class HTMLFilter implements Filter {


	@Override
	public void doFilter(Request request, Response response,FilterChain fc) {
		//先处理带尖括号的信息
		String str=request.getRequestStr().replace('<', '[')
                    .replace('>', ']');
		request.setRequestStr(str+"----HTMLFilter");


		fc.doFilter(request, response, fc);
		
		str=response.getResponseStr()+"----HTMLFilter";
		response.setResponseStr(str);
	}

}

我们来测试Main，测试结果为：
大家好：),[script]，和谐，帮助，我们要把设计模式学好----HTMLFilter----SesitiveFilter
response----SesitiveFilter----HTMLFilter

刚好达到我们想要的结果，使response的处理是逆向的(request是从栈顶到站底，response是从栈底到栈顶)！

大家可能还没摸清头脑，我们分析一下：
看Main：

package cn.edu.hpu.filter.web;


public class Main {
	public static void main(String[] args) {
		String msg="大家好：),<script>，偷盗，抢劫，我们要把设计模式学好";
		Request request=new Request();
		request.setRequestStr(msg);
		Response response=new Response();
		//response对象无反馈信息之前先设一个暂时的信息"response"
		response.setResponseStr("response");
		FilterChain fc=new FilterChain();
		fc.addFilter(new HTMLFilter())
		  .addFilter(new SesitiveFilter());//链条式写法


		fc.doFilter(request, response,fc);
		System.out.println(request.getRequestStr());
		System.out.println(response.getResponseStr());
	}
}

我们首先调用的是FilterChain的doFilter方法，这个时候，FilterChain中的index是0，也就是说调用了第一个Filter即HTMLFilter，这个时候在HTMLFilter中处理了request的信息之后(此时是request信息被第一次处理，并且加了标记"----HTMLFilter")，调用了FilterChain的doFilter方法，此时在FilterChain的doFilter方法中又进一步调用了下一个Filter，这样下来，最终调取了最后的SesitiveFilter，在SesitiveFilter中进一步处理了request的信息(此时是request信息被第二次处理，并且加了标记"----SesitiveFilter")，然后继续执行FilterChain的doFilter方法，发现index已经到头了，方法结束，这个时候开始执行下面的处理Response的代码(此时response信息被第一次处理，并且加了标记"----SesitiveFilter")，处理完毕时候跳出了递归，最后又回到了HTMLFilter中，接下去处理response(此时response信息被第二次处理，并且加了标记"----HTMLFilter")，


其实运行一下，仔细思考一下(前提是你理解递归的概念)，理解起来并不难。难得的是，JavaWeb中对Servlet的过滤器就是采用类似这种机制来完成请求和反馈的过滤的(其实还不如刚刚我们设计的那种)。


至此责任链就探讨完了，大家是不是也理解了Filter的一些原理？
在此感谢马士兵老师的"设计模式"视频的讲解。

转载请注明出处：http://blog.csdn.net/acmman/article/details/44673483