设置utf8编码问题

注意：乱码和request的具体实现类有关，现在已经查到的是RequestDispatcher.forward调用前使用的是org.apache.catalina.connector.RequestFacade类而RequestDispatcher.forward调用后使用的是org.apache.catalina.core.ApplicationHttpRequest，他们内部在ParseParameter的时候， 用来解码的默认的编码逻辑不同，使用不同的协议时，影响乱码的因素不同！ 
具体参考：Tomcat源码分析--ServletRequest.getParameterValues内部分析，Request字符集&QueryStringEncoding 

乱码的产生 
譬如汉字“中”，以UTF-8编码后得到的是3字节的值%E4%B8%AD，然后通过GET或者POST方式把这3个字节提交到Tomcat容器，如果你不告诉Tomcat我的参数是用UTF-8编码的，那么tomcat就认为你是用ISO-8859-1来编码的，而ISO8859-1（兼容URI中的标准字符集US-ASCII）是兼容ASCII的单字节编码并且使用了单字节内的所有空间，因此Tomcat就以为你传递的用ISO-8859-1字符集编码过的3个字符，然后它就用ISO-8859-1来解码，得到中-，解码后。字符串中-在Jvm是以Unicode的形式存在的，而HTTP传输或者数据库保存的其实是字节，因此根据各终端的需要，你可以把unicode字符串中-用UTF-8编码后得到相应的字节后存储到数据库（3个UTF-8字符），也可以取得这3个字符对应的ISO-8859-1的3个字节，然后用UTF-8重新编码后得到unicode字符“中”（特性：把其他任何编码的字节流当作ISO-8859-1编码看待都没有问题），然后用response传递给客户端（根据你设置的content-type不同，传递的字节也是不同的！） 
总结： 

• 1，HTTP GET或者POST传递的是字节？数据库保存的也是字节（譬如500MB空间就是500M字节）
• 2，乱码产生的原因是编码和解码的字符集（方式）不同导致的，即对于几个不同的字节，在不同的编码方案下对应的字符可能不同，也可能在某种编码下有些字节不存在（这也是乱码中？产生的原因）
• 3，解码后的字符串在jvm中以Unicode的形式存在
• 4，如果jvm中存在的Unicode字符就是你预期的字符（编码，解码的字符集相同或者兼容），那么没有任何问题，如果jvm中存在的字符集不是你预期的字符，譬如上述例子中jvm中存在的是3个Unicode字符，你也可以通过取得这3个unicode字符对应的3个字节，然后用UTF-8对这3个字节进行编码生成新的Unicode字符：汉字“中”
• 5，ISO8859-1是兼容ASCII的单字节编码并且使用了单字节内的所有空间，在支持ISO-8859-1的系统中传输和存储其他任何编码的字节流都不会被抛弃。换言之，把其他任何编码的字节流当作ISO-8859-1编码看待都没有问题。

下面的代码显示，使用不同的编码来Encoder会得到不同的结果，同时如果Encoder和Decoder不一致或者使用的汉字在编码ISO-8859-1中不存在时，都会表现为乱码的形式！ 

Java代码  

