扯淡过滤器之乱码篇

package com.hitech.filter;

import java.io.IOException;
import java.util.Map;

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.HttpServletRequestWrapper;

public class ApplicationEncodingFilter implements Filter {

    private String encoding = null;
    public void init(FilterConfig filterConfig) throws ServletException {
        this.encoding = filterConfig.getInitParameter("encoding");
    }

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        // 解决响应中文乱码
        response.setContentType("text/html;charset=" + encoding);
        // 解决请求中文乱码
        chain.doFilter(new _HttpServletRequest((HttpServletRequest) request), response);
    }

    public void destroy() {

    }

    class _HttpServletRequest extends HttpServletRequestWrapper {

        private HttpServletRequest request = null;
        // 由于Map的缓存，所以需要控制只对请求参数做一次编解码
        private boolean flag = true;
        // 父类没有提供无参构造，所以这里也只能有无参构造
        public _HttpServletRequest(HttpServletRequest request) {
            super(request);
            this.request = request;
        }

        @SuppressWarnings("unchecked")
        @Override
        public Map<String, String[]> getParameterMap() {
            try {
                if ("post".equals(request.getMethod().toLowerCase())) {
                    // 如果是post提交的参数，只需要指定编码
                    request.setCharacterEncoding(encoding);
                    return request.getParameterMap();
                }else if ("get".equals(request.getMethod().toLowerCase())) {
                    Map<String, String[]> parameterMap = request.getParameterMap();
                    // 对于get提交的参数，系统默认用ISO-8859-1解码，所以要先用ISO-8859-1先编码回去，再按指定编码解码
                    if (flag) {// 由于Map会对提交过来的数据进行缓存，所以只需要编码一次以防止正确的编码再次被编码
                        // 遍历Map，对String[]中的每一项值进行重新编解码
                        for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
                            String[] values = entry.getValue(); 
                            for (int i = 0; i < values.length; i++) {
                                values[i] = new String(values[i].getBytes("ISO-8859-1"),encoding);
                            }
                        }
                        // 编码一次后，不再需要编码
                        flag = false;
                    }
                    return parameterMap;
                }else {
                    // 其他方式提交的数据，不作处理，直接返回
                    return super.getParameterMap();
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        @Override
        public String[] getParameterValues(String name) {
            // 从getParameterMap中的取出已经修改好的Values[]
            return getParameterMap().get(name);
        }

        @Override
        public String getParameter(String name) {
            // 需要对NullPointerException做处理
            String[] parameterValues = getParameterValues(name);
            return parameterValues == null ? null : parameterValues[0];
        }
    }
}

  <filter>
      <filter-name>CodecFilter</filter-name>
      <filter-class>com.hitech.filter.ApplicationEncodingFilter</filter-class>
      <init-param>
          <param-name>encoding</param-name>
          <param-value>utf-8</param-value>
      </init-param>
  </filter>
    
  <filter-mapping>
      <filter-name>CodecFilter</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>    

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy {
    public static void main(String[] args) {
        final ProxyDemo demo = new ProxyDemo();
        Proxy proxy = (Proxy)java.lang.reflect.Proxy.newProxyInstance(ProxyDemo.class.getClassLoader(), ProxyDemo.class.getInterfaces(), new InvocationHandler() {
            
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // 如果只想重新定义function方法可以这样
                if ("function".equals(method.getName())) {
                    // 这里重新定义function方法的功能
                    System.out.println("This is a new function");
                    return null;
                }else {
                    return method.invoke(demo, args);
                }
            }
        });
        proxy.method();
        proxy.function();
    }
}
class ProxyDemo implements Proxy{

    public ProxyDemo(){}
    
    public void method() {
        System.out.println("This is a method.");
    }

    public void function() {
        System.out.println("This is a function.");
    }
}
interface Proxy{
    public abstract void method();
    public abstract void function();
}