采用Filter的方法解決HttpServletRequest.getParameter亂碼的問題

其實就是利用這么一個原理：

byte[] bytes = str.getBytes("iso-8859-1");
String result = new String(bytes, charset); // 將str轉化為你指定的charset encoding

這個filter解決了什么問題呢？其實就是解決了使用request.getParameter時的亂碼問題，比如說，你有一個a.html或者a.jsp發送request給servlet_b，servlet_b利用request.getParameter把參數提取出來，然后送到c.jsp去顯示，如果你的a.html/jsp使用的編碼是GB2312或者UTF-8之類的，那么在傳輸的過程中就可能出現亂碼（具體我就不描述了，你拿這個代碼去試試就知道亂碼到底出現在哪里）

在web.xml中關於這個filter的一個參數是enable，如果你想關閉這個filter，那么令enable為false即可

完整的代碼如下，先給出測試代碼（見http://www.cnblogs.com/qrlozte/p/3515171.html）：

input_attribute.html

AttributeSetterServlet.java

　　req.getParameter讀取attribute，然后req.setAttribute(attribute)，接着跳轉到display_attribute.jsp

display_attribute.jsp

　　request.getAttribute("attribute")提取attribute

------------------------------Filter代碼-------------------------------

I18nServletFilter:

　　注意，由於編碼的filter是屬於最基本的的filter，所以在web.xml中一定要把編碼的filter放在靠前的位置，至少是要放在encoding-sensitive的filter和servlet之前

　　此filter從web.xml中讀取參數charset，charset就是你希望使用的編碼參數，比如說GBK、UTF-8之類的

　　這個filter使用了一個自定義的類叫做I18nHttpServletRequestWrapper，繼承自HttpServletRequestWrapper，HttpServletRequestWrapper提供了實現HttpServletRequest的基本框架，client可以繼續extends（參考design pattern:adapter），所以I18nHttpServletRequestWrapper重寫了的getParameter()以及getParameterValues()方法，添加了encoding的代碼，確保了getParameter()和getParameterValues()返回的內容都是由charset參數指定的編碼。並且，這個filter一但被調用，那么chain.doFilter()就會把這里的wrapper給傳遞下去，從而確保在filter-chain后面的filter或者其他的servlet的編碼問題都得到解決。

/**
 * If this filter is enabled, it will wrap the default
 * HttpServletRequest with I18nHttpServletRequestWrapper and 
 * pass it to filters/servlets following this filter in the chain,
 * the purpose is to add charset-conversion functionality to the
 * HttpServletRequest, so that when you invoke getParameter()
 * or getParameterValues(), the returned string is encoded in the
 * specified charset. The charset name is specified by the init-param
 * of this filter. 
 * */
public class I18nServletFilter implements Filter {

    private FilterConfig filterConfig;

    private String charsetName = "UTF-8";
    private boolean enable = false;
    //Handle the passed-in FilterConfig
    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
        String enableString = filterConfig.getInitParameter("enable");
        if (enableString != null && enableString.equalsIgnoreCase("true")) {
            this.enable = true;
        }
        String charset = filterConfig.getInitParameter("charset");
        if (charset != null && charset.trim().length() != 0) {
            this.charsetName = charset;
        }
    }

    //Process the request/response pair
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        if (this.enable) {
            try {
                if (this.charsetName != null) {
                    // System.out.println(this + ", " + this.charsetName); // @Debug
                    I18nHttpServletRequestWrapper requestWrapper = 
                        new I18nHttpServletRequestWrapper( (HttpServletRequest) request, this.charsetName);
                    // 注意：傳遞下去的是requestWrapper而不是request
                    filterChain.doFilter(requestWrapper, response);
                } else {
                    filterChain.doFilter(request, response);
                }
            } catch(ServletException sx) {
                filterConfig.getServletContext().log(sx.getMessage());
            } catch(IOException iox) {
                filterConfig.getServletContext().log(iox.getMessage());
            }
        } else {
            filterChain.doFilter(request, response);
        }
    }

    // Clean up resources
    public void destroy() {
        filterConfig = null;
        charsetName = null;
    }
    
}

HttpServletRequestWrapper