1. try {    
2.   
3.         // 汉字“中”用UTF-8进行URLEncode的时候，得到%e4%b8%ad(对应的ISO-8859-1的字符是中)  
4.         String item = new String(new byte[] { (byte) 0xe4, (byte) 0xb8, (byte) 0xad }, "UTF-8");  
5.         // 中  
6.         System.out.println(item);  
7.   
8.         item = new String(new byte[] { (byte) 0xe4, (byte) 0xb8, (byte) 0xad }, "ISO-8859-1");  
9.         // 中  
10.         System.out.println(item);  
11.   
12.         System.out.println(new BigInteger("253").toByteArray());  
13.         System.out.println(Integer.toBinaryString(253));  
14.   
15.         // 中  
16.         item = new String(item.getBytes("ISO_8859_1"), "UTF-8");  
17.         System.out.println(item);  
18.         // 中  
19.         item = new String(item.getBytes("UTF-8"), "ISO_8859_1");  
20.         System.out.println(item);  
21.   
22.         // 汉字中以UTF-8编码为     %E4%B8%AD（3字节）  
23.         System.out.println(URLEncoder.encode("中", "UTF-8"));    
24.         // 汉字中以UTF-8编码为     %3F      （1字节 这是由于汉字在ISO-8859-1字符集中不存在，返回的是？在ISO-8859-1下的编码）  
25.         System.out.println(URLEncoder.encode("中", "ISO-8859-1"));    
26.         // 汉字中以UTF-8编码为     %D6%D0        （2字节）  
27.         System.out.println(URLEncoder.encode("中", "GB2312"));    
28.             
29.         // 把汉字中对应的UTF-8编码                 %E4%B8%AD 用UTF-8解码得到正常的汉字 中  
30.         System.out.println(URLDecoder.decode("%E4%B8%AD", "UTF-8"));    
31.         // 把汉字中对应的ISO-8859-1编码    %3F       用ISO-8859-1解码得到?  
32.         System.out.println(URLDecoder.decode("%3F", "ISO-8859-1"));    
33.         // 把汉字中对应的GB2312编码                 %D6%D0        用GB2312解码得到正常的汉字 中   
34.         System.out.println(URLDecoder.decode("%D6%D0", "GB2312"));    
35.         // 把汉字中对应的UTF-8编码                 %E4%B8%AD 用ISO-8859-1解码  
36.         // 得到字符中（这个就是所谓的乱码，其实是3字节%E4%B8%AD中每个字节对应的ISO-8859-1中的字符）  
37.         // ISO-8859-1字符集使用了单字节内的所有空间  
38.         System.out.println(URLDecoder.decode("%E4%B8%AD", "ISO-8859-1"));  
39.         // 把汉字中对应的UTF-8编码                 %E4%B8%AD 用GB2312解码  
40.         // 得到字符涓?，因为前2字节 %E4%B8对应的GB2312的字符就是涓，而第3字节%AD在GB2312编码中不存在，故返回？  
41.         System.out.println(URLDecoder.decode("%E4%B8%AD", "GB2312"));    
42.     } catch (UnsupportedEncodingException e) {    
43.         // TODO Auto-generated catch block    
44.         e.printStackTrace();    
45.     }    

Tomcat关于encoding编码的默认设置以及相关标准: 
对于Get请求，"URI Syntax"规范规定HTTP query strings（又叫GET parameters）使用US-ASCII编码，所有不在这个编码范围内的字符，必须经常一定的转码：%61的形式（encode）。又由于ISO-8859-1 and ASCII对于0x20 to 0x7E范围内的字符是兼容的，大部分的web容器譬如Tomcat容器默认使用ISO-8859-1解码URI中%xx部分的字节。可以使用Connector中的URIEncoding来修改这个默认用来解码URI中%xx部分字节的字符集。URIEncoding要和get请求query string中encode的编码一直，或者通过设置Content-Type来告诉容器你使用什么编码来转码url中的字符 

POST请求应该自己通过参数Content-Type指定所使用的编码，由于许多客户端都没有设置一个明确的编码，tomcat就默认使用ISO-8859-1编码。注意：用来对URI进行解码的字符集，Request字符集，Response字符集的区别！不同的Request实现中，对于上述3个编码的关系是不同的 

对于POST请求，ISO-8859-1是Servlet规范中定义的HTTP request和response的默认编码。如果request或者response的字符集没有被设定，那么Servlet规范指定使用编码ISO-8859-1，请求和相应指定编码是通过Content-Type响应头来设定的。 

如果Get、Post请求没有通过Content-Type来设置编码的话，Tomcat默认使用ISO-8859-1编码。可以使用SetCharacterEncodingFilter来修改Tomcat请求的默认编码设置（encoding：使用的编码， ignore：true，不管客户端是否指定了编码都进行设置， false，只有在客户端没有指定编码的时候才进行编码设置， 默认true） 
注意：一般这个Filter建议放在所有Filter的最前面（Servlet3.0之前基于filter-mapping在web.xml中的顺序， Servlet3.0之后有参数可以指定顺序），因为一旦从request里面取值后，再进行设置的话，设置无效。因为在第一次从request取值时，tomcat会把querystring或者post方式提交的变量，用指定的编码转成从parameters数组，以后直接从这个数组中获取相应参数的值！ 

