java web中字符编码的过滤器(Filter - 1)

      建立一个实现Filter接口的类。这个类需要三个方法，分别是：doFilter、init和destroy。doFilter方法包含主要的过滤代码，init方法建立设置操作，而destroy方法进行清除。

package OSChina;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class FilterDemo implements Filter {

 protected String encoding = null;

 protected FilterConfig filterConfig = null;

 @Override
 public void destroy() {

  this.encoding = null;
  this.filterConfig = null;

 }

 @Override
 public void doFilter(ServletRequest request, ServletResponse response,
   FilterChain chain) throws IOException, ServletException {

  String encoding = selectEncoding(request);

  request.setCharacterEncoding(encoding);
  response.setCharacterEncoding(encoding);
  chain.doFilter(request, response);

 }

 /**
  * 或得web.xml中初始化参数"encoding"
  */
 public void init(FilterConfig filterConfig) throws ServletException {

  this.filterConfig = filterConfig;
  this.encoding = filterConfig.getInitParameter("encoding");

 }

 protected String selectEncoding(ServletRequest request) {
  return (this.encoding);
 }

}

配置web.xml如下：

javaWeb 字体替换过滤器

字体替换过滤器继承 HttpServletRequestWrapper, 重定义了: getParameter (),getParameterValues (),getParameterMap (), 增强字节替换功能，满足更多的请求情况.

一：字节替换过滤器:

 1 package cc.openhome.controler;
 2 
 3 import javax.servlet.*;
 4 import javax.servlet.annotation.WebFilter;
 5 import javax.servlet.http.HttpServletRequest;
 6 import javax.servlet.http.HttpServletResponse;
 7 import java.io.IOException;
 8 
 9 @WebFilter("/*")
10 public class HtmlFilter implements Filter {
11     @Override
12     public void init(FilterConfig filterConfig) throws ServletException {
13 
14     }
15 
16     @Override
17     public void doFilter(ServletRequest sreq, ServletResponse sresp, FilterChain chain) throws IOException, ServletException {
18         HttpServletRequest req = (HttpServletRequest) sreq;
19         HttpServletResponse resp = (HttpServletResponse) sresp;
20         MyHtmlRequest mreq = new MyHtmlRequest(req);
21         chain.doFilter(mreq,resp);
22     }
23     @Override
24     public void destroy() {
25 
26     }
27 }

字节替换处理部分:

 1 package cc.openhome.controler;
 2 
 3 import javax.servlet.http.HttpServletRequest;
 4 import javax.servlet.http.HttpServletRequestWrapper;
 5 import java.util.*;
 6 
 7 public class MyHtmlRequest extends HttpServletRequestWrapper {
 8 
 9     private HttpServletRequest req;
10     public MyHtmlRequest(HttpServletRequest req){
11 
12         super(req);
13         this.req = req;
14     }
15 
16     public String getParameter(String name){
17         String value = getRequest().getParameter(name);
18         if(value == null){
19             return null;
20         }
21         return filter(value);
22     }
23 
24     public String [] getParameterValues(String name){
25         String [] values = getRequest().getParameterValues(name);
26         String [] res = new String[values.length];
27         if(values == null){
28             return null;
29         }
30         for(int i = 0;i < values.length;i++){
31             res[i] = filter(values[i]);
32         }
33         return res;
34 
35     }
36 
37     public Map<String,String[]> getParameterMap(){
38         Map<String,String[]> values = getRequest().getParameterMap();
39         Map<String,String[]> res = new HashMap<String, String[]>();
40         List <String> listv= new ArrayList<String>();
41         String [] arrv;
42         for(Iterator<String> it = values.keySet().iterator();it.hasNext();){
43             String k = it.next();
44             String [] v = values.get(k);
45             if(v == null || v.length == 0){
46                 continue;
47             }
48             else {
49                 for (int i = 0;i < v.length;i++){
50                     listv.add(filter(v[i]));
51                 }
52                 arrv = new String[listv.size()];
53                 arrv = listv.toArray(arrv);
54             }
55             res.put(k,arrv);
56         }
57         if(res == null){
58             return null;
59         }
60         return res;
61     }
62 
63     public String filter(String message){
64         if(message == null){
65             return null;
66         }
67         char content[] = new char[message.length()];
68         message.getChars(0,message.length(),content,0);
69         StringBuilder result = new StringBuilder(content.length + 50);
70         for(int i = 0;i < content.length;i++){
71             switch (content[i]){
72                 case ''<'':
73                     result.append("&lt;");
74                     break;
75                 case ''>'':
76                     result.append("&gt;");
77                     break;
78                 case ''&'':
79                     result.append("&amp;");
80                     break;
81                 case ''"'':
82                     result.append("&quot");
83                     break;
84                 default:
85                     result.append(content[i]);
86             }
87         }
88         return result.toString();
89     }
90 }