　　上面已經解釋過了，這個是利用decorator pattern對HttpServletRequest進行了一次封裝，對getParameter()以及getParameterValues()方法增加編碼轉換的功能

/**
 * This class wraps the default HttpServletRequest to provide
 * a charset-conversion functionality, so that getParameter()
 * and getParameterValues() can return parameter-strings encoded
 * in your specified charset. 
 * 
 * The charset is specified by the constructor
 * of this class.
 * */
public class I18nHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private Map<String, String[]> paramMap = new HashMap<String, String[]>();
    private String charsetName = "iso-8859-1";
    /**
     * 每次I18nServletFilter.doFilter()被調用，就會新建一個I18nHttpServletRequestWrapper.
     * 那么I18nHttpServletRequestWrapper就會提取出HttpServletRequest中的所有parameters並
     * 存放到paramMap中.
     * 
     * 由於服務器跳轉是request范圍的，所以服務器跳轉始終是一個request，只會new一個I18nHttpServletRequestWrapper
     * */
    public I18nHttpServletRequestWrapper(HttpServletRequest request, String charsetName) {
        super(request);
        // System.out.println("constructing " + this); // @Debug
        this.charsetName = charsetName;
        initParameterMap(request);
    }
    private void initParameterMap(HttpServletRequest request) {
        if (request == null) {
            return;
        }
        Map<String,String[]> map = request.getParameterMap();
        Set<String> names = map.keySet();
        String[] values;
        for (Iterator<String> i = names.iterator(); i.hasNext(); ) {
            String name = i.next();
            values = map.get(name);
            for (int j = 0; j < values.length; j++) {
                values[j] = convertCharset(values[j]);
            }
            this.paramMap.put(name, values);
        }
    }
    public String getParameter(String name) {
        String[] values = this.getParameterValues(name);
        if (values != null && values.length > 0) {
            return values[0];
        } else {
            return null;
        }
    }
    public String[] getParameterValues(String name) {
        return this.paramMap.get(name);
    }
    private boolean isInParamValues(String s) {
        for (String[] values : paramMap.values()) {
            for (String value : values) {
                if (s.equals(value)) {
                    return true;
                }
            }
        }
        return false;
    }
    @Override
    public void setAttribute(String name, Object o) {
        /*
         * 防止已經被編碼過的String被重新編碼、
         * 比如說，一個String x本來是iso-8859-1，通過convertCharset轉碼成為了utf-8
         * 然后，你又調用convertCharset(x)，那么convertCharset就會首先把x解碼成
         * iso-8859-1的byte（導致亂碼，因為此時x已經是utf-8編碼了），然后再用utf-8編碼（還是亂碼）
         * 
         * 那么已經被編碼過的String來源有哪些？
         * 1、通過request.setAttribute已經添加的string attribute value
         * 2、已經在paramMap中的value
         * */
        if (o instanceof String && !isInParamValues((String)o) && !o.equals(getAttribute(name))) {
            // System.out.println("setAttr:check " + paramMap + "\n" + getAttribute(name)); // @Debug
            o = convertCharset((String)o);
        }
        super.setAttribute(name, o);
    }
    
    private String convertCharset(String str) {
        if (str == null) {
            return null;
        }
        try {
            // System.out.println("before convert: " + str); // @Debug
            str = new String(str.getBytes("iso-8859-1"), this.charsetName);
            // System.out.println("\tafter convert: " + str); // @Debug
            return str;
        } catch (UnsupportedEncodingException ex) {
            Logger.getLogger(this.getClass().toString()).log(Level.SEVERE, ex + ", charset = " + this.charsetName);
        }
        return null;
    }
}

web.xml

    <!-- i18nservletfilter -->
    <filter>
        <filter-name>i18nservletfilter</filter-name>
        <filter-class>org.foo.filterdemo.I18nServletFilter</filter-class>
        <init-param>
            <param-name>enable</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>charset</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>i18nservletfilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

總結：

　　這個什么I18nServletFilter是我先前在翻閱資料的時候找到的，現搬過來吧，又解決不了編碼的問題

　　自己搗鼓了半天吧，好歹算是能用了，但是總的感覺就是：Verbose + Error-prone.

　　推薦使用http://www.cnblogs.com/qrlozte/p/3515171.html給出的方法