03 最常用的处理乱码的方式

上一节我们看了数据请求到后台并返回的页面的处理方式，但这种方法是有缺陷的。就拿在后台获取数据而言，我们需要对每个查询参数传过来的数据进行编解码，耗费过大。我们需要找到一种通用的方式。

1、前提约束

• 创建一个springmvc项目 https://www.jianshu.com/p/7458c2af1199

2、通用方式一：使用spring中的乱码过滤器CharacterEncodingFilter

2.1 操作步骤

• 在web工程的web.xml中加入此过滤器的配置

     <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

注意：这个过滤器只对post请求的乱码进行处理。

3、通用方式二：自定义过滤器完成对get，post的统一处理

3.1 操作步骤

• 在src文件夹下加入net.wanho.filter.CharacterEncodingFilter.java，内容如下：

package net.wanho.filter;

import org.springframework.util.Assert;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

public class CharacterEncodingFilter extends OncePerRequestFilter {

    private String encoding;

    private boolean forceRequestEncoding = false;

    private boolean forceResponseEncoding = false;

    public CharacterEncodingFilter() {
    }

    public CharacterEncodingFilter(String encoding) {
        this(encoding, false);
    }

    public CharacterEncodingFilter(String encoding, boolean forceEncoding) {
        this(encoding, forceEncoding, forceEncoding);
    }

    public CharacterEncodingFilter(String encoding, boolean forceRequestEncoding, boolean forceResponseEncoding) {
        Assert.hasLength(encoding, "Encoding must not be empty");
        this.encoding = encoding;
        this.forceRequestEncoding = forceRequestEncoding;
        this.forceResponseEncoding = forceResponseEncoding;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    public String getEncoding() {
        return this.encoding;
    }

    public void setForceEncoding(boolean forceEncoding) {
        this.forceRequestEncoding = forceEncoding;
        this.forceResponseEncoding = forceEncoding;
    }

    public void setForceRequestEncoding(boolean forceRequestEncoding) {
        this.forceRequestEncoding = forceRequestEncoding;
    }

    public boolean isForceRequestEncoding() {
        return this.forceRequestEncoding;
    }

    public void setForceResponseEncoding(boolean forceResponseEncoding) {
        this.forceResponseEncoding = forceResponseEncoding;
    }

    public boolean isForceResponseEncoding() {
        return this.forceResponseEncoding;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        String encoding = getEncoding();
        if (encoding != null) {
            if (isForceRequestEncoding() || request.getCharacterEncoding() == null) {
                response.setCharacterEncoding(encoding);
                response.setContentType("text/html;charset=" + encoding);

            }
            if (isForceResponseEncoding()) {
                response.setCharacterEncoding(encoding);
                response.setContentType("text/html;charset=" + encoding);
            }
        }
        filterChain.doFilter(new MyHttpServletRequest((HttpServletRequest) request), response);
    }
    
    private class MyHttpServletRequest extends HttpServletRequestWrapper{
        private HttpServletRequest request = null;
        private boolean isNotEncode = true;
        public MyHttpServletRequest(HttpServletRequest request) {
            super(request);
            this.request = request;
        }
        /* 重写以下三个被装饰对象request中与请求参数获取相关的接口 */
        @Override
        public Map<String,String[]> getParameterMap() {
            try{
                if(request.getMethod().equalsIgnoreCase("POST")){
                    request.setCharacterEncoding(encoding);
                    return request.getParameterMap();
                }
                else if(request.getMethod().equalsIgnoreCase("GET")){
                    Map<String,String[]> map = request.getParameterMap();
                    if(isNotEncode){
                        //依次处理每组请求参数中的乱码
                        for(Map.Entry<String, String[]> entry : map.entrySet()) {
                            String[] values = entry.getValue();
                            for(int i=0; i<values.length; i++){
                                byte[] bytes = values[i].getBytes("ISO-8859-1");
                                String encodeStr = new String(bytes,encoding);
                                values[i] = encodeStr;
                            }
                        }
                        isNotEncode = false;
                    }               
                    return map;
                }
                else{
                    return request.getParameterMap();
                }
            }catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }       
        }
        
        @Override
        public String[] getParameterValues(String name) {
            return getParameterMap().get(name);
        }
        
        @Override
        public String getParameter(String name) {
            String[] values = getParameterValues(name);
            return values == null ? null : values[0];
        }
    }

}

• 在web.xml中加入此过滤器的配置：

    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <!-- 配置encoding，告诉我们指定的编码格式 -->
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
        <!-- 解决响应乱码 -->
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

如此一来，我们就能通过这个过滤器处理通用的乱码请求。