对请求参数进行扩充，Filter 方法处理请求到值.Filter 方法可以扩充为功能更强大的方法.

二，总结:

(1). 对 getParameter (),getParameterValues (),getParameterMap (), 方法有了更深入的理解。对于前端传入的复杂数据类型如 checkbox 数据，密码用户名等复杂数据类型处理

有了概念.

(2), 首次使用 List 容器.

javaweb 学习总结 ——Filter (过滤器) 学习

一、Filter 简介

　　Filter 也称之为过滤器，它是 Servlet 技术中最激动人心的技术，WEB 开发人员通过 Filter 技术，对 web 服务器管理的所有 web 资源：例如 Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，从而实现一些特殊的功能。例如实现 URL 级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。
　　Servlet API 中提供了一个 Filter 接口，开发 web 应用时，如果编写的 Java 类实现了这个接口，则把这个 java 类称之为过滤器 Filter。通过 Filter 技术，开发人员可以实现用户在访问某个目标资源之前，对访问的请求和响应进行拦截，如下所示：

二、Filter 是如何实现拦截的？

　　Filter 接口中有一个 doFilter 方法，当我们编写好 Filter，并配置对哪个 web 资源进行拦截后，WEB 服务器每次在调用 web 资源的 service 方法之前，都会先调用一下 filter 的 doFilter 方法，因此，在该方法内编写代码可达到如下目的：

1. 调用目标资源之前，让一段代码执行。

2. 是否调用目标资源（即是否让用户访问 web 资源）。

3. 调用目标资源之后，让一段代码执行。

　　web 服务器在调用 doFilter 方法时，会传递一个 filterChain 对象进来，filterChain 对象是 filter 接口中最重要的一个对 象，它也提供了一个 doFilter 方法，开发人员可以根据需求决定是否调用此方法，调用该方法，则 web 服务器就会调用 web 资源的 service 方 法，即 web 资源就会被访问，否则 web 资源不会被访问。

三、Filter 开发入门

3.1、Filter 开发步骤

　　Filter 开发分为二个步骤：

1. 编写 java 类实现 Filter 接口，并实现其 doFilter 方法。

2. 在 web.xml 文件中使用 <filter> 和 < filter-mapping > 元素对编写的 filter 类进行注册，并设置它所能拦截的资源。

　　过滤器范例：

package me.gacl.web.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
* @ClassName: FilterDemo01
* @Description:filter的三种典型应用：
*                     1、可以在filter中根据条件决定是否调用chain.doFilter(request, response)方法，
*                        即是否让目标资源执行
*                     2、在让目标资源执行之前，可以对request\response作预处理，再让目标资源执行
*                     3、在目标资源执行之后，可以捕获目标资源的执行结果，从而实现一些特殊的功能
* @author: 孤傲苍狼
* @date: 2014-8-31 下午10:09:24
*/ 
public class FilterDemo01 implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("----过滤器初始化----");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        
        //对request和response进行一些预处理
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        
        System.out.println("FilterDemo01执行前！！！");
        chain.doFilter(request, response);  //让目标资源执行，放行
        System.out.println("FilterDemo01执行后！！！");
    }

    @Override
    public void destroy() {
        System.out.println("----过滤器销毁----");
    }
}