到处都使用UTF-8建议操作： 

• 1， Set URIEncoding="UTF-8" on your <Connector> in server.xml.使得Tomcat Http Get请求使用UTF-8编码
• 2， Use a character encoding filter with the default encoding set to UTF-8. 由于很多请求本身没有指定编码， Tomcat默认使用ISO-8859-1编码作为HttpServletRequest的编码，通过filter修改
• 3， Change all your JSPs to include charset name in their contentType. For example, use <%@page contentType="text/html; charset=UTF-8" %> for the usual JSP pages and <jsp:directive.page contentType="text/html; charset=UTF-8" /> for the pages in XML syntax (aka JSP Documents). 指定Jsp页面使用的编码
• 4， Change all your servlets to set the content type for responses and to include charset name in the content type to beUTF-8. Use response.setContentType("text/html; charset=UTF-8") or response.setCharacterEncoding("UTF-8"). 设置Response返回结果的编码
• 5, Change any content-generation libraries you use (Velocity, Freemarker, etc.) to use UTF-8 and to specify UTF-8 in the content type of the responses that they generate.指定所有模版引擎佘勇的编码
• 6, Disable any valves or filters that may read request parameters before your character encoding filter or jsp page has a chance to set the encoding to UTF-8. SetCharacterEncodingFilter一般要放置在第一位，否则可能无效

Java代码  

1. 1. /* 
   2. * Licensed to the Apache Software Foundation (ASF) under one or more 
   3. * contributor license agreements.  See the NOTICE file distributed with 
   4. * this work for additional information regarding copyright ownership. 
   5. * The ASF licenses this file to You under the Apache License, Version 2.0 
   6. * (the "License"); you may not use this file except in compliance with 
   7. * the License.  You may obtain a copy of the License at 
   8. * 
   9. *     http://www.apache.org/licenses/LICENSE-2.0 
   10. * 
   11. * Unless required by applicable law or agreed to in writing, software 
   12. * distributed under the License is distributed on an "AS IS" BASIS, 
   13. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
   14. * See the License for the specific language governing permissions and 
   15. * limitations under the License. 
   16. */  
   17.   
   18. package filters;  
   19.   
   20.   
   21. import java.io.IOException;  
   22. import javax.servlet.Filter;  
   23. import javax.servlet.FilterChain;  
   24. import javax.servlet.FilterConfig;  
   25. import javax.servlet.ServletException;  
   26. import javax.servlet.ServletRequest;  
   27. import javax.servlet.ServletResponse;  
   28.   
   29.   
   30. /** 
   31.  * <p>Example filter that sets the character encoding to be used in parsing the 
   32.  * incoming request, either unconditionally or only if the client did not 
   33.  * specify a character encoding.  Configuration of this filter is based on 
   34.  * the following initialization parameters:</p> 
   35.  * <ul> 
   36.  * <li><strong>encoding</strong> - The character encoding to be configured 
   37.  *     for this request, either conditionally or unconditionally based on 
   38.  *     the <code>ignore</code> initialization parameter.  This parameter 
   39.  *     is required, so there is no default.</li> 
   40.  * <li><strong>ignore</strong> - If set to "true", any character encoding 
   41.  *     specified by the client is ignored, and the value returned by the 
   42.  *     <code>selectEncoding()</code> method is set.  If set to "false, 
   43.  *     <code>selectEncoding()</code> is called <strong>only</strong> if the 
   44.  *     client has not already specified an encoding.  By default, this 
   45.  *     parameter is set to "true".</li> 
   46.  * </ul> 
   47.  * 
   48.  * <p>Although this filter can be used unchanged, it is also easy to 
   49.  * subclass it and make the <code>selectEncoding()</code> method more 
   50.  * intelligent about what encoding to choose, based on characteristics of 
   51.  * the incoming request (such as the values of the <code>Accept-Language</code> 
   52.  * and <code>User-Agent</code> headers, or a value stashed in the current 
   53.  * user's session.</p> 
   54.  * 
   55.  * @author Craig McClanahan 
   56.  * @version $Id: SetCharacterEncodingFilter.java 939521 2010-04-30 00:16:33Z kkolinko $ 
   57.  */  
   58.   
   59. public class SetCharacterEncodingFilter implements Filter {  
   60.   
   61.   
   62.     // ----------------------------------------------------- Instance Variables  
   63.   
   64.   
   65.     /** 
   66.      * The default character encoding to set for requests that pass through 
   67.      * this filter. 
   68.      */  
   69.     protected String encoding = null;  
   70.   
   71.   
   72.     /** 
   73.      * The filter configuration object we are associated with.  If this value 
   74.      * is null, this filter instance is not currently configured. 
   75.      */  
   76.     protected FilterConfig filterConfig = null;  
   77.   
   78.   
   79.     /** 
   80.      * Should a character encoding specified by the client be ignored? 
   81.      */  
   82.     protected boolean ignore = true;  
   83.   
   84.   
   85.     // --------------------------------------------------------- Public Methods  
   86.   
   87.   
   88.     /** 
   89.      * Take this filter out of service. 
   90.      */  
   91.     public void destroy() {  
   92.   
   93.         this.encoding = null;  
   94.         this.filterConfig = null;  
   95.   
   96.     }  
   97.   
   98.   
   99.     /** 
   100.      * Select and set (if specified) the character encoding to be used to 
   101.      * interpret request parameters for this request. 
   102.      * 
   103.      * @param request The servlet request we are processing 
   104.      * @param result The servlet response we are creating 
   105.      * @param chain The filter chain we are processing 
   106.      * 
   107.      * @exception IOException if an input/output error occurs 
   108.      * @exception ServletException if a servlet error occurs 
   109.      */  
   110.     public void doFilter(ServletRequest request, ServletResponse response,  
   111.                          FilterChain chain)  
   112.     throws IOException, ServletException {  
   113.   
   114.         // Conditionally select and set the character encoding to be used  
   115.         if (ignore || (request.getCharacterEncoding() == null)) {  
   116.             String encoding = selectEncoding(request);  
   117.             if (encoding != null)  
   118.                 request.setCharacterEncoding(encoding);  
   119.         }  
   120.   
   121.     // Pass control on to the next filter  
   122.         chain.doFilter(request, response);  
   123.   
   124.     }  
   125.   
   126.   
   127.     /** 
   128.      * Place this filter into service. 
   129.      * 
   130.      * @param filterConfig The filter configuration object 
   131.      */  
   132.     public void init(FilterConfig filterConfig) throws ServletException {  
   133.   
   134.     this.filterConfig = filterConfig;  
   135.         this.encoding = filterConfig.getInitParameter("encoding");  
   136.         String value = filterConfig.getInitParameter("ignore");  
   137.         if (value == null)  
   138.             this.ignore = true;  
   139.         else if (value.equalsIgnoreCase("true"))  
   140.             this.ignore = true;  
   141.         else if (value.equalsIgnoreCase("yes"))  
   142.             this.ignore = true;  
   143.         else  
   144.             this.ignore = false;  
   145.   
   146.     }  
   147.   
   148.   
   149.     // ------------------------------------------------------ Protected Methods  
   150.   
   151.   
   152.     /** 
   153.      * Select an appropriate character encoding to be used, based on the 
   154.      * characteristics of the current request and/or filter initialization 
   155.      * parameters.  If no character encoding should be set, return 
   156.      * <code>null</code>. 
   157.      * <p> 
   158.      * The default implementation unconditionally returns the value configured 
   159.      * by the <strong>encoding</strong> initialization parameter for this 
   160.      * filter. 
   161.      * 
   162.      * @param request The servlet request we are processing 
   163.      */  
   164.     protected String selectEncoding(ServletRequest request) {  
   165.   
   166.         return (this.encoding);  
   167.   
   168.     }  
   169.   
   170.   
   171. }