大学IT网 - 最懂大学生的IT学习网站! QQ资料交流群:367606806
当前位置:大学IT网 > Java技巧 > 浅淡过滤器之乱码

浅淡过滤器之乱码

关键词:过滤器乱码  阅读(468) 赞(19)

[摘要]本文是对扯淡过滤器之乱码篇的讲解,对学习Java编程技术有所帮助,与大家分享。

在JavaWeb开发中,Servlet过滤器可以很方便地帮助开发者做很多重复的事情,比如说这里要和大家分享的乱码问题。其实说起乱码自己也没有什么经验可谈,只是东拼西凑来出来的一些代码,这里说过滤器是一方面,另一方面还有其中用到的一些思想上的东西。
  乱码产生的原因说来说去就一句话,编码和解码用的码表不同造成。但是要弄清楚这其中的原理,怕是自己也不清楚,只好扬长避短。Web开发中的乱码就发生在服务器和浏览器之间,这样根据乱码的作用者可以分为请求参数乱码和响应内容乱码,响应乱码容易解决,只要response.setContentType("text/html;charset=utf-8"),就可以简单搞定;但是对于请求参数乱码又分了post提交和get提交参数的乱码处理,这两种提交方式的乱码处理也不一样,当然还有其他提交方式,只是不常用就没有考虑。
  对于post提交,使用request.setCharacterEncoding("utf-8")也可以简单搞定,但是get方式提交的中文数据就不能这样来处理。首先搞清楚产生的原因很有必要:浏览器会以服务器response中设置的编码发送请求参数到服务器,但是服务器并不知道以什么编码来解码,默认情况下会使用ISO-8859-1字符集对参数解码,而ISO-8859-1中没有中文,所以这种情况下查出来的基本上都会是"?"来显示,可以肯定的是,服务器接收到的编码本身是没有问题,只是他自作主张查了错误的编码表,所以我们就可以用ISO-8859-1编码表再查回去,然后再重新以正确的编码表查出来就解决了get方式提交的参数乱码问题,在代码上的体现也可以很直观:
    request.getParameter("nickname") -- 查错码表的数据
    request.getParameter("nickname").getBytes("ISO-8859-1") -- 使用错误的码表再错误一次
    new String(request.getParameter("nickname").getBytes("ISO-8859-1"),"utf-8") -- 正确的表得正确
  这样我们的get提交的中文乱码也可以解决了,所以通过以上剖析可以开发自己的全站乱码过滤器了,还等什么呢?代码奉上。

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,再在web.xml中配置filter便可以使用。

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

  完成了filter之后,再看看其中用到的一种设计模式--包装模式,谈到包装模式先说说对于一个对象上的方法进行重写,可以有三种方式完成。
  1、使用继承
   一个类继承另一个类后,可以对父类中已经的方法进行重写,以完成子类特有的功能。但是在这里似乎不太合适,原因是无法改变ServletRequest的继承结构。
  2、使用包装设计模式
   显然这个方式在这里是可行的,也就是使用一个类实现和要包装的类相同的接口,构造方法中接受一个需要包装的对象,然后就可以重新定义其中的方法。
  3、动态代理
   使用java中的反射机制也可以完成这样的功能,但是看起来似乎稍微有些难以理解,上来一个demo吧。

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


相关评论