字符编码过滤器的实现

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() {
}
}

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;
}

}

<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>