　　在 web. xml 中配置过滤器：

 <?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name></display-name>    
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <!--配置过滤器-->
  <filter>
      <filter-name>FilterDemo01</filter-name>
      <filter-class>me.gacl.web.filter.FilterDemo01</filter-class>
  </filter>
  
  <!--映射过滤器-->
  <filter-mapping>
      <filter-name>FilterDemo01</filter-name>
      <!--“/*”表示拦截所有的请求 -->
      <url-pattern>/*</url-pattern>
  </filter-mapping>
  
</web-app>

3.2、Filter 链

　　在一个 web 应用中，可以开发编写多个 Filter，这些 Filter 组合起来称之为一个 Filter 链。
　　web 服务器根据 Filter 在 web.xml 文件中的注册顺序，决定先调用哪个 Filter，当第一个 Filter 的 doFilter 方法被调用时，web 服务器会创建一个代表 Filter 链的 FilterChain 对象传递给该方法。在 doFilter 方法中，开发人员如果调用了 FilterChain 对象的 doFilter 方法，则 web 服务器会检查 FilterChain 对象中是否还有 filter，如果有，则调用第 2 个 filter，如果没有，则调用目标资源。

四、Filter 的生命周期

4.1、Filter 的创建

　　Filter 的创建和销毁由 WEB 服务器负责。 web 应用程序启动时，web 服务器将创建 Filter 的实例对象，并调用其 init 方法，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作，filter 对象只会创建一次，init 方法也只会执行一次。通过 init 方法的参数，可获得代表当前 filter 配置信息的 FilterConfig 对象。

4.2、Filter 的销毁

　　Web 容器调用 destroy 方法销毁 Filter。destroy 方法在 Filter 的生命周期中仅执行一次。在 destroy 方法中，可以释放过滤器使用的资源。

4.3、FilterConfig 接口

　　用户在配置 filter 时，可以使用 <init-param> 为 filter 配置一些初始化参数，当 web 容器实例化 Filter 对象，调用其 init 方法时，会把封装了 filter 初始化参数的 filterConfig 对象传递进来。因此开发人员在编写 filter 时，通过 filterConfig 对象的方法，就可获得：
　　String getFilterName ()：得到 filter 的名称。
　　String getInitParameter (String name)： 返回在部署描述中指定名称的初始化参数的值。如果不存在返回 null.
　　Enumeration getInitParameterNames ()：返回过滤器的所有初始化参数的名字的枚举集合。
　　public ServletContext getServletContext ()：返回 Servlet 上下文对象的引用。
范例：利用 FilterConfig 得到 filter 配置信息

package me.gacl.web.filter;

import java.io.IOException;
import java.util.Enumeration;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class FilterDemo02 implements Filter {

    /* 过滤器初始化
     * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("----过滤器初始化----");
        /**
         *  <filter>
                  <filter-name>FilterDemo02</filter-name>
                  <filter-class>me.gacl.web.filter.FilterDemo02</filter-class>
                  <!--配置FilterDemo02过滤器的初始化参数-->
                  <init-param>
                      <description>配置FilterDemo02过滤器的初始化参数</description>
                      <param-name>name</param-name>
                      <param-value>gacl</param-value>
                  </init-param>
                  <init-param>
                      <description>配置FilterDemo02过滤器的初始化参数</description>
                      <param-name>like</param-name>
                      <param-value>java</param-value>
                  </init-param>
            </filter>
            
             <filter-mapping>
                  <filter-name>FilterDemo02</filter-name>
                  <!--“/*”表示拦截所有的请求 -->
                  <url-pattern>/*</url-pattern>
             </filter-mapping>
         */
        //得到过滤器的名字
        String filterName = filterConfig.getFilterName();
        //得到在web.xml文件中配置的初始化参数
        String initParam1 = filterConfig.getInitParameter("name");
        String initParam2 = filterConfig.getInitParameter("like");
        //返回过滤器的所有初始化参数的名字的枚举集合。
        Enumeration<String> initParameterNames = filterConfig.getInitParameterNames();
        
        System.out.println(filterName);
        System.out.println(initParam1);
        System.out.println(initParam2);
        while (initParameterNames.hasMoreElements()) {
            String paramName = (String) initParameterNames.nextElement();
            System.out.println(paramName);
        }
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("FilterDemo02执行前！！！");
        chain.doFilter(request, response);  //让目标资源执行，放行
        System.out.println("FilterDemo02执行后！！！");
    }

    @Override
    public void destroy() {
        System.out.println("----过滤器销毁----");
    }
}

　　<description> 用于添加描述信息，该元素的内容可为空，<description > 可以不配置。

　　<filter-name> 用于为过滤器指定一个名字，该元素的内容不能为空。
　　<filter-class> 元素用于指定过滤器的完整的限定类名。
　　<init-param> 元素用于为过滤器指定初始化参数，它的子元素 < param-name > 指定参数的名字，<param-value > 指定参数的值。在过滤器中，可以使用 FilterConfig 接口对象来访问初始化参数。如果过滤器不需要指定初始化参数，那么 < init-param > 元素可以不配置。

5.2、映射 Filter

　　在 web.xml 文件中注册了 Filter 之后，还要在 web.xml 文件中映射 Filter

1  <!--映射过滤器-->
2   <filter-mapping>
3       <filter-name>FilterDemo02</filter-name>
4       <!--“/*”表示拦截所有的请求 -->
5       <url-pattern>/*</url-pattern>
6   </filter-mapping>

　　<filter-mapping> 元素用于设置一个 Filter 所负责拦截的资源。一个 Filter 拦截的资源可通过两种方式来指定：Servlet 名称和资源访问的请求路径
　　<filter-name> 子元素用于设置 filter 的注册名称。该值必须是在 < filter > 元素中声明过的过滤器的名字
　　<url-pattern> 设置 filter 所拦截的请求路径 (过滤器关联的 URL 样式)
　　<servlet-name> 指定过滤器所拦截的 Servlet 名称。
　　<dispatcher> 指定过滤器所拦截的资源被 Servlet 容器调用的方式，可以是 REQUEST,INCLUDE,FORWARD 和 ERROR 之一，默认 REQUEST。用户可以设置多个 < dispatcher> 子元素用来指定 Filter 对资源的多种调用方式进行拦截。如下：

1 <filter-mapping>
2 <filter-name>testFilter</filter-name>
3 <url-pattern>/index.jsp</url-pattern>
4 <dispatcher>REQUEST</dispatcher>
5 <dispatcher>FORWARD</dispatcher>
6 </filter-mapping>

　　<dispatcher> 子元素可以设置的值及其意义：

1. REQUEST：当用户直接访问页面时，Web 容器将会调用过滤器。如果目标资源是通过 RequestDispatcher 的 include () 或 forward () 方法访问时，那么该过滤器就不会被调用。

2. INCLUDE：如果目标资源是通过 RequestDispatcher 的 include () 方法访问时，那么该过滤器将被调用。除此之外，该过滤器不会被调用。

3. FORWARD：如果目标资源是通过 RequestDispatcher 的 forward () 方法访问时，那么该过滤器将被调用，除此之外，该过滤器不会被调用。

4. ERROR：如果目标资源是通过声明式异常处理机制调用时，那么该过滤器将被调用。除此之外，过滤器不会被调用。

关于JavaWeb——字符编码过滤器和字符编码过滤器代码的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Java Web——过滤器、java web中字符编码的过滤器(Filter - 1)、javaWeb 字体替换过滤器、javaweb 学习总结 ——Filter (过滤器) 学习等相关内容，可以在本站寻找。