backup2007

导航

<2024年5月>
日一二三四五六
2829301234
567891011
12131415161718
19202122232425
2627282930311
2345678

统计

公告

@import url(http://www.blogjava.net/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);


常用链接

留言簿(1)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜

编码问题1 转

HTML：
    ……
    //实际上这里的charset=utf-8 也是可以的，因为在中文平台下
    //用了GB2312
   

JS：
    我用了两个方法提交：GET 和 POST。
    在服务器端要对应不同的提交方式转换不同的编码。
   ……
    //要传递的参数
   var queryString = "firstName=" + firstName + "&lastName=" + lastName
                          + "&birthday=" + birthday;    function  
 
    //GET方式提交
    doRequestUsingGET() {
        createXMLHttpRequest();
        var url = "GetAndPostExample?" + queryString + "&timeStamp="
                          + new Date().getTime();
        xmlHttp.onreadystatechange = handleStateChange;
        xmlHttp.open("GET", url, true);
        xmlHttp.send(null);
    }

    //POST方式提交
    function doRequestUsingPOST() {
        createXMLHttpRequest();
        var url = "GetAndPostExample?timeStamp=" + new Date().getTime();
        xmlHttp.open("POST", url, true);
        xmlHttp.onreadystatechange = handleStateChange;
        xmlHttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
        xmlHttp.send(queryString);
    }

servlet：
        response.setContentType("text/xml");

        //这个一定要设置，这里的设置应该跟HTML中的一样，但是我在这里
        //用了 uft-8， 结果也是一样。
        response.setCharacterEncoding("GB2312");
      
        //当用POST方法时，一定要设置成utf-8，否则乱码
        String firstName = new String(request.getParameter("firstName").getBytes("ISO-8859-1"), "utf-8");

        //当用GET方法时，要设置成GB2312，否则乱码。
        String lastName = new String(request.getParameter("lastName").getBytes("ISO-8859-1"), "GB2312");

测试结果：
因为界面上两个控件firstName 和  lastName都输入中文。
接收xmlHttp.responseText后，会发现其中一个为乱码，一个可以正常显示中文。

-----------------------------------------------------------------------------------------------------------

这里的方案是页面(page)是基于GBK(gb2312) 的编码格式

AJAX的中文情况,默认情况下,tomcat和weblogic的get和post请求的编码方案都不一样,不过前提都是要设置 request.setCharactorEncoding("UTF-8")如下面代码中,get方案是很烦琐的那种将得到的参数重新编码来实现的 |new String(request.getParameter("para name").getBytes("encoding name"))|而post方案是比较简单而方便的,也提倡使用这种方式,因为可以基于filter来管理编码
tomcat可以通过设置在 server.xml里的Connector元素下设置URIencoding="gbk"参数来让get使用post的方案(即get和post都使用 request.setCharactorEncoding("UTF-8"),request.getParameter("para name") )具体设置参考http://www.javaeye.com/topic/131542,不过在weblogic下无解(我个人还没发现如何实现), weblogic好像在解析get参数后自己又用什么编码格式包装过......其实AJAX get根本没有普通请求get请求作为标签的作用,我们完全可以不使用get,而只使用post

测试用的jsp和servlet在下面,丢到一个项目里,在web.xml里配置servlet后运行可以看到效果,servlet的url- pattern是这个<url-pattern>/GetAndPostExample</url-pattern>

getAndPostExample.jsp

代码
  1. <%@ page language="java" import="java.util.Date"  contentType="text/html; charset=gbk"%>  
  2. <html>  
  3.     <head>  
  4.         <title>发送带参数的信息到服务器，以及get,post的区别</title>  
  5.         <script type="text/javascript">  
  6.             var xmlHttp;               
  7.             function show()   
  8.                 {   
  9.                 document.getElementById("show").value=document.getElementById("firstName").value;   
  10.                 }   
  11.             function createXMLHttpRequest()   
  12.                 {   
  13.                 if (window.ActiveXObject)   
  14.                     xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");   
  15.                 else if (window.XMLHttpRequest)   
  16.                     xmlHttp = new XMLhttpRequest();   
  17.                 }   
  18.                
  19.             function createQueryString()   
  20.                 {   
  21.                 var firstName = document.getElementById("firstName").value;   
  22.                 var secondName = document.getElementById("secondName").value;   
  23.                 var birthday = document.getElementById("birthday").value;   
  24.                    
  25.                 var queryString = "firstName="+firstName+"&secondName="+secondName   
  26.                                                 +"&birthday="+birthday;   
  27.                 return queryString;   
  28.                 }   
  29.                
  30.             function doRequestUsingGET()   
  31.                 {   
  32.                 createXMLHttpRequest();   
  33.                 show();   
  34.                 var queryString = "GetAndPostExample?";   
  35.                 queryStringqueryString = queryString + createQueryString()   
  36.                                         + "&timeStamep=" + new Date().getTime();   
  37.                 xmlHttp.onreadystatechange = handleStateChange;   
  38.                 xmlHttp.open("GET",queryString,true);   
  39.                                     xmlHttp.setRequestHeader("RequestType","ajax");   
  40.                 xmlHttp.send(null);   
  41.                 //alert(queryString);   
  42.                 }   
  43.                    
  44.             function doRequestUsingPOST()   
  45.                 {   
  46.                 createXMLHttpRequest();   
  47.                 show();        
  48.                 var url = "GetAndPostExample"  
  49.                 var queryString = createQueryString()+ "&timeStamp="+ new Date().getTime();            
  50.                 xmlHttp.open("POST",url,true);   
  51.                 xmlHttp.onreadystatechange = handleStateChange;   
  52.                 xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded;");   
  53.                                      //设置报头,说明此请求是ajax请求   
  54.                                      xmlHttp.setRequestHeader("RequestType","ajax");   
  55.                 xmlHttp.send(queryString);   
  56.                 }   
  57.                    
  58.             function handleStateChange()   
  59.                 {   
  60.                 if (xmlHttp.readyState == 4)   
  61.                     {   
  62.                     if (xmlHttp.status == 200)   
  63.                         parseResults();   
  64.                     }   
  65.                 }   
  66.                
  67.             function parseResults()   
  68.                 {   
  69.                 var responseDiv = document.getElementById("serverResponse");   
  70.                 if (responseDiv.hasChildNodes())   
  71.                     {   
  72.                     responseDiv.removeChild(responseDiv.childNodes[0]);   
  73.                     }   
  74.                 var responseText = document.createTextNode(xmlHttp.responseText);   
  75.                 responseDiv.appendChild(responseText);   
  76.                 }   
  77.                
  78.         </script>  
  79.     </head>  
  80.     <body>  
  81.         <h1>输入你的姓，名，生日日期</h1>  
  82.         <br>  
  83.            
  84.             <table>  
  85.                 <tr>  
  86.                     <td>  
  87.                         姓：   
  88.                     </td>  
  89.                     <td>  
  90.                         <input type="text" name="firstName" id="firstName" value="羽飞">  
  91.                     </td>  
  92.                 </tr>  
  93.                     <td>  
  94.                         名：   
  95.                     </td>  
  96.                     <td>  
  97.                         <input type="text" name="secondName" id="secondName" value="翼">  
  98.                     </td>  
  99.                 <tr>  
  100.                 </tr>  
  101.                 <tr>  
  102.                     <td>  
  103.                         生日：   
  104.                     </td>  
  105.                     <td>  
  106.                         <input type="text" name="birthday" id="birthday" value="五月">  
  107.                     </td>  
  108.                     <td>  
  109.                         <input type="text" name="show" id="show">  
  110.                     </td>  
  111.                 </tr>  
  112.             </table>  
  113.         <form action="#">  
  114.             <input type="button" value="使用GET提交" onclick="doRequestUsingGET();">  
  115.             <br>  
  116.             <input type="button" value="使用POST提交" onclick="doRequestUsingPOST();">  
  117.         </form>  
  118.         <br>  
  119.         <br>           
  120.         <h2>服务器返回信息：</h2>          
  121.         <div id="serverResponse">  
  122.         </div>  
  123.     </body>  
  124. </html>  

GetAndPostExample.java

代码
  1. package yufei;   
  2.   
  3. import java.io.*;   
  4. import java.net.*;   
  5. import javax.servlet.*;   
  6. import javax.servlet.http.*;   
  7.   
  8. public class GetAndPostExample extends HttpServlet   
  9.     {   
  10.         protected void processRequest(HttpServletRequest request,   
  11.                 HttpServletResponse response, String method1)   
  12.                 throws ServletException,IOException   
  13.                 {   
  14.                 //设置文本类型(content type)   
  15.                 response.setContentType("text/xml");   
  16.                                      //设置文本类型的编码格式   
  17.                 response.setCharacterEncoding("GBK");   
  18.                 response.setHeader("Cache-Control","no-cache");   
  19.                    
  20.                 String firstName =null;   
  21.                 String secondName = null;   
  22.                 String birthday = null;   
  23.                                     //无论是get还是post,都要使用下面这句   
  24.                                     request.setCharacterEncoding("UTF-8");   
  25.                 if (method1.equals("GET"))   
  26.                 {                   
  27.                  firstName = new String(request.getParameter("firstName").getBytes("ISO8859-1"));   
  28.                  secondName = new String(request.getParameter("secondName").getBytes("ISO8859-1"));   
  29.                  birthday = new String(request.getParameter("birthday").getBytes("ISO8859-1"));   
  30.                 }   
  31.                 else if (method1.equals("POST"))   
  32.                 {                            firstName = request.getParameter("firstName");   
  33.                  secondName = request.getParameter("secondName");   
  34.                  birthday = request.getParameter("birthday");   
  35.                 }      
  36.                 String responseText = "Hello " + firstName + " " + secondName   
  37.                                 + " 你的生日是 " + birthday + " " + "(method: " + method1 + ")";                
  38.                 PrintWriter out = response.getWriter();   
  39.                 out.println(responseText);   
  40.                    
  41.                 out.close();   
  42.                 }   
  43.         protected void doGet(HttpServletRequest request,   
  44.                 HttpServletResponse response)   
  45.                 throws ServletException,IOException   
  46.                 {   
  47.                 processRequest(request,response,"GET");   
  48.                 }   
  49.         protected void doPost(HttpServletRequest request,   
  50.                 HttpServletResponse response)   
  51.                 throws ServletException,IOException   
  52.                 {   
  53.                 processRequest(request,response,"POST");   
  54.                 }   
  55.     }   

-
-

当我们的ajax请求只使用post(tomcat下可以实现get和post同样方案)请求时,我们可以使用过滤器来实现其编码设置,就可以把 servlet中的request.setCharactorEncoding提出来,去掉servlet里的 request.setCharactorEncoding("encoding name"),加入下面的过滤器
根据fins大大的指导,将过滤器重写为可以区分普通请求和ajax请求的样式了(ajax请求中设置了header)

SetCharacterEncodingFilter.java

代码
  1. package yufei;   
  2.   
  3. import java.io.IOException;   
  4. import javax.servlet.FilterChain;   
  5. import javax.servlet.FilterConfig;   
  6. import javax.servlet.ServletException;   
  7. import javax.servlet.ServletRequest;   
  8. import javax.servlet.ServletResponse;   
  9. import javax.servlet.Filter;   
  10. import javax.servlet.http.HttpServletRequest;   
  11.   
  12. public class CharactorEncodingFilter implements Filter   
  13.     {   
  14.     public CharactorEncodingFilter()   
  15.         {   
  16.         super();   
  17.         }   
  18.     private FilterConfig filterConfig;   
  19.     private String ajaxEncoding = "UTF-8";   
  20.     private String commonEncoding;   
  21.     protected boolean ignore = true;   
  22.     public void init(FilterConfig filterConfig) throws ServletException   
  23.         {   
  24.         this.filterConfig = filterConfig;   
  25.         commonEncoding = filterConfig.getInitParameter("CommonRequestEncoding");   
  26.         String value = filterConfig.getInitParameter("ignore");   
  27.         if (value == null)   
  28.             this.ignore = true;   
  29.         else if (value.equalsIgnoreCase("true"))   
  30.             this.ignore = true;   
  31.         else if (value.equalsIgnoreCase("yes"))   
  32.             this.ignore = true;   
  33.         else  
  34.             this.ignore = false;   
  35.         }   
  36.   
  37.     public void doFilter(ServletRequest req, ServletResponse res,   
  38.         FilterChain filterChain)   
  39.   
  40.         {   
  41.         try  
  42.             {   
  43.             HttpServletRequest request = (HttpServletRequest) req;   
  44.             if (ignore || (request.getCharacterEncoding() == null))   
  45.                 {   
  46.                 if (request.getHeader("RequestType") != null  
  47.                     && request.getHeader("RequestType")   
  48.                         .equalsIgnoreCase("ajax"))   
  49.                     {   
  50.                     request.setCharacterEncoding(ajaxEncoding);   
  51.                     }   
  52.                 else if (commonEncoding != null)   
  53.                     {   
  54.                     request.setCharacterEncoding(commonEncoding);   
  55.                     }   
  56.                 else  
  57.                     {   
  58.                     request.setCharacterEncoding("UTF-8");   
  59.                     }   
  60.                 }   
  61.             filterChain.doFilter(req, res);   
  62.             }   
  63.         catch (IOException e)   
  64.             {   
  65.             e.printStackTrace();   
  66.             }   
  67.         catch (ServletException e)   
  68.             {   
  69.             e.printStackTrace();   
  70.             }   
  71.         }   
  72.     public void destroy()   
  73.         {   
  74.         this.commonEncoding = null;   
  75.         this.filterConfig = null;   
  76.         }   
  77.     }   

web.xml加入如下过滤器配置

代码
  1. <filter>  
  2.     <filter-name>CharactorEncoding</filter-name>  
  3.     <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>  
  4.                  <!-- 设置编码格式到initparameter里去 -->  
  5.     <init-param>  
  6.         <param-name>CommonRequestEncoding</param-name>  
  7.         <param-value>GBK</param-value>  
  8.     </init-param>          
  9. </filter>  
  10. <filter-mapping>  
  11.     <filter-name>CharactorEncoding</filter-name>  
  12.     <url-pattern>/*</url-pattern>  
  13. </filter-mapping>  
  14. ---------------------------------------------------------------------------------------------------

  15. 字符，字节和编码

    [原创文章，转载请保留或注明出处：http://www.regexlab.com/zh/encoding.htm]

    级别：中级

    摘要：本文介绍了字符与编码的发展过程，相关概念的正确理解。举例说明了一些实际应用中，编码的实现方法。然后，本文讲述了通常对字符与编码的几种误解，由于这些误解而导致乱码产生的原因，以及消除乱码的办法。本文的内容涵盖了“中文问题”，“乱码问题”。

    掌握编码问题的关键是正确地理解相关概念，编码所涉及的技术其实是很简单的。因此，阅读本文时需要慢读多想，多思考。

    引言

    “字符与编码”是一个被经常讨论的话题。即使这样，时常出现的乱码仍然困扰着大家。虽然我们有很多的办法可以用来消除乱码，但我们并不一定理解这些 办法的内在原理。而有的乱码产生的原因，实际上由于底层代码本身有问题所导致的。因此，不仅是初学者会对字符编码感到模糊，有的底层开发人员同样对字符编 码缺乏准确的理解。

    回页首

    1. 编码问题的由来，相关概念的理解

    1.1 字符与编码的发展

    从计算机对多国语言的支持角度看，大致可以分为三个阶段：

    　 系统内码 说明 系统
    阶段一 ASCII 计算机刚开始只支持英语，其它语言不能够在计算机上存储和显示。 英文 DOS
    阶段二 ANSI编码
    （本地化）    		 为使计算机支持更多语言，通常使用 0x80~0xFF 范围的 2 个字节来表示 1 个字符。比如：汉字 '中' 在中文操作系统中，使用 [0xD6,0xD0] 这两个字节存储。

    不同的国家和地区制定了不同的标准，由此产生了 GB2312, BIG5, JIS 等各自的编码标准。这些使用 2 个字节来代表一个字符的各种汉字延伸编码方式，称为 ANSI 编码。在简体中文系统下，ANSI 编码代表 GB2312 编码，在日文操作系统下，ANSI 编码代表 JIS 编码。

    不同 ANSI 编码之间互不兼容，当信息在国际间交流时，无法将属于两种语言的文字，存储在同一段 ANSI 编码的文本中。    		 中文 DOS，中文 Windows 95/98，日文 Windows 95/98
    阶段三 UNICODE
    （国际化）    		 为了使国际间信息交流更加方便，国际组织制定了 UNICODE 字符集，为各种语言中的每一个字符设定了统一并且唯一的数字编号，以满足跨语言、跨平台进行文本转换、处理的要求。 Windows NT/2000/XP，Linux，Java

    字符串在内存中的存放方法：

    在 ASCII 阶段，单字节字符串使用一个字节存放一个字符（SBCS）。比如，"Bob123" 在内存中为：

    42 6F 62 31 32 33 00
    B o b 1 2 3 \0

    在使用 ANSI 编码支持多种语言阶段，每个字符使用一个字节或多个字节来表示（MBCS），因此，这种方式存放的字符也被称作多字节字符。比如，"中文123" 在中文 Windows 95 内存中为7个字节，每个汉字占2个字节，每个英文和数字字符占1个字节：

    D6 D0 CE C4 31 32 33 00
    中 文 1 2 3 \0

    在 UNICODE 被采用之后，计算机存放字符串时，改为存放每个字符在 UNICODE 字符集中的序号。目前计算机一般使用 2 个字节（16 位）来存放一个序号（DBCS），因此，这种方式存放的字符也被称作宽字节字符。比如，字符串 "中文123" 在 Windows 2000 下，内存中实际存放的是 5 个序号：

    2D 4E 87 65 31 00 32 00 33 00 00 00      ← 在 x86 CPU 中，低字节在前
    中 文 1 2 3 \0 　

    一共占 10 个字节。

    回页首
    1.2 字符，字节，字符串

    理解编码的关键，是要把字符的概念和字节的概念理解准确。这两个概念容易混淆，我们在此做一下区分：

    　 概念描述 举例
    字符 人们使用的记号，抽象意义上的一个符号。 '1', '中', 'a', '$', '￥', ……
    字节 计算机中存储数据的单元，一个8位的二进制数，是一个很具体的存储空间。 0x01, 0x45, 0xFA, ……
    ANSI
    字符串    		 在内存中，如果“字符”是以 ANSI 编码形式存在的，一个字符可能使用一个字节或多个字节来表示，那么我们称这种字符串为 ANSI 字符串或者多字节字符串。 "中文123"
    （占7字节）
    UNICODE
    字符串    		 在内存中，如果“字符”是以在 UNICODE 中的序号存在的，那么我们称这种字符串为 UNICODE 字符串或者宽字节字符串。 L"中文123"
    （占10字节）

    由于不同 ANSI 编码所规定的标准是不相同的，因此，对于一个给定的多字节字符串，我们必须知道它采用的是哪一种编码规则，才能够知道它包含了哪些“字符”。而对于 UNICODE 字符串来说，不管在什么环境下，它所代表的“字符”内容总是不变的。

    回页首
    1.3 字符集与编码

    各个国家和地区所制定的不同 ANSI 编码标准中，都只规定了各自语言所需的“字符”。比如：汉字标准（GB2312）中没有规定韩国语字符怎样存储。这些 ANSI 编码标准所规定的内容包含两层含义：

    1. 使用哪些字符。也就是说哪些汉字，字母和符号会被收入标准中。所包含“字符”的集合就叫做“字符集”。
    2. 规定每个“字符”分别用一个字节还是多个字节存储，用哪些字节来存储，这个规定就叫做“编码”。

    各个国家和地区在制定编码标准的时候，“字符的集合”和“编码”一般都是同时制定的。因此，平常我们所说的“字符集”，比如：GB2312, GBK, JIS 等，除了有“字符的集合”这层含义外，同时也包含了“编码”的含义。

    “UNICODE 字符集”包含了各种语言中使用到的所有“字符”。用来给 UNICODE 字符集编码的标准有很多种，比如：UTF-8, UTF-7, UTF-16, UnicodeLittle, UnicodeBig 等。

    回页首
    1.4 常用的编码简介

    简单介绍一下常用的编码规则，为后边的章节做一个准备。在这里，我们根据编码规则的特点，把所有的编码分成三类：

    分类 编码标准 说明
    单字节字符编码 ISO-8859-1 最简单的编码规则，每一个字节直接作为一个 UNICODE 字符。比如，[0xD6, 0xD0] 这两个字节，通过 iso-8859-1 转化为字符串时，将直接得到 [0x00D6, 0x00D0] 两个 UNICODE 字符，即 "ÖÐ"。

    反之，将 UNICODE 字符串通过 iso-8859-1 转化为字节串时，只能正常转化 0~255 范围的字符。
    ANSI 编码 GB2312,
    BIG5,
    Shift_JIS,
    ISO-8859-2 ……    		 把 UNICODE 字符串通过 ANSI 编码转化为“字节串”时，根据各自编码的规定，一个 UNICODE 字符可能转化成一个字节或多个字节。

    反之，将字节串转化成字符串时，也可能多个字节转化成一个字符。比如，[0xD6, 0xD0] 这两个字节，通过 GB2312 转化为字符串时，将得到 [0x4E2D] 一个字符，即 '中' 字。

    “ANSI 编码”的特点：
    1. 这些“ANSI 编码标准”都只能处理各自语言范围之内的 UNICODE 字符。
    2. “UNICODE 字符”与“转换出来的字节”之间的关系是人为规定的。
    UNICODE 编码 UTF-8,
    UTF-16, UnicodeBig ……    		 与“ANSI 编码”类似的，把字符串通过 UNICODE 编码转化成“字节串”时，一个 UNICODE 字符可能转化成一个字节或多个字节。

    与“ANSI 编码”不同的是：
    1. 这些“UNICODE 编码”能够处理所有的 UNICODE 字符。
    2. “UNICODE 字符”与“转换出来的字节”之间是可以通过计算得到的。

    我们实际上没有必要去深究每一种编码具体把某一个字符编码成了哪几个字节，我们只需要知道“编码”的概念就是把“字符”转化成“字节”就可以了。对 于“UNICODE 编码”，由于它们是可以通过计算得到的，因此，在特殊的场合，我们可以去了解某一种“UNICODE 编码”是怎样的规则。

    回页首

    2. 字符与编码在程序中的实现

    2.1 程序中的字符与字节

    在 C++ 和 Java 中，用来代表“字符”和“字节”的数据类型，以及进行编码的方法：

    类型或操作 C++ Java
    字符 wchar_t char
    字节 char byte
    ANSI 字符串 char[] byte[]
    UNICODE 字符串 wchar_t[] String
    字节串→字符串 mbstowcs(), MultiByteToWideChar() string = new String(bytes, "encoding")
    字符串→字节串 wcstombs(), WideCharToMultiByte() bytes = string.getBytes("encoding")

    以上需要注意几点：

    1. Java 中的 char 代表一个“UNICODE 字符（宽字节字符）”，而 C++ 中的 char 代表一个字节。
    2. MultiByteToWideChar() 和 WideCharToMultiByte() 是 Windows API 函数。

    回页首
    2.2 C++ 中相关实现方法

    声明一段字符串常量：

    // ANSI 字符串，内容长度 7 字节
    char         sz[20] = "中文123";

    // UNICODE 字符串，内容长度 5 个 wchar_t（10 字节）
    wchar_t wsz[20] = L"\x4E2D\x6587\x0031\x0032\x0033";

    UNICODE 字符串的 I/O 操作，字符与字节的转换操作：

    // 运行时设定当前 ANSI 编码，VC 格式
    setlocale(LC_ALL, ".936");

    // GCC 中格式
    setlocale(LC_ALL, "zh_CN.GBK");

    // Visual C++ 中使用小写 %s，按照 setlocale 指定编码输出到文件
    // GCC 中使用大写 %S
    fwprintf(fp, L"%s\n", wsz);

    // 把 UNICODE 字符串按照 setlocale 指定的编码转换成字节
    wcstombs(sz, wsz, 20);
    // 把字节串按照 setlocale 指定的编码转换成 UNICODE 字符串
    mbstowcs(wsz, sz, 20);

    在 Visual C++ 中，UNICODE 字符串常量有更简单的表示方法。如果源程序的编码与当前默认 ANSI 编码不符，则需要使用 #pragma setlocale，告诉编译器源程序使用的编码：

    // 如果源程序的编码与当前默认 ANSI 编码不一致，
    // 则需要此行，编译时用来指明当前源程序使用的编码
    #pragma setlocale    (".936")

    // UNICODE 字符串常量，内容长度 10 字节
    wchar_t wsz[20] = L"中文123";

    以上需要注意 #pragma setlocale 与 setlocale(LC_ALL, "") 的作用是不同的，#pragma setlocale 在编译时起作用，setlocale() 在运行时起作用。

    回页首
    2.3 Java 中相关实现方法

    字符串类 String 中的内容是 UNICODE 字符串：

    // Java 代码，直接写中文
    String     string = "中文123";

    // 得到长度为 5，因为是 5 个字符
    System.out.println(string.length());

    字符串 I/O 操作，字符与字节转换操作。在 Java 包 java.io.* 中，以“Stream”结尾的类一般是用来操作“字节串”的类，以“Reader”，“Writer”结尾的类一般是用来操作“字符串”的类。

    // 字符串与字节串间相互转化

    // 按照 GB2312 得到字节（得到多字节字符串）
    byte     [] bytes = string.getBytes("GB2312");

    // 从字节按照 GB2312 得到 UNICODE 字符串
    string = new String(bytes, "GB2312");

    // 要将 String 按照某种编码写入文本文件，有两种方法：

    // 第一种办法：用 Stream 类写入已经按照指定编码转化好的字节串
    OutputStream os = new FileOutputStream("1.txt");
    os.write(bytes);
    os.close();

    // 第二种办法：构造指定编码的 Writer 来写入字符串
    Writer ow = new OutputStreamWriter(new FileOutputStream("2.txt"), "GB2312");
    ow.write(string);
    ow.close();

    /* 最后得到的 1.txt 和 2.txt 都是 7 个字节 */

    如果 java 的源程序编码与当前默认 ANSI 编码不符，则在编译的时候，需要指明一下源程序的编码。比如：

    E:\>javac -encoding BIG5 Hello.java

    以上需要注意区分源程序的编码与 I/O 操作的编码，前者是在编译时起作用，后者是在运行时起作用。

    回页首

    3. 几种误解，以及乱码产生的原因和解决办法

    3.1 容易产生的误解
    　 对编码的误解
    误解一 在将“字节串”转化成“UNICODE 字符串”时，比如在读取文本文件时，或者通过网络传输文本时，容易将“字节串”简单地作为单字节字符串，采用每“一个字节”就是“一个字符”的方法进行转化。

    而实际上，在非英文的环境中，应该将“字节串”作为 ANSI 字符串，采用适当的编码来得到 UNICODE 字符串，有可能“多个字节”才能得到“一个字符”。

    通常，一直在英文环境下做开发的程序员们，容易有这种误解。
    误解二 在 DOS，Windows 98 等非 UNICODE 环境下，字符串都是以 ANSI 编码的字节形式存在的。这种以字节形式存在的字符串，必须知道是哪种编码才能被正确地使用。这使我们形成了一个惯性思维：“字符串的编码”。

    当 UNICODE 被支持后，Java 中的 String 是以字符的“序号”来存储的，不是以“某种编码的字节”来存储的，因此已经不存在“字符串的编码”这个概念了。只有在“字符串”与“字节串”转化时，或 者，将一个“字节串”当成一个 ANSI 字符串时，才有编码的概念。

    不少的人都有这个误解。

    第一种误解，往往是导致乱码产生的原因。第二种误解，往往导致本来容易纠正的乱码问题变得更复杂。

    在这里，我们可以看到，其中所讲的“误解一”，即采用每“一个字节”就是“一个字符”的转化方法，实际上也就等同于采用 iso-8859-1 进行转化。因此，我们常常使用 bytes = string.getBytes("iso-8859-1") 来进行逆向操作，得到原始的“字节串”。然后再使用正确的 ANSI 编码，比如 string = new String(bytes, "GB2312")，来得到正确的“UNICODE 字符串”。

    回页首
    3.2 非 UNICODE 程序在不同语言环境间移植时的乱码

    非 UNICODE 程序中的字符串，都是以某种 ANSI 编码形式存在的。如果程序运行时的语言环境与开发时的语言环境不同，将会导致 ANSI 字符串的显示失败。

    比如，在日文环境下开发的非 UNICODE 的日文程序界面，拿到中文环境下运行时，界面上将显示乱码。如果这个日文程序界面改为采用 UNICODE 来记录字符串，那么当在中文环境下运行时，界面上将可以显示正常的日文。

    由于客观原因，有时候我们必须在中文操作系统下运行非 UNICODE 的日文软件，这时我们可以采用一些工具，比如，南极星，AppLocale 等，暂时的模拟不同的语言环境。

    回页首
    3.3 网页提交字符串

    当页面中的表单提交字符串时，首先把字符串按照当前页面的编码，转化成字节串。然后再将每个字节转化成 "%XX" 的格式提交到 Web 服务器。比如，一个编码为 GB2312 的页面，提交 "中" 这个字符串时，提交给服务器的内容为 "%D6%D0"。

    在服务器端，Web 服务器把收到的 "%D6%D0" 转化成 [0xD6, 0xD0] 两个字节，然后再根据 GB2312 编码规则得到 "中" 字。

    在 Tomcat 服务器中，request.getParameter() 得到乱码时，常常是因为前面提到的“误解一”造成的。默认情况下，当提交 "%D6%D0" 给 Tomcat 服务器时，request.getParameter() 将返回 [0x00D6, 0x00D0] 两个 UNICODE 字符，而不是返回一个 "中" 字符。因此，我们需要使用 bytes = string.getBytes("iso-8859-1") 得到原始的字节串，再用 string = new String(bytes, "GB2312") 重新得到正确的字符串 "中"。

    回页首
    3.4 从数据库读取字符串

    通过数据库客户端（比如 ODBC 或 JDBC）从数据库服务器中读取字符串时，客户端需要从服务器获知所使用的 ANSI 编码。当数据库服务器发送字节流给客户端时，客户端负责将字节流按照正确的编码转化成 UNICODE 字符串。

    如果从数据库读取字符串时得到乱码，而数据库中存放的数据又是正确的，那么往往还是因为前面提到的“误解一”造成的。解决的办法还是通过 string = new String( string.getBytes("iso-8859-1"), "GB2312") 的方法，重新得到原始的字节串，再重新使用正确的编码转化成字符串。

    回页首
    3.5 电子邮件中的字符串

    当一段 Text 或者 HTML 通过电子邮件传送时，发送的内容首先通过一种指定的字符编码转化成“字节串”，然后再把“字节串”通过一种指定的传输编码（Content-Transfer-Encoding）进行转化得到另一串“字节串”。比如，打开一封电子邮件源代码，可以看到类似的内容：

    Content-Type: text/plain;
            charset="gb2312"
    Content-Transfer-Encoding: base64

    sbG+qcrQuqO17cf4yee74bGjz9W7+b3wudzA7dbQ0MQNCg0KvPKzxqO6uqO17cnnsaPW0NDEDQoNCg==

    最常用的 Content-Transfer-Encoding 有 Base64 和 Quoted-Printable 两种。在对二进制文件或者中文文本进行转化时，Base64 得到的“字节串”比 Quoted-Printable 更短。在对英文文本进行转化时，Quoted-Printable 得到的“字节串”比 Base64 更短。

    邮件的标题，用了一种更简短的格式来标注“字符编码”和“传输编码”。比如，标题内容为 "中"，则在邮件源代码中表示为：

    // 正确的标题格式
    Subject: =?GB2312?B?1tA=?=

    其中，

    • 第一个“=?”与“?”中间的部分指定了字符编码，在这个例子中指定的是 GB2312。
    • “?”与“?”中间的“B”代表 Base64。如果是“Q”则代表 Quoted-Printable。
    • 最后“?”与“?=”之间的部分，就是经过 GB2312 转化成字节串，再经过 Base64 转化后的标题内容。

    如果“传输编码”改为 Quoted-Printable，同样，如果标题内容为 "中"：

    // 正确的标题格式
    Subject: =?GB2312?Q?=D6=D0?=

    如果阅读邮件时出现乱码，一般是因为“字符编码”或“传输编码”指定有误，或者是没有指定。比如，有的发邮件组件在发送邮件时，标题 "中"：

    // 错误的标题格式
    Subject: =?ISO-8859-1?Q?=D6=D0?=

    这样的表示，实际上是明确指明了标题为 [0x00D6, 0x00D0]，即 "ÖÐ"，而不是 "中"。

    回页首

    4. 几种错误理解的纠正

    误解：“ISO-8859-1 是国际编码？”

    非也。iso-8859-1 只是单字节字符集中最简单的一种，也就是“字节编号”与“UNICODE 字符编号”一致的那种编码规则。当我们要把一个“字节串”转化成“字符串”，而又不知道它是哪一种 ANSI 编码时，先暂时地把“每一个字节”作为“一个字符”进行转化，不会造成信息丢失。然后再使用 bytes = string.getBytes("iso-8859-1") 的方法可恢复到原始的字节串。

    误解：“Java 中，怎样知道某个字符串的内码？”

    Java 中，字符串类 java.lang.String 处理的是 UNICODE 字符串，不是 ANSI 字符串。我们只需要把字符串作为“抽象的符号的串”来看待。因此不存在字符串的内码的问题。

posted on 2008-01-17 14:29 backup2007 阅读(539) 评论(0)  编辑  收藏


只有注册用户登录后才能发表评论。
网站导航: