字符编码过滤器的实现

1.CharacterEncodingFilter.java

package org.guyezhai.modules.encode;

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;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class CharacterEncodingFilter implements Filter {
    private String encoding = "UTF-8";
    private boolean encodingOn = true;
    private boolean trimOn = true;
    private String[] postfixs;
    
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain filterChain) throws IOException, ServletException {
        if (req instanceof CharacterEncodingRequestWrapper) {
            filterChain.doFilter(req, res);
            return;
        }
        
        HttpServletRequest request = (HttpServletRequest) req;
        if (isMultipart(request)) {// 如果是上传文件
            if (encodingOn) {
                request.setCharacterEncoding(encoding);
            }
            filterChain.doFilter(req, res);
            return;
        }
        HttpServletResponse response = (HttpServletResponse) res;
        
        String suri = request.getRequestURI().toLowerCase();
        if (isContainPostfix(suri) && request.getCharacterEncoding() == null) {
            request = new CharacterEncodingRequestWrapper(request, encoding, encodingOn, trimOn);
        }
        
        filterChain.doFilter(request, response);
    }
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        String e = filterConfig.getInitParameter("encoding");
        if (e != null && !"".equals(e.trim())) {
            encoding = e;
        }
        String eo = filterConfig.getInitParameter("encodingOn");
        if (eo != null) {
            encodingOn = Boolean.parseBoolean(eo);
        }
        String to = filterConfig.getInitParameter("trimOn");
        if (to != null) {
            trimOn = Boolean.parseBoolean(to);
        }
        
        String postfix = filterConfig.getInitParameter("postfixs");
        if (postfix != null) {
            postfixs = postfix.split("\|");
        }
    }
    
    /**
     * 链接地址是否包含配置的后缀
     * 
     * @param suri
     * @return
     */
    private boolean isContainPostfix(String suri) {
        int i = suri.indexOf('.');
        if (i == -1 || postfixs == null || postfixs.length == 0) {
            return true;
        }
        
        for (String s : postfixs) {
            if (suri.endsWith(s)) {
                return true;
            }
        }
        
        return false;
    }
    
    private boolean isMultipart(HttpServletRequest request) {
        if (!"post".equals(request.getMethod().toLowerCase())) {
            return false;
        }
        String contentType = request.getContentType();
        return (contentType != null && contentType.toLowerCase().startsWith("multipart/"));
    }
    
    @Override
    public void destroy() {
    }
}

2.CharacterEncodingRequestWrapper.java

package org.guyezhai.modules.encode;

import java.io.UnsupportedEncodingException;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import org.apache.commons.lang3.StringEscapeUtils;

public class CharacterEncodingRequestWrapper extends HttpServletRequestWrapper {
    
    private final HttpServletRequest request;
    private String encoding = "UTF-8";
    private boolean encodingOn;
    private boolean trimOn;
    
    private HashMap<String, String[]> parameterMap;
    
    public CharacterEncodingRequestWrapper(HttpServletRequest request, String encoding, boolean encodingOn, boolean trimOn) {
        super(request);
        this.request = request;
        
        this.encodingOn = encodingOn;
        String econ = request.getParameter("econ");
        if (econ != null) {
            if ("y".equalsIgnoreCase(econ)) {
                this.encodingOn = true;
            } else if ("n".equalsIgnoreCase(econ)) {
                this.encodingOn = false;
            }
        }
        
        if (encoding != null && !"".equals(encoding.trim())) {
            this.encoding = encoding;
        }
        String ec = request.getParameter("ec");
        if (ec != null && !"".equals(ec.trim())) {
            this.encoding = ec.trim();
        }
        
        this.trimOn = trimOn;
        String trimon = request.getParameter("trimon");
        if (trimon != null) {
            if ("y".equalsIgnoreCase(trimon)) {
                this.trimOn = true;
            } else if ("n".equalsIgnoreCase(trimon)) {
                this.trimOn = false;
            }
        }
    }
    
    @Override
    public String getParameter(String name) {
        // 修改：从本类中ParameterMap获取并返回
        String[] values = getParameterMap().get(name);
        if (values != null) {
            if (values.length == 0) {
                return "";
            }
            return StringEscapeUtils.escapeHtml4(values[0]);
        } else {
            return null;
        }
    }
    
    @Override
    public Map<String, String[]> getParameterMap() {
        if (parameterMap != null) {
            return parameterMap;
        }
        
        parameterMap = new HashMap<String, String[]>();
        Map<String, String[]> map = request.getParameterMap();
        for (Entry<String, String[]> entry : map.entrySet()) {
            String key = entry.getKey();
            String[] strs = entry.getValue();
            String[] tempStr = null;
            if (strs != null) {
                tempStr = new String[strs.length];
                for (int i = 0; i < strs.length; i++) {
                    tempStr[i] = getEncodedString(strs[i], encoding);
                }
            }
            parameterMap.put(key, tempStr);
        }
        return parameterMap;
    }
    
    @Override
    public Enumeration<String> getParameterNames() {
        // 修改：从本类中ParameterMap获取并返回
        return Collections.enumeration(getParameterMap().keySet());
    }
    
    @Override
    public String[] getParameterValues(String name) {
        // 修改：从本类中ParameterMap获取并返回
        return getParameterMap().get(name);
    }
    
    private String getEncodedString(String value, String enc) {
        if (encodingOn) {
            try {
                value = new String(value.getBytes("ISO-8859-1"), encoding);
            } catch (UnsupportedEncodingException e) {
            }
        }
        if (trimOn) {
            value = value.trim();
        }
        return value;
    }
    
}

3. web.xml

    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.guyezhai.modules.encode.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>encodingOn</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>trimOn</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>postfixs</param-name>
            <param-value>jsp|jspv</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
        <dispatcher>INCLUDE</dispatcher>
        <dispatcher>ERROR</dispatcher>
    </filter-mapping>