Filter（下）

一、Filter的部署——注册Filter

<filter>
  	<filter-name>MappingFilter</filter-name>
  	<filter-class>cn.itcast.web.filter.MappingFilter</filter-class>
	<init-param>
		<param-name>word_file</param-name>	
		<param-value>/WEB-INF/word.txt</param-value>
	</init-param>
  </filter>
  <filter-mapping>
    <filter-name>MappingFilter</filter-name>
    <url-pattern>/FromServlet</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
    <dispatcher>INCLUDE</dispatcher>
    <dispatcher>ERROR</dispatcher>
  </filter-mapping>

<filter-name>用于为过滤器指定一个名字，该元素的内容不能为空。
<filter-class>元素用于指定过滤器的完整的限定类名。
<init-param>元素用于为过滤器指定初始化参数，它的子元素<param-name>指定参数的名字，<param-value>指定参数的值。在过滤器中，可以使用FilterConfig接口对象来访问初始化参数。
<filter-mapping>元素用于设置一个Filter所负责拦截的资源。一个Filter拦截的资源可通过两种方式来指定：Servlet名称和资源访问的请求路径
<filter-name>子元素用于设置filter的注册名称。该值必须是在<filter>元素中声明过的过滤器的名字。
<url-pattern>设置filter所拦截的请求路径
<servlet-name>指定过滤器所拦截的Servlet名称
<dispatcher>指定过滤器所拦截的资源被Servlet容器调用的方式，可以是REQUEST,INCLUDE,FORWARD和ERROE之一，默认是REQUEST。用户可以设置多个<dispatcher>子元素用来指定Filter对资源的多种调用方式进行拦截。

二、Decorator设计模式

当某个对象的方法不适应业务需求时，通常有2种方法可以对方法进行增强：
1.编写子类，覆盖需增强的方法。
2.使用Decorator设计模式对方法进行增强。
比如request、response对象，开发人员之所以在servlet中能通过sun公司定义的HttpServketRequest\Response接口去操作这些对象，是因为Tomcat服务器厂商编写了request、response接口的实现类。web服务器在调用servlet时，会用这些接口的实现类创建出对象，然后传递给servlet程序。
此种情况下，由于开发人员根本不知道服务器厂商编写的request、response接口的实现类是哪个？在程序中只能拿到服务器厂商提供的对象，一次就只能采用Decorator设计模式对这些对象进行增强。

Decorator设计模式的实现
1.首先看需要被增强对象继承了什么接口或父类，编写一个类也去继承这些接口或父类或被增强对象本身。
2.在类中定义一个变量，变量类型即需增强对象的类型。
3.在类中定义一个构造函数，接收需增强的对象。
4.覆盖需增强的方法，编写增强的代码。
5.对于不想增强的方法，直接调用被增强对象的方法。

Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttoServletRequestWrapper(HttpServletRequestWrapper类实现了request接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的request对象的对应方法)以避免用户在对request对象进行增强时需要实现request接口中的所有方法。

//对HttpServletRequest对象包装/装饰
public class MyRequest extends HttpServletRequestWrapper{
	private HttpServletRequest request;
	public MyRequest(HttpServletRequest request) {
		super(request);
		this.request = request;
	}
	//重写父类的方法
	public String getParameter(String name) {//表单项的名字
		String value = null;
		//取得客户端的请求方式[GET/POST]
		String method = request.getMethod();
		if("GET".equals(method)){
			try {
				value = request.getParameter(name);//乱码
				byte[] buf = value.getBytes("ISO8859-1");
				value = new String(buf,"UTF-8");//正码
			} catch (Exception e) {
				e.printStackTrace();
			}
		}else if("POST".equals(method)){
			try {
				request.setCharacterEncoding("UTF-8");
				value = request.getParameter(name);//正码
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		value = filter(value);
		return value;
	}
	//转义方法
	public String filter(String message) {
        if (message == null)
            return (null);
        char content[] = new char[message.length()];
        message.getChars(0, message.length(), content, 0);
        StringBuffer result = new StringBuffer(content.length + 50);
        for (int i = 0; i < content.length; i++) {
            switch (content[i]) {
            case '<':
                result.append("<");
                break;
            case '>':
                result.append(">");
                break;
            case '&':
                result.append("&");
                break;
            case '"':
                result.append(""");
                break;
            default:
                result.append(content[i]);
            }
        }
        return (result.toString());
    }
}

Servlet API中提供了一个response 对象的Decorator设计模式的默认实现类HttoServletResponse Wrapper(HttpServletResponse Wrapper类实现了response 接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的response 对象的对应方法)以避免用户在对response 对象进行增强时需要实现response 接口中的所有方法。

//对response对象的装饰/包装
public class MyResponse extends HttpServletResponseWrapper{
	private HttpServletResponse response;
	//缓存
	private ByteArrayOutputStream bout = new ByteArrayOutputStream();
	private PrintWriter pw;
	public MyResponse(HttpServletResponse response) {
		super(response);
		this.response = response;
	}
	//重写父类方法,目的是将字节输出到缓存中去[字节]
	public ServletOutputStream getOutputStream() throws IOException {
		return new MyServletOutputStream(bout);
	}
	//重写父类方法,目的是将字符输出到缓存中去[字符]
	public PrintWriter getWriter() throws IOException {
		pw = new PrintWriter(new OutputStreamWriter(bout,"UTF-8"));
		return pw;
	}
	//取得缓存中的数据
	public byte[] getBuffer(){
		if(pw!=null){
			pw.flush();
		}
		return bout.toByteArray();
	}
}
//带有缓存功能ServletOutputStream
class MyServletOutputStream extends ServletOutputStream{
	private ByteArrayOutputStream bout;
	public MyServletOutputStream(ByteArrayOutputStream bout) {
		this.bout = bout;
	}
	public void write(int b) throws IOException {
	}
	public void write(byte[] bytes) throws IOException {
		//将字节数组的内容写入缓存
		bout.write(bytes);
		//确保所有字节数组内容进入缓存
		bout.flush();
	}
}

压缩响应：

public class GzipFilter implements Filter {
	public void destroy() {
	}
	public void doFilter(ServletRequest req, ServletResponse res,FilterChain chain) throws IOException, ServletException {
		
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		
		MyResponse myResponse = new MyResponse(response);
		
		chain.doFilter(request,myResponse);
		
		//取得缓存中的内容
		byte[] data = myResponse.getBuffer();
		System.out.println("压缩前：" + data.length);
		
		//进行压缩
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
		GZIPOutputStream gout = new GZIPOutputStream(bout);
		gout.write(data);
		gout.flush();
		gout.close();
		data = bout.toByteArray();
		System.out.println("压缩后：" + data.length);
		
		//通知浏览器接收是的一个压缩型数据库和长度
		response.setHeader("content-encoding","gzip");
		response.setHeader("content-length",data.length+"");
		
		//以字节方式真正输出到浏览器
		response.getOutputStream().write(data);
		
		//无限压缩，无出口，类似环无限循环
		//myResponse.getOutputStream().write(data);
	}
	public void init(FilterConfig filterConfig) throws ServletException {
	}
}