krf301的博客 http://blogger.org.cn/blog/blog.asp?name=krf301 krf301的博客 blogger.org.cn W3CHINA Blog webmaster@blogger.org.cn <![CDATA[java中如何正确使用字体编码-摘自计算机世界报]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24435 krf301 2007/4/29 19:17:23  

在Java编程中，中文字体编码难倒了不少程序员，如果抓住了影响Java中文显示的几个关键因素，问题将迎刃而解。

Java是目前最流行的面向对象的编程语言之一，Java支持UTF-8、ISO-8859-1、GBK等各种字体编码，可笔者发现Java中字体编码的问题仍难倒了不少程序员，网上虽然也有不少关于在Java中如何正确显示中文的文章，但都不够全面，笔者特意总结如下。

影响Java中字体编码正确显示的有几个因素: 1)数据库的连接方式; 2)网页中使用的字体编码; 3)数据库里存放数据的字体编码; 4)Java的缺省字体编码。如果在编程中遇到不能正确显示中文时，要先弄清楚以上几项所使用的字体编码，再分析找出原因，即可解决问题。

众所周知，JSP是Java的一种，和网页有关，而网页也有自己的中文编码系统，所以JSP处理中文要比纯Java的类文件更为麻烦。本文的测试数据库是MySQL3.2，数据库连接驱动是用org.gjt.mm.mysql.Driver，这里主要讨论UTF-8和GBK的显示( GB2312是GBK的一个子集，Java中可以使用GBK来代替GB系列)。我们先来研究JSP中字体编码问题， 下面第一到第六点是针对JSP的(因为从数据库里读出中文数据与写入中文数据有所区别，咱们分别说明，前三点是从读取数据库到显示在网页，后三点是从网页输入数据到存入数据库)，第七到第九点针对纯Java的类文件。 以下rs表示ResultSet的一个实例，是执行Select语句之后产生的数据集。

一、数据库连接方式使用UTF-8

在连接数据库的驱动后面加上这句参数useUnicode=true&characterEncoding=

UTF-8，例如jdbc:mysql://localhost/DBVF?autoReconnect=true&useUnicode=

true&characterEncoding=UTF-8，从数据库里读出中文显示在使用GBK的JSP的网页里，如果数据库里存放的字体编码是UTF-8，在JSP中使用 str=new String(rs.getBytes(1),"UTF-8")或者str=rs.getString(1)，可以正确显示中文。如果数据库里存放的是GBK数据，那么JSP中也要使用str=new String(rs.getBytes(1),"GBK")来显示正确的中文。值得注意的是如果页面使用UTF-8，数据库里存放的是UTF-8，也可以用str=new String(rs.getBytes(1),"GBK")正确显示中文。如果网页是UTF-8，而数据库里存放的是GBK，无法直接显示中文，需要2步转换, str=new String(rs.getBytes(1),"GBK"); 再str=new String(str.getBytes("UTF-8"),"GBK")，才可以正确显示中文。

二、数据库连接方式使用GBK

在连接数据库的驱动后面加上这句参数useUnicode=true&characterEncoding=

GBK,例如jdbc:mysql://localhost/DBVF?autoReconnect=true&UseUnicode=true&

characterEncoding=GBK，从数据库里读出中文，显示在使用GBK的JSP的网页里，如果数据库里存放的字体编码是UTF-8，在JSP中一定要使用 str=new String(rs.getBytes(1),"UTF-8")，才正确显示中文。如果数据库里存放的是GBK数据，那么JSP中也要使用str=new String(rs.getBytes(1),"GBK") 或者直接使用str=rs.getString(1)，即可显示正确的中文。 如果网页是UTF-8，而数据库里存放的是GBK，只能用str=new String(rs.getString(1).getBytes("UTF-8"),"GBK")的方法来显示中文; 如果网页是UTF-8，而数据库里存放的是UTF-8，可用str=new String(rs.getBytes(1),"GBK") 或者rs.getString(1)方法来显示中文。

三、使用缺省数据库连接方式

连接数据库的驱动后面没有这句参数useUnicode=&characterEncoding=，例如jdbc:mysql://localhost/DBVF?autoReconnect=true，没有参数useUnicode=true&characterEncoding，表示使用默认的ISO-8895-1编码。

1. 从数据库里读出中文，显示在GBK的网页里。如果数据库里存放的字体编码是UTF-8，在JSP网页中一定要使用语句 str=new String(rs.getBytes(1),"UTF-8") 或者str= new String(rs.getString(1).getBytes("ISO-8859-1"),"UTF-8")，才可正确显示中文。如果数据库里存放的是GBK数据，那么JSP中也要使用str=new String(rs.getBytes(1),"GBK")或str=new String(rs.getString(1).getBytes("ISO-8859-1"),"GBK") 显示正确的中文。

2. 如果网页是UTF-8,不能直接正确显示GBK，需要2步转换，str=new String(rs.getBytes(1),"GBK")，再str=new String(str.getBytes("UTF-8"),"GBK") 才可以正确显示中文。如果数据库里存的是UTF-8，直接用str=new String(rs.getBytes(1),"GBK")或者str=new String(rs.getString(1).getBytes("ISO-8859-1"),"GBK")就可以显示中文了。

以上是读取数据库里中文正确显示在网页上，下面三点是如何正确存入数据库。

四、数据库连接方式使用UTF-8编码

JSP中要把网页输入的中文存入数据库，通常有一个提交(Submit)的过程，是用str=request.getParameter("username")，然后执行update或者insert语句来存入数据库。如何赋值给str很重要，而且这里中文输入与网页所使用的字体编码有关。

1、 网页使用UTF-8，使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"UTF-8")或者str= new String(request.getParameter("username").getBytes(),"UTF-8")，都可以使得存到数据库里的数据是UTF-8编码。

2. 网页使用GBK，使用str= new String(request.getParameter("username").getBytes(),"GBK")，那么存入数据库的是UTF-8编码。

3. 值得注意的是使用UTF-8的数据库连接方式不能存得GBK。

五、数据库连接方式使用GBK编码

1. 输入使用GBK网页，存到数据库里是GBK的方法: str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"GBK") 或者str= new String(request.getParameter("username").getBytes(),"GBK")。

2. 网页使用GBK，想存入UTF-8到数据库里，要分2步: 先str=new String(request.getParameter("username").getBytes(),"GBK")，再str=new String(str.getBytes("UTF-8"),"GBK")即可。

3. 网页使用UTF-8，而且使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"GBK") 或者str= new String(request.getParameter("username").getBytes(),"UTF-8")，那么存到数据库里的数据是UTF-8编码。

4. 网页使用UTF-8，而且使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"UTF-8")，那么存到数据库里的数据是GBK编码。

六、数据库连接方式使用缺省，即不使用参数useUnicode和characterEncoding

1. 网页使用GBK，如果使用str= request.getParameter("username")或者str= new String(request.getParameter("username").getBytes())，那么在数据库里的数据是GBK码。网页使用UTF-8 和使用str= request.getParameter("username")，则存入数据库是UTF-8编码。

2. 如果使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"))，那么根据网页提供的字体编码而存到数据库里，比如是UTF-8的网页，那么存到数据库中就是UTF-8编码，如果使用GBK网页，那么存到数据库里的字就是GBK编码。

3. 如果使用str= new String(request.getParameter("username").getBytes("UTF-8"),"UTF-8")这一种组合能存到正确的数据外，其他存到数据库里的数据则都是乱码或者错误码。在这个UTF-8组合的特例中，网页使用的是GBK，则存放到数据库里就是GBK，网页使用UTF-8，那么存到数据库里的就是UTF-8。

4. 网页是GBK的要存得UTF-8，一定需要2步: company=new String(request.getParameter("company").getBytes(),"GBK")和company=new String(company.getBytes("UTF-8"))。

5. 网页是UTF-8的，不能存得GBK在数据库里，一句话，改变数据库连接方式不能存得GBK码。

以上所有的都是基于JSP网页和数据库交换数据，下面讨论一下纯JAVA编程下的字体编码转换。

七、数据库连接方式使用UTF-8编码

1. 数据库里的中文是UTF-8，可以转换为GBK,但不能把GBK存入数据库。

2. 数据库是GBK，如果转换为UTF-8，使用content=new String(rs.getBytes(2),"GBK")直接将content存入数据库就可为UTF-8。

八、数据库连接方式使用GBK编码

1. 数据库里的中文是UTF-8，如果转换为GBK，使用content= new String(rs.getString(2).getBytes(),"UTF-8"),再直接使用update或者insert语句插入到数据库，即存得GBK。如果使用content= new String(rs.getString(2).getBytes(),"GBK")或者content= new String(rs.getString(2).getBytes())，再存入数据库即存得还是UTF-8编码。

2. 数据库里的中文是GBK，如果转换为UTF-8，使用content= new String(rs.getString(2).getBytes("UTF-8"))或者content= new String(rs.getString(2).getBytes("UTF-8"),"GBK")，再直接使用update或者insert语句插入到数据库,即存得UTF-8。

3. 如果某个String是GBK，要转换为UTF-8，也是使用content= new String(GBKstr.getBytes("UTF-8"))或者content= new String(GBKstr.getBytes("UTF-8"),"GBK"); 如果某个String是UTF-8，要转换为GBK，应该使用new String(UTFstr.getBytes("GBK"),"UTF-8")。

九、数据库连接方式使用缺省,即不跟参数

1. str2=new String(GBKstr.getBytes("UTF-8"),"ISO-8859-1")，可以将数据库里的GBK编码转换为UTF-8。

2. 读取UTF-8然后存入UTF-8，则用str1=new String(UTFstr.getBytes(),"ISO-8859-1")或者str1=new String(UTFstr.getBytes("GBK"),"ISO-8859-1")。

3. 不能实现数据库里的UTF-8转换为GBK。

如果采用UTF-8的数据库连接方式或者缺省数据连接方式，那么无法将UTF-8转为GBK；而GBK的数据库连接方式可以实现UTF-8和GBK的相互转换。建议大家采用GBK的数据连接方式。

]]> <![CDATA[jsp连接mysql乱码问题]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24342 krf301 2007/4/25 19:52:37

解决方法一：

连接mysql时(无论在从mysql读还是取数据的情况)，指定使用的编码方式为gb2312，具体代码如下

//装载mysql-jdbc驱动
Class.forName("com.mysql.jdbc.Driver").newInstance();
//连接数据库
Connection sqlCon = DriverManager.getConnection( "jdbc:mysql://localhost:3306/test?user=root&password=1&useUnicode=true&characterEncoding=gb2312" );

解决方法二：

如果方法一不行那么在方法一的基础上对读入的字符串进行强制编码方式转换。

代码示例如下：

String name = rst.getString("name");
name= new String(name.getBytes("ISO-8859-1"),"gb2312");

注：代码也可以为：String name =new String( rst.getString("name").getBytes("ISO-8859-1"),"gb2312"));其中rst为返回的resultset,ISO-8859-1为mysql默认的编码方式，代码的目的是把以ISO-8859-1的编码转换为gb2312编码方式，这样强制转换，可以解决一部分问题，如果结合方法一，应该可以解决中文乱码问题。

之后问题解决

]]> <![CDATA[乱码问题（二十）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24241 krf301 2007/4/21 22:48:28 但是我在用这种方式读取163的返回时就有问题，具体代码如下：
try{
                    current=null;
                    current=new WaitCanvas();
                    Display.getDisplay(MainMidlet.instance).setCurrent(current);
                    current.setMessage("正在连接。。。。。");
                    if(ConList.conmode==true){
                        int charpo=url.indexOf("/",7);
                        ip=url.substring(0,charpo);
                        String suburl=url.substring(charpo);
                        url="http://10.0.0.172"+suburl;
                        try{
                            conn=(HttpConnection)Connector.open(url,Connector.READ_WRITE,true);
                        }catch(Exception e){
                            operation.FinishAlert("停止连接网络");//不连接网络时从这里抛出异常
                            return;
                        }
                        suburl=null;
                    }else{
                        try{
                            conn=(HttpConnection)Connector.open(url,Connector.READ_WRITE,true);
                        }catch(Exception e){
                            operation.FinishAlert("停止连接网络");//不连接网络时从这里抛出异常
                            return;
                        }
                    }
                    conn.setRequestMethod(HttpConnection.POST);
                    if(ConList.conmode==true){
                        conn.setRequestProperty("X-Online-Host",ip);
                    }
                    conn.setRequestProperty("User-Agent","Profile/MIDP-2.0 Configuration/CLDC-1.1");
                    conn.setRequestProperty("Content-Language","en-US");
                    conn.setRequestProperty("Content-Type","application/octet-stream");
                    conn.setRequestProperty("Accept","application/octet-stream");
                    conn.setRequestProperty("Connection","Keep-Alive");
//                    osStrm=conn.openOutputStream();
                    current.setMessage("连接成功。。。。。");
//                    DataOutputStream os=new DataOutputStream(osStrm);
                    current.setMessage("发送请求中。。。。。");
//                    for(int i=0;i<requestcon.length;i++){
//                        os.writeUTF(requestcon[i]);
//                    }
//                    os.close();
                    current.setMessage("发送请求完成。。。。。");
                    current.setMessage("接收信息中。。。。。");
                    int rc=0;
                    try{
                        rc=conn.getResponseCode();
                    }catch(Exception e){
                        operation.FinishAlert("无法建立连接");//成功发出request后没有收到服务器的回馈信息
                        return;
                    }
                    if(rc!=HttpConnection.HTTP_OK){
                        operation.FinishAlert("服务器没有回应");//成功发出request后没有收到服务器的回馈信息
                        return;
                    }
                     isStrm=conn.openInputStream();
                     isr=new InputStreamReader(isStrm);
                     try{
                                isr=new InputStreamReader(isStrm,"UTF8");
                            }catch(Exception e1){
                                try{
                                    isr=new InputStreamReader(isStrm,"UTF-8");
                                }catch(Exception e2){
                                    try{
                                        isr=new InputStreamReader(isStrm,"utf8");
                                    }catch(Exception e3){
                                        isr=new InputStreamReader(isStrm,"utf-8");
                                    }
                                }
                            }
                            int ic;
                            StringBuffer b=new StringBuffer();
                            while ((ic = isr.read()) != -1) {
                                b.append((char)ic);
                            }
                            content=b.toString();
                isr.close();
                current.setMessage("接受完成。。。。。");

                }catch(IOException e){
                    operation.FinishAlert("连接异常");//无法连接网络时从这里抛出异常
                    return;
                }finally{
                    try{
                        if(conn!=null)
                            conn.close();
                        if(isStrm!=null)
                            isStrm.close();
                    }catch(Exception e){
                        operation.FinishAlert("关闭错误");
                    }
                }
                Alert a=new Alert("提示信息");
                a.setString(content);
                a.setTimeout(Alert.FOREVER);
                Display.getDisplay(MainMidlet.instance).setCurrent(a);

特别是中间黑体的部分，如果有这一段，读取163会提示连接异常，如果没有的话，就能读取的到信息下来，为什么在局域网中能用的方法到这些网页上就不能用了

而且对于检查conn.getResponseCode()是否为ok的状态，我感觉也是有时用了这个判断会连不上，如果不用的话直接读取反而还可以读取的信息，怎么会有这样的情况]]> <![CDATA[数据库中取存数据]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24239 krf301 2007/4/21 20:35:28 今天遇到一个乱码问题,不知是什么原因,我向数据库中插入一条记录后,再取出,若是中文,得到的就是乱码,请大伙帮帮忙...
------------------
package w113.conn;

import java.sql.*;

public class UseExecuteUpdate {

public static void main(String[] args)
{
String url = "jdbc:mysql://localhost/sql_test";
String userName = "root";
String passWord = "w113";
String sql = null;

try
{
Class.forName("com.mysql.jdbc.Driver");
}
catch(Exception e)
{
e.printStackTrace();
}

try
{
Connection conn = DriverManager.getConnection(url,userName,passWord);
Statement stmt = conn.createStatement();

sql = "insert into student values('17','张三','hubei','2054-07-30')";
int affectedRowCount = stmt.executeUpdate(sql);
System.out.println("受插入操作影响的数据行数为:" + affectedRowCount);

sql = "select * from student where stu_id = '17'";
ResultSet rs = stmt.executeQuery(sql);
while(rs.next())
{
String id = rs.getString(1);
String name = rs.getString(2);
String address = rs.getString(3);

System.out.println(id + "" + name + "" +address);
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
---------------------
我看到的结果:

受插入操作影响的数据行数为:1
17??hubei

    nationally(自由鸟) 于 2005-10-26 17:09:38
存储和取出的时候都
用String.getByte("iso8859-1")转换
w1113(文) 于 2005-10-26 17:59:30
请大哥把存储和取出时的几行代码帮我实现一下，谢谢了..
lcwlyl(网络幽灵) 于 2005-10-26 18:25:58
应该是编码的问题，试试把取出来的中文转码。
overgame(我菜我存在) 于 2005-10-26 19:08:30
取代码的时候转换下就是

public String getString(String str){
return new String(str, "GB2312");
}
pauliuyou(paul) 于 2005-10-27 10:59:03
存的时候用 s = new String(s.getBytes(),"ISO-8859-1");
取的时候用 s = new String(s.getBytes("ISO-8859-1");

w1113(文) 于 2005-10-27 17:06:01
还是乱码啊,
大哥能不能帮我把代码写具体一些?
keiy 于 2005-10-27 17:13:43
试试我的:
import java.sql.*;

public class mysqltest {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String url = "jdbc:mysql://192.168.0.222/";// 主机名和端口
String login = "test";// 登录名
String password = "test";// 密码

try {
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection(url,login,password);
//得到数据库驱动程序版本

DatabaseMetaData conMD = connection.getMetaData();
System.out.println("Driver Name:\t" + conMD.getDriverName());
System.out.println("Driver Version:\t" + conMD.getDriverVersion());
//选择数据库
connection.setCatalog( "jtest");
//创建Statement
Statement st = connection.createStatement();
//插数据
String sql2=new String("INSERT INTO test VALUES('测试',20)".getBytes("GBK"),"ISO8859_1");
st.executeUpdate(sql2);
//执行查询
ResultSet rs = st.executeQuery("SELECT * FROM test");
//取得结果，输出到屏幕
String x;
while (rs.next()){
for(int j=1; j<=rs.getMetaData().getColumnCount(); j++){
x=new String((rs.getString(j)).getBytes("ISO8859_1"),"GBK");
System.out.print( x+"\t");
}

System.out.println();
}

//关闭对象
st.close();
connection.close();
} catch(Exception e) {
System.out.println("SQL Error:"+e.getMessage());
}

}
}
]]> <![CDATA[httpconnection]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24238 krf301 2007/4/21 20:28:52 httpconnection
 
                hc = (HttpConnection) Connector.open(url , Connector.READ/*_WRITE*/ , true ) ;
                if( gateway != null ){
                    hc.setRequestProperty( "X-Online-Host", webServerAddress ) ;
                }
                hc.setRequestProperty("Content-Type" ,
                        "application/xml, text/html, text/plain, " ) ;
                if(cookieSessionID!=null){
                    hc.setRequestProperty("Cookie", cookieSessionID);
                }
                // 告知服务器当前客户端的版本号
                //hc.setRequestProperty("User-Agent", "1.0") ;  错误！
                hc.setRequestProperty("User-Agent","Profile/MIDP-2.0 Configuration/CLDC-1.1"); // CLDC-1.1
                hc.setRequestProperty("Pragma", "no-cache");
                hc.setRequestProperty("Cache-Control", "no-cache") ;
                //hc.setRequestProperty("Connection", "close");
                hc.setRequestProperty("User-Chat-Agent",
                        System.getProperty("microedition.platform") );
                hc.setRequestProperty("Accept-Charset" , "utf-8" ) ;
                hc.setRequestProperty("Accept-Language", "zh, en" ) ;
]]> <![CDATA[乱码问题（十七）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24082 krf301 2007/4/16 23:29:30   大家在JSP的开发过程中，经常出现中文乱码的问题，可能一至困扰着您，我现在把我在JSP开发中遇到的中文乱码的问题及解决办法写出来供大家参考。    
   
  一、JSP页面显示乱码    
  下面的显示页面(display.jsp)就出现乱码：    
  <html>    
  <head>    
  <title>JSP的中文处理</title>    
  <meta   http-equiv="Content-Type"   content="text/html;   charset=gb2312">    
  </head>    
   
  <body>    
  <%    
  out.print("JSP的中文处理");    
  %>    
  </body>    
  </html>    
  对不同的WEB服务器和不同的JDK版本，处理结果就不一样。原因：服务器使用的编码方式不同和浏览器对不同的字符显示结果不同而导致的。解决办法：在JSP页面中指定编码方式(gb2312),即在页面的第一行加上：<%@   page   contentType="text/html;   charset=gb2312"%>，就可以消除乱码了。完整页面如下：    
  <%@   page   contentType="text/html;   charset=gb2312"%>    
  <html>    
  <head>    
  <title>JSP的中文处理</title>    
  <meta   http-equiv="Content-Type"   content="text/html;   charset=gb2312">    
  </head>    
   
  <body>    
  <%    
  out.print("JSP的中文处理");    
  %>    
  </body>    
  </html>    
   
  二、表单提交中文时出现乱码    
  下面是一个提交页面(submit.jsp)，代码如下：    
  <html>    
  <head>    
  <title>JSP的中文处理</title>    
  <meta   http-equiv="Content-Type"   content="text/html;   charset=gb2312">    
  </head>    
   
  <body>    
  <form   name="form1"   method="post"   action="process.jsp">    
  <div   align="center">    
  <input   type="text"   name="name">    
  <input   type="submit"   name="Submit"   value="Submit">    
  </div>    
  </form>    
  </body>    
  </html>    
  下面是处理页面(process.jsp)代码：    
  <%@   page   contentType="text/html;   charset=gb2312"%>    
  <html>    
  <head>    
  <title>JSP的中文处理</title>    
  <meta   http-equiv="Content-Type"   content="text/html;   charset=gb2312">    
  </head>    
   
  <body>    
  <%=request.getParameter("name")%>    
  </body>    
  </html>    
  如果submit.jsp提交英文字符能正确显示，如果提交中文时就会出现乱码。原因：浏览器默认使用UTF-8编码方式来发送请求，而UTF-8和GB2312编码方式表示字符时不一样，这样就出现了不能识别字符。解决办法:通过request.setCharacterEncoding("gb2312")对请求进行统一编码，就实现了中文的正常显示。修改后的process.jsp代码如下：    
  <%@   page   contentType="text/html;   charset=gb2312"%>    
  <%    
  request.seCharacterEncoding("gb2312");    
  %>    
  <html>    
  <head>    
  <title>JSP的中文处理</title>    
  <meta   http-equiv="Content-Type"   content="text/html;   charset=gb2312">    
  </head>    
   
  <body>    
  <%=request.getParameter("name")%>    
  </body>    
  </html>    
   
  三、数据库连接出现乱码    
  只要涉及中文的地方全部是乱码，解决办法：在数据库的数据库URL中加上useUnicode=true&characterEncoding=GBK就OK了。    
   
  四、数据库的显示乱码    
  在mysql4.1.0中,varchar类型，text类型就会出现中文乱码，对于varchar类型把它设为binary属性就可以解决中文问题，对于text类型就要用一个编码转换类来处理，实现如下：    
  public   class   Convert   {    
  /**   把ISO-8859-1码转换成GB2312    
  */    
  public   static   String   ISOtoGB(String   iso){    
  String   gb;    
  try{    
  if(iso.equals("")   ||   iso   ==   null){    
  return   "";    
  }    
  else{    
  iso   =   iso.trim();    
  gb   =   new   String(iso.getBytes("ISO-8859-1"),"GB2312");    
  return   gb;    
  }    
  }    
  catch(Exception   e){    
  System.err.print("编码转换错误："+e.getMessage());    
  return   "";    
  }    
  }    
  }    
  把它编译成class，就可以调用Convert类的静态方法ISOtoGB()来转换编码。     
 ]]> <![CDATA[乱码问题（十六）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24080 krf301 2007/4/16 22:48:10 jsp中的乱码问题                            

关键问题：编码，建议统一为GB2312或GBK，本文使用GB2312，GBK未测试；

【Step1】： 消除纯HTML页和JSP页在Tomcat环境下运行的乱码

   这个是由于流览器无法选择编码方式造成的， 手动从IE中选择“GB2312”即可解决；也可以网页中加入META标记或Page指令；
   META标记如下：
        
   Page指令如下：
       
   前面说明中已经提到， META在2K下可能不起作用（XP下时了时坏），因为简单起见，加入Page指令似乎是一个一劳永逸的事情；

   总结： 加入Page指令，一定可以使纯JSP页面或HTML页面在Tomcat环境下正常显示。


【Step2】： 消除从MySQL数据库中读出中文的乱码

    分为两个目标： step1: 从MySQL客户端查看中文正常， step2: 从网页中查看中文正常；

  1: 在用SQL脚本创建数据库前，设置MySQL的默认编码方式为“gb2312”，
   此步可以在mysql-administrator-1.1.0-rc-win.msi中完成，或者是MySQL Server向导；
   这样设置完毕后再用SQL 脚本创建数据库， 注意如果SQL脚本中有设置字符集为latin1或utf-8的语句，一定要删除。
         已发现目前版本《在线书店》中的SQL脚本中带有设置默认字符集为latin1，一定要删除！

       创建数据库完毕后，用MySQL CC或MySQL Admin可检查所创建的数据库的字符集，如果正确，则用MySQL CC或MySQL Admin都可以正常查看中文；

  2:  一般情况下，到这一步，在网页中已经基本能正常显示中文了，但凡事总有例外，可以在数据库连接串处再特别说明一下：
       String url ="jdbc:mysql://localhost/BookStore?useUnicode=true&characterEncoding=gb2312";
       conn=DriverManager.getConnection(url,"root","");

   一般情况下用 String url ="jdbc:mysql://localhost/BookStore"应该就能正常显示中文。


   总结：修改MySQL Server数据库默认字符集为“GB2312”，从MySQL读出中文可正常显示；

   例外： 此时仍有可能还有乱码，如本书光盘中的《在线书店》，请参见前面的说明。


【Step3】： 消除插入MySQL数据库中的中文乱码

   此步比较简单，在JSP页面中加入如下代码：
          request.setCharacterEncoding("GB2312");

]]> <![CDATA[乱码问题（十五）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24079 krf301 2007/4/16 22:45:59 /JTi
©达内科技论坛 -- 达内科技论坛　　4Z\Y.
现在 Java 编程语言已经广泛应用于互联网世界，早在 Sun 公司开发 Java 语言的时候，就已经考虑到对非英文字符的支持了。Sun 公司公布的 Java 运行环境（JRE）本身就分英文版和国际版，但只有国际版才支持非英文字符。不过在 Java 编程语言的应用中，对中文字符的支持并非如同 Java Soft 的标准规范中所宣称的那样完美，因为中文字符集不只一个，而且不同的操作系统对中文字符的支持也不尽相同，所以会有许多和汉字编码处理有关的问题在我们进行应用开发中困扰着我们。有很多关于这些问题的解答，但都比较琐碎，并不能够满足大家迫切解决问题的愿望，关于 Java 中文问题的系统研究并不多，本文从汉字编码常识出发，分析 Java 中文问题，希望对大家解决这个问题有所帮助。FrC)r(
汉字编码的常识 tu
我们知道，英文字符一般是以一个字节来表示的，最常用的编码方法是 ASCII 。但一个字节最多只能区分256个字符，而汉字成千上万，所以现在都以双字节来表示汉字，为了能够与英文字符分开，每个字节的最高位一定为1，这样双字节最多可以表示64K格字符。我们经常碰到的编码方式有 GB2312、BIG5、UNICODE 等。关于具体编码方式的详细资料，有兴趣的读者可以查阅相关资料。我肤浅谈一下和我们关系密切的 GB2312 和 UNICODE。GB2312 码，中华人民共和国国家标准汉字信息交换用编码，是一个由中华人民共和国国家标准总局发布的关于简化汉字的编码，通行于中国大陆地区及新加坡，简称国标码。两个字节中，第一个字节（高字节）的值为区号值加32（20H），第二个字节（低字节）的值为位号值加32（20H），用这两个值来表示一个汉字的编码。UNICODE 码是微软提出的解决多国字符问题的多字节等长编码，它对英文字符采取前面加“0”字节的策略实现等长兼容。如 “A” 的 ASCII 码为0x41，UNICODE 就为0x00，0x41。利用特殊的工具各种编码之间可以互相转换。.Y -
Java 中文问题的初步认识 Kr-
我们基于 Java 编程语言进行应用开发时，不可避免地要处理中文。Java 编程语言默认的编码方式是 UNICODE，而我们通常使用的数据库及文件都是基于 GB2312 编码的，我们经常碰到这样的情况：浏览基于 JSP 技术的网站看到的是乱码，文件打开后看到的也是乱码，被 Java 修改过的数据库的内容在别的场合应用时无法继续正确地提供信息。 zoZKSK
String sEnglish = “apple”; `_/r
String sChinese = “苹果”; B{uVMA
String s = “苹果 apple ”; I{
sEnglish 的长度是5，sChinese的长度是4，而 s 默认的长度是14。对于 sEnglish来说， Java 中的各个类都支持得非常好，肯定能够正确显示。但对于 sChinese 和 s 来说，虽然 Java Soft 声明 Java 的基本类已经考虑到对多国字符的支持（默认 UNICODE 编码），但是如果操作系统的默认编码不是 UNICODE ，而是国标码等。从 Java 源代码到得到正确的结果，要经过 “Java 源代码-> Java 字节码-> ;虚拟机->操作系统->显示设备”的过程。在上述过程中的每一步骤，我们都必须正确地处理汉字的编码，才能够使最终的显示结果正确。 G!
“ Java 源代码-> Java 字节码”，标准的 Java 编译器 javac 使用的字符集是系统默认的字符集，比如在中文 Windows 操作系统上就是 GBK ,而在 Linux 操作系统上就是ISO-8859-1，所以大家会发现在 Linux 操作系统上编译的类中源文件中的中文字符都出了问题，解决的办法就是在编译的时候添加 encoding 参数，这样才能够与平台无关。用法是 M]9{m2
javac –encoding GBK。 ~,x
“ Java 字节码->虚拟机->操作系统”， Java 运行环境 （JRE） 分英文版和国际版，但只有国际版才支持非英文字符。 Java 开发工具包 （JDK） 肯定支持多国字符，但并非所有的计算机用户都安装了 JDK 。很多操作系统及应用软件为了能够更好的支持 Java ，都内嵌了 JRE 的国际版本，为自己支持多国字符提供了方便。 :,[k
“操作系统->显示设备”，对于汉字来说，操作系统必须支持并能够显示它。英文操作系统如果不搭配特殊的应用软件的话，是肯定不能够显示中文的。 lz
还有一个问题，就是在 Java 编程过程中，对中文字符进行正确的编码转换。例如，向网页输出中文字符串的时候，不论你是用 )(^7K
out.println(string);       // string 是含中文的字符串 ?Cxl7,
还是用 X
<%=string%>，都必须作 UNICODE 到 GBK 的转换，或者手动，或者自动。在 JSP 1.0中，可以定义输出字符集，从而实现内码的自动转换。用法是 =f#
<%@page ContentType=”text/html;charset=gb2312” %> $
但是在一些 JSP 版本中并没有提供对输出字符集的支持，（例如 JSP 0.92），这就需要手动编码输出了，方法非常多。最常用的方法是 a
String s1 = request.getParameter(“keyword”); v=>ni
String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”); }o}Z_h
getBytes 方法用于将中文字符以“ISO-8859-1”编码方式转化成字节数组，而“GBK” 是目标编码方式。我们从以ISO-8859-1方式编码的数据库中读出中文字符串 s1 ，经过上述转换过程，在支持 GBK 字符集的操作系统和应用软件中就能够正确显示中文字符串 s2 。 /UmWD
Java 中文问题的表层分析及处理 [TABLE][TR][TD]}9z}%S
背景 [/TD][/TR][TR][TD]qo(6+
开发环境 [/TD][TD]K9K%~
JDK1.15 [/TD][TD]R=FDM
Vcafe2.0 [/TD][TD]`
JPadPro [/TD][/TR][TR][TD]N'
服务器端 [/TD][TD]y*
NT IIS [/TD][TD]D~_Pe
Sybase System [/TD][TD]Q
Jconnect（JDBC） [/TD][/TR][TR][TD]5f
客户端 [/TD][TD]kbj
IE5.0 [/TD][TD]U}]^x]
Pwin98 [/TD][TD]3y^pJ7
 [/TD][/TR][/TABLE]9U
.CLASS 文件存放在服务器端，由客户端的浏览器运行 APPLET ， APPLET 只起调入 FRAME 类等主程序的作用。界面包括 Textfield ，TextArea，List，Choice 等。 X+(m:
I.       取中文 .!4X~
用 JDBC 执行 SELECT 语句从服务器端读取数据（中文）后，将数据用 APPEND 方法加到 TextArea（TA） ，不能正确显示。但加到 List 中时，大部分汉字却可正确显示。 qQ
将数据按“ISO-8859-1” 编码方式转化为字节数组，再按系统缺省编码方式 （Default Character Encoding） 转化为 STRING ，即可在 TA 和 List 中正确显示。 sGY"#y
程序段如下： J_UdS5
dbstr2 = results.getString(1); #O
//After reading the result from DB server，converting it to string. -k(a6f
dbbyte1 = dbstr2.getBytes(“iso-8859-1”); <|7`Z
dbstr1 = new String(dbbyte1); 2Mk+I
在转换字符串时不采用系统默认编码方式，而直接采用“ GBK” 或者 “GB2312” ,在 A 和 B 两种情况下，从数据库取数据都没有问题。 f0^a
II.    写中文到数据库 E
处理方式与“取中文”相逆，先将 SQL 语句按系统缺省编码方式转化为字节数组，再按“ISO-8859-1”编码方式转化为 STRING ，最后送去执行，则中文信息可正确写入数据库。 ;
程序段如下： 2{"*K
sqlstmt = tf_input.getText(); v
//Before sending statement to DB server，converting it to sql statement. >3IM
dbbyte1 = sqlstmt.getBytes(); f_bw
sqlstmt = newString(dbbyte1,”iso-8859-1”); oE*E
_stmt = _con.createStatement(); y
_stmt.executeUpdate(sqlstmt); B,<i[
…… ©达内科技论坛 -- 达内科技论坛　　#l
问题：如果客户机上存在 CLASSPATH 指向 JDK 的 CLASSES.ZIP 时（称为 A 情况），上述程序代码可正确执行。但是如果客户机只有浏览器，而没有 JDK 和 CLASSPATH 时（称为 B 情况），则汉字无法正确转换。 K
我们的分析： A
1.经过测试，在 A 情况下，程序运行时系统的缺省编码方式为 GBK 或者 GB2312 。在 B 情况下，程序启动时浏览器的 JAVA 控制台中出现如下错误信息： {w
Can't find resource for sun.awt.windows.awtLocalization_zh_CN v4
然后系统的缺省编码方式为“8859-1”。 XZ
2.如果在转换字符串时不采用系统缺省编码方式，而是直接采用 “GBK” 或“GB2312”，则在 A 情况下程序仍然可正常运行，在 B 情况下，系统出现错误： P8u%R
UnsupportedEncodingException。 x@
3.在客户机上，把 JDK 的 CLASSES.ZIP 解压后，放在另一个目录中， CLASSPATH 只包含该目录。然后一边逐步删除该目录中的 .CLASS 文件，另一边运行测试程序，最后发现在一千多个 CLASS 文件中，只有一个是必不可少的，该文件是： Rh
sun.io.CharToByteDoubleByte.class。 Y"
将该文件拷到服务器端和其它的类放在一起，并在程序的开头 IMPORT 它，在 B 情况下程序仍然无法正常运行。 r8@kQl
4.在 A 情况下，如果在 CLASSPTH 中去掉 sun.io.CharToByteDoubleByte.class ，则程序运行时测得默认编码方式为“8859-1”，否则为 “GBK” 或 “GB2312” 。 !e%*|
如果 JDK 的版本为1.2以上的话，在 B 情况下遇到的问题得到了很好的解决，测试的步骤同上，有兴趣的读者可以尝试一下。 PtS
Java 中文问题的根源分析及解决 ?
在简体中文 MS Windows 98 + JDK 1.3 下，可以用 System.getProperties() 得到 Java 运行环境的一些基本属性，类 PoorChinese 可以帮助我们得到这些属性。 QG
类 PoorChinese 的源代码： IbE:v
public class PoorChinese { t
  public static void main(String[] args) { bjo}C
      System.getProperties().list(System.out); )K$nl
  } v>M
} ©达内科技论坛 -- 达内科技论坛　　5uAq4
执行 java PoorChinese 后，我们会得到: G#b
系统变量 file.encoding 的值为 GBK ，user.language 的值为 zh ， user.region 的值为 CN ，这些系统变量的值决定了系统默认的编码方式是 GBK 。 @;qR#K
在上述系统中，下面的代码将 GB2312 文件转换成 Big5 文件，它们能够帮助我们理解 Java 中汉字编码的转化: M
 $fl8)-
import java.io.*; n>sQ
import java.util.*; eeQK6
 I
public class gb2big5 { 3L
 3S)&m
static int iCharNum=0; >SX
 >S@wh@
public static void main(String[] args) { k:
System.out.println("Input GB2312 file, output Big5 file."); '
if (args.length!=2) { '`
System.err.println("Usage: jview gb2big5 gbfile big5file"); 8k H{
System.exit(1); empH\
  } UXuB
String inputString = readInput(args[0]); "O};
writeOutput(inputString,args[1]); ~
System.out.println("Number of Characters in file: "+iCharNum+"."); N
} ©达内科技论坛 -- 达内科技论坛　　>TR
 "e@
static void writeOutput(String str, String strOutFile) { ^b
try { iX
FileOutputStream fos = new FileOutputStream(strOutFile); a[*:$
Writer out = new OutputStreamWriter(fos, "Big5"); xA"i-)
out.write(str); tVUcV
out.close(); PRZ[
} ©达内科技论坛 -- 达内科技论坛　　Y5
catch (IOException e) { -.fbA
e.printStackTrace(); R3
e.printStackTrace(); (uFOQ
} ©达内科技论坛 -- 达内科技论坛　　msoB
} ©达内科技论坛 -- 达内科技论坛　　>H,,
 ^k{-
static String readInput(String strInFile) { ug'v)
StringBuffer buffer = new StringBuffer(); l4!Y-
try { I
FileInputStream fis = new FileInputStream(strInFile); Q3=
InputStreamReader isr = new InputStreamReader(fis, "GB2312"); mP<su
Reader in = new BufferedReader(isr); K}
int ch; Eit(@
while ((ch = in.read()) > -1) { c+
iCharNum += 1; uo#,|r
buffer.append((char)ch); _-
} ©达内科技论坛 -- 达内科技论坛　　xl,2\
in.close(); #m]Mz
return buffer.toString(); 1D
} ©达内科技论坛 -- 达内科技论坛　　dK;7j1
catch (IOException e) { cNh(>
e.printStackTrace(); jM(
return null; e
} ©达内科技论坛 -- 达内科技论坛　　,
} ©达内科技论坛 -- 达内科技论坛　　SE(
} ©达内科技论坛 -- 达内科技论坛　　#'a@
 !,H
编码转化的过程如下： #!I
      ByteToCharGB2312         CharToByteBig5 ^
GB2312------------------>Unicode------------->Big5 Lo"e
执行 java gb2big5 gb.txt big5.txt ，如果 gb.txt 的内容是“今天星期三”，则得到的文件 big5.txt 中的字符能够正确显示；而如果 gb.txt 的内容是“情人节快乐”，则得到的文件 big5.txt 中对应于“节”和“乐”的字符都是符号“？”（0x3F），可见 sun.io.ByteToCharGB2312 和 sun.io.CharToByteBig5 这两个基本类并没有编好。 Iu?l!0
正如上例一样， Java 的基本类也可能存在问题。由于国际化的工作并不是在国内完成的，所以在这些基本类发布之前，没有经过严格的测试，所以对中文字符的支持并不像 Java Soft 所声称的那样完美。前不久，我的一位技术上的朋友发信给我说，他终于找到了 Java Servlet 中文问题的根源。两周以来，他一直为 Java Servlet 的中文问题所困扰，因为每面对一个含有中文字符的字符串都必须进行强制转换才能够得到正确的结果（这好象是大家公认的唯一的解决办法）。后来，他确实不想如此继续安分下去了，因为这样的事情确实不应该是高级程序员所要做的工作，他就找出 Servlet 解码的源代码进行分析，因为他怀疑问题就出在解码这部分。经过四个小时的奋斗，他终于找到了问题的根源所在。原来他的怀疑是正确的， Servlet 的解码部分完全没有考虑双字节，直接把 %XX 当作一个字符。（原来 Java Soft 也会犯这幺低级的错误！） I>io
如果你对这个问题有兴趣或者遇到了同样的烦恼的话，你可以按照他的步骤对 Servlet.jar 进行修改： Q<: N
找到源代码 HttpUtils 中的 static private String parseName ，在返回前将 sb（StringBuffer） 复制成 byte bs[] ，然后 return new String(bs,”GB2312”)。作上述修改后就需要自己解码了： 5{~
HashTable form=HttpUtils .parseQueryString(request.getQueryString())或者 >?rCS
form=HttpUtils.parsePostData(……) l&
千万别忘了编译后放到 Servlet.jar 里面。 U
五、 关于 Java 中文问题的总结 i1EYD
Java 编程语言成长于网络世界，这就要求 Java 对多国字符有很好的支持。 Java 编程语言适应了计算的网络化的需求，为它能够在网络世界迅速成长奠定了坚实的基础。 Java 的缔造者 （Java Soft） 已经考虑到 Java 编程语言对多国字符的支持，只是现在的解决方案有很多缺陷在里面，需要我们付诸一些补偿性的措施。而世界标准化组织也在努力把人类所有的文字统一在一种编码之中，其中一种方案是 ISO10646 ，它用四个字节来表示一个字符。当然，在这种方案未被采用之前，还是希望 Java Soft 能够严格地测试它的产品，为用户带来更多的方便。 O%
附一个用于从数据库和网络中取出中文乱码的处理函数，入参是有问题的字符串，出参是问题已经解决了的字符串。 l1+c
       String parseChinese(String in) _9
       { j.CS
               String s = null; $"~e
               byte temp []; N
               if (in == null) t$6
               { h3PD{
                       System.out.println("Warn:Chinese null founded!"); a5$v
                               return new String(""); [
               } 6i
               try GV6G>o
               { ,1
                       temp=in.getBytes("iso-8859-1"); >.B
                       temp=in.getBytes("iso-8859-1"); _$
                       s = new String(temp); O&6NW^
               } k
               { fU
                       System.out.println("Warn:Chinese null founded!"); Z~`0WM
                               return new String(""); fUPL
               } $],
               try \fP|x
               { VD1
                       temp=in.getBytes("iso-8859-1"); (#P
                       s = new String(temp); }uEHZ
               } 3
               catch(UnsupportedEncodingException e) ]K
               { A|m3X
                       System.out.println (e.toString()); Rv
               } Zho#s
               return s; Q(1
       } LZ7G
©达内科技论坛 -- 达内科技论坛　　,l
参考资料[UL][LI][url href=http://smth.org/SMTH2000/bbsdoc?NJava]BBS 水木清华站的 Java 讨论区[/url](
©达内科技论坛 -- 达内科技论坛　　!
[UL][LI]中国最大的电子公告板的 Java 讨论区，有众多高校的 Java 爱好者在此进行关于 Java 技术的讨论 [/LI][/UL][/LI][/UL]},~
作者简介 [UL][LI]段明辉(duanmh@dns.ime.tsinghua.edu.cn)，清华大学电子工程系学生 [UL][LI]现在正在清华大学微电子学研究所从事 Java 智能卡微处理器的研究和开发 [LI]领导 BBS 水木清华站的 Java 讨论组，为众多 Java 技术应用者提供解决方案 [/LI][/UL][/LI][/UL]R=]]> <![CDATA[乱码问题（十四）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24078 krf301 2007/4/16 22:44:28 中文乱码问题初步解决方案

一、request参数的乱码问题

现象描述：

login.html  -->  test.jsp

login.html中要求用户在表单中输入用户名和密码。如果用户输入的用户名为中文，则test.jsp获取此参数时为乱码。注意：此时的URL为：

http://localhost:8083/myweb/test.jsp?username=%D6%D0%CE%C4

处理方法有三种：

1)      对request.getParameter(“…”)取到的参数逐个new String(xxx.getBytes(“ISO-8859-1”), ”gbk”);

2)      在getParameter获取参数之前之前调用Request.setCharacterEncoding(“gbk”);

3)      Filter方式

 

 

相关问题：

如果需要在sendRedirect中自己指定URL中的参数，如果写：

res.sendRedirect("/myweb/test.jsp?username=中文”); 则会出错。

处理方法：

只要能将上述URL中的参数写成” %D6%D0%CE%C4”格式就可以使用前面的方法解决。

通过下述代码可以实现这样的目的：

String new = java.net.URLEncoder.encode("中文","GB2312");  //此时的new值即为%D6%D0%CE%C4.

然后res.sendRedirect(“/myweb/test.jsp?username=”+new);

]]> <![CDATA[乱码问题（十三）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24077 krf301 2007/4/16 22:31:01 解决web服务器各种应用的乱码问题
 

乱码问题：

（1）服务器端：
修改httpd.conf (在Redhat中放置的位置为/etc/httpd/conf/)
查找：
AddDefaultCharset ISO-8859-1
改成： 
#AddDefaultCharset ISO-8859-1 



AddDefaultCharset off
]

这种方式关掉了服务器的默认语言的发送，这样仅凭html文件头中设置的语言来决定网页语言。

很多文章都说通过修改为 AddDefaultCharset GB2312 把缺省语言改成GB2312来解决中文乱码，确实GB2312内码 的网页可以正常显示了，但这并非万全之策。因为当你的网页内码不是GB2312，就算你在网页用下面的meta指定了正确的语言，如ISO8859-1， 也不会解码为ISO8859-1，因为Apache已经先你一步将GB2312指定为网页的语言了，


（2）养成良好的习惯，在每个网页的<head>;</head>;的最前面加入这行： 

<meta http-equiv="Content-Type" content="text/html; charset=gb2312">;


一般的中文版网页编辑工具（例如FrontPage、Dreamweaver等）都会自动加上这行。

3、如何解决中文文件名无法访问 

　在ie中选择 工具 ->; internet选项 ->; 高级 ->; 取消“总是以UTF-8发送URL”。




UTF-8网页空白，在网页中加上metadata标识后，还需要手动调整编码為 utf-8 才能正常显示

如果使用的是Mozilla、Mozilla Firefox、Sarafi等其他目前流行的浏览器，通常就不会有这样的问题。

在网页的meta中指定用UTF-8： 
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />;


在<head>;</head>;之前，把"Content-Type"放在最前面，便可以解決这样的问题了。

原因：

IE 解析网页编码时是 HTML 內的标识优先的，然后是 HTTP header ；而mozilla 系列的浏览器刚刚好相反。

一般情况在，很多人是把<title>;</title>;排在最前面，并且在title中就出现了UTF-8中文，这 样，IE在解析时，就先遇到UTF-8，不往下解析了，因此必须把如果把meta放在UTF-8出现之前，这样IE才能判断这个网页是以UTF-8编码 的。


总之：
无论是 PHP、JSP、ASP 或其他动态网页的脚本语言，如果需要作编码设定，最好放在最前面。

使用php,也可以定义php的默认语言.

php.ini中： 

default_charset = "gb2312"


释掉此行，做了以上修改，一样是为了让浏览器根据网页头中的charset来自动选择语言，这样就可以在同台服务器上提供多种语言的网页服务。


java中文乱码的解决

转


在基于JAVA的编程中，经常会碰到汉字的处里及显示的问题，比如一大堆乱码或问号。
这是因为JAVA中默认的编码方式是UNICODE，而中国人通常使用的文件和DB都是基于GB2312或者BIG5等编码，故会出现此问题。

1、在网页中输出中文。

JAVA在网络传输中使用的编码是"ISO-8859-1"，故在输出时需要进行转化，如：
String   str="中文";
str=new   String(str.getBytes("GB2312"),"8859_1");
但如果在编译程序时，使用的编码是“GB2312”,且在中文平台上运行此程序，不会出现此问题，一定要注意。

2、从参数中读取中文

这正好与在网页中输出相反如：
str=new   String(str.getBytes("8859_1"),"GB2312");

3、操作DB中的中文问题

一个较简单的方法是：在“控制面扳”中，把“区域”设置为“英语(美国)”。如果还会出现乱码，还可进行如下设置：
取中文时：str=new   String(str.getBytes("GB2312"));
向DB中输入中文：str=new   String(str.getBytes("ISO-8859-1"));

4、在JSP中的中文解决：

在“控制面扳”中，把“区域”设置为“英语(美国)”.
在JSP页面中加入：
如果还不行正常显示，则还要进行下面的转换：
如：name=new   String(name.getBytes("ISO-8859-1"),"GBK");
就不会出现中文问题了。

CGI的？不知道对不？

找到CGI.pm，打开它，找到$self->;charset('ISO-8859-1');将它改为$self->;charset('GB2312');
]]> <![CDATA[乱码问题（十二）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24075 krf301 2007/4/16 22:29:06 关于java中文乱码问题一些解决方案和经验

java内核是unicode的，就连class文件也是，但是很多媒体，包括文件/流的保存方式是使用字节流的。因此java要对这些字节流经行转化。char是unicode的，而byte是字节。java中byte/char互转的函数在sun.io的包中间有。其中ByteToCharConverter类是中调度，可以用来告诉你，你用的convertor。其中两个很常用的静态函数是
publicstaticByteToCharConvertergetDefault();
publicstaticByteToCharConvertergetConverter(Stringencoding);
如果你不指定converter，则系统会自动使用当前的encoding,gb平台上用gbk,en平台上用8859_1。
byte——〉char：
"你"的gb码是：0xc4e3,unicode是0x4f60
Stringencoding="gb2312";
byteb[]={(byte)'\u00c4',(byte)'\u00e3'};
ByteToCharConverterconverter=ByteToCharConverter.getConverter(encoding);
charc[]=converter.convertAll(b);
for(inti=0;i＜c.length;i++){
System.out.println(Integer.toHexString(c));
}
结果是什么？0x4f60
如果encoding="8859_1"，结果又是什么？0x00c4,0x00e3
如果代码改为
byteb[]={(byte)'\u00c4',(byte)'\u00e3'};
ByteToCharConverterconverter=ByteToCharConverter.getDefault();
charc[]=converter.convertAll(b);
for(inti=0;i＜c.length;i++){
System.out.println(Integer.toHexString(c));
}
结果将又是什么？根据平台的编码而定。
char——〉byte：
Stringencoding="gb2312";
charc[]={'\u4f60'};
CharToByteConverterconverter=CharToByteConverter.getConverter(encoding);
byteb[]=converter.convertAll(c);
for(inti=0;i＜b.length;i++){
System.out.println(Integer.toHexString(b));
}
结果是什么？0x00c4,0x00e3
如果encoding="8859_1"，结果又是什么？0x3f
如果代码改为
Stringencoding="gb2312";
charc[]={'\u4f60'};
CharToByteConverterconverter=CharToByteConverter.getDefault();
byteb[]=converter.convertAll(c);
for(inti=0;i＜b.length;i++){
System.out.println(Integer.toHexString(b));
}
结果将又是什么？根据平台的编码而定。
很多中文问题就是从这两个最简单的类派生出来的。而却有很多类不直接支持把encoding输入，这给我们带来诸多不便。很多程序难得用encoding了，直接用default的encoding，这就给我们移植带来了很多困难。
    2.utf-8
utf-8是和unicode一一对应的，其实现很简单
7位的unicode:0_______
11位的unicode:110_____10______
16位的unicode:1110____10______10______
21位的unicode:11110___10______10______10______
大多数情况是只使用到16位以下的unicode:
"你"的gb码是：0xc4e3,unicode是0x4f60
0xc4e3的二进制：
1100，0100，1110，0011
由于只有两位我们按照两位的编码来排，但是我们发现这行不通，因为第７位不是0因此，返回"?"
0x4f60的二进制：
0100，1111，0110，0000
我们用utf-8补齐，变成：
1110，0100，1011，1101，1010，0000
e4--bd--a0
于是返回：0xe4,0xbd,0xa0。
    3.string和byte[]
string其实核心是char[],然而要把byte转化成string，必须经过编码。string.length()其实就是char数组的长度，如果使用不同的编码，很可能会错分，造成散字和乱码。
例如：
Stringencoding=“”;
byte[]b={(byte)'\u00c4',(byte)'\u00e3'};
Stringstr=newString(b,encoding);
如果encoding=8859_1，会有两个字，但是encoding=gb2312只有一个字这个问题在处理分页是经常发生。
     4.Reader,Writer/InputStream,OutputStream
Reader和Writer核心是char，InputStream和OutputStream核心是byte。但是Reader和Writer的主要目的是要把char读/写InputStream/OutputStream。
例如：
文件test.txt只有一个"你"字，0xc4,0xe3
Stringencoding="gb2312";
InputStreamReaderreader=newInputStreamReader(newFileInputStream(
"text.txt"),encoding);
charc[]=newchar[10];
intlength=reader.read(c);
for(inti=0;i＜length;i++){
System.out.println(c);
}
结果是什么？你
如果encoding="8859_1"，结果是什么？??两个字符，表示不认识。
反过来的例子自己做。
    5.我们要对java的编译器有所了解 ：
javac?encoding
我们常常没有用到encoding这个参数。其实encoding这个参数对于跨平台的操作是很重要的。如果没有指定encoding，则按照系统的默认encoding,gb平台上是gb2312，英文平台上是iso8859_1。
java的编译器实际上是调用sun.tools.javac.main的类，对文件进行编译，这个类有compile函数中间有一个encoding的变量,-encoding的参数其实直接传给encoding变量。编译器就是根据这个变量来读取java文件的，然后把用utf-8形式编译成class文件。
例子代码：
Stringstr="你";
FileWriterwriter=newFileWriter("text.txt");
write.write(str);
writer.close();
如果用gb2312编译，你会找到e4bda0的字段；
如果用8859_1编译，00c400e3的二进制：
0000，0000，1100，0100，0000，0000，1110，0011
因为每个字符都大于7位，因此用11位编码：
1100，0001，1000，0100，1100，0011，1010，0011
c1--84--c3--a3
你会找到c184c3a3。
但是我们往往忽略掉这个参数，因此这样往往会有跨平台的问题：
样例代码在中文平台上编译，生成zhclass
样例代码在英文平台上编译，输出enclass
(1).zhclass在中文平台上执行ok,但是在英文平台上不行
(2).enclass在英文平台上执行ok,但是在中文平台上不行
原因：
(1).在中文平台上编译后，其实str在运行态的char[]是0x4f60,在中文平台上运行，filewriter的缺省编码是gb2312,因此chartobyteconverter会自动用调用gb2312的converter,把str转化成byte输入到fileoutputstream中，于是0xc4,0xe3放进了文件。
但是如果是在英文平台下，chartobyteconverter的缺省值是8859_1,filewriter会自动调用8859_1去转化str,但是他无法解释，因此他会输出"?"
(2).在英文平台上编译后，其实str在运行态的char[]是0x00c40x00e3,在中文平台上运行，中文无法识别，因此会出现??；
在英文平台上，0x00c4-->0xc4,0x00e3->0xe3，因此0xc4,0xe3被放进了文件。
    6.其它原因：
＜%@pagecontentType="text/html;charset=GBK"%>
设置浏览器的显示编码，如果response的数据是utf8编码，显示将是乱码，但是乱码和上述原因还不一样。
    7.发生编码的地方 ：
从数据库到java程序byte——〉char
从java程序到数据库char——〉byte
从文件到java程序byte——〉char
从java程序到文件char——〉byte
从java程序到页面显示char——〉byte
从页面form提交数据到java程序byte——〉char
从流到java程序byte——〉char
从java程序到流char——〉byte
谢志钢的解决方法：
我是使用配置过滤器的方法解决中文乱码的：
＜web-app>
＜filter>
＜filter-name>RequestFilter＜/filter-name>
＜filter-class>net.golden.uirs.util.RequestFilter＜/filter-class>
＜init-param>
＜param-name>charset＜/param-name>
＜param-value>gb2312＜/param-value>
＜/init-param>
＜/filter>
＜filter-mapping>
＜filter-name>RequestFilter＜/filter-name>
＜url-pattern>*.jsp＜/url-pattern>
＜/filter-mapping>
＜/web-app>
publicvoiddoFilter(ServletRequestreq,ServletResponseres,
FilterChainfChain)throwsIOException,ServletException{
HttpServletRequestrequest=(HttpServletRequest)req;
HttpServletResponseresponse=(HttpServletResponse)res;
HttpSessionsession=request.getSession();
StringuserId=(String)session.getAttribute("userid");
req.setCharacterEncoding(this.filterConfig.getInitParameter("charset"));//设置字符集？
实际上是设置了byte——〉char的encoding
try{
if(userId==null||userId.equals("")){
if(!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}\\x2Ejsp$")){
session.invalidate();
response.sendRedirect(request.getContextPath()+
"/uirs/logon/logon.jsp");
}
}
else{//看看是否具有信息上报系统的权限
if(!net.golden.uirs.util.UirsChecker.check(userId,"信息上报系统",
net.golden.uirs.util.UirsChecker.ACTION_DO)){
if(!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}\\x2Ejsp$")){
response.sendRedirect(request.getContextPath()+
"/uirs/logon/logonController.jsp");
}
}
}
}
catch(Exceptionex){
response.sendRedirect(request.getContextPath()+
"/uirs/logon/logon.jsp");
}
fChain.doFilter(req,res);
} ]]> <![CDATA[乱码问题（十一）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24074 krf301 2007/4/16 22:23:52

Java中文转码的例子，用来对付乱码

 

public class HelloWorld

{

   public static void main(String[] argv){

     try{

       System.out.println("中文");//1

       System.out.println("中文".getBytes());//2

       System.out.println("中文".getBytes("GB2312"));//3

       System.out.println("中文".getBytes("ISO8859_1"));//4

       System.out.println(new String("中文".getBytes()));//5

       System.out.println(new String("中文".getBytes(),"GB2312"));//6

       System.out.println(new String("中文".getBytes(),"ISO8859_1"));//7

       System.out.println(new String("中文".getBytes("GB2312")));//8

       System.out.println(new String("中文".getBytes("GB2312"),"GB2312"));//9

       System.out.println(new String("中文".getBytes("GB2312"),"ISO8859_1"));//10

       System.out.println(new String("中文".getBytes("ISO8859_1")));//11

       System.out.println(new String("中文".getBytes("ISO8859_1"),"GB2312"));//12

       System.out.println(new String("中文".getBytes("ISO8859_1"),"ISO8859_1"));//13

     }

     catch(Exception e){

       e.printStackTrace();

     }

   }

}

]]> <![CDATA[乱码问题（十）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24073 krf301 2007/4/16 22:22:48 JSP的参数传递的乱码解决

 

本文解决了JSP的URL字符 encoding 问题：

如果通过 get/post 方式从 browser 返回的值中包含汉字信息， servlet 将无法得到正确的值。

解决方案

http://www.kaixuela.com?value=你好

解决方案是用这种方案：

<%@ page contentType="text/html;charset=gb2312" %>
<html>
你好<%=new String(request.getParameter("value").getBytes("8859_1"),"gb2312")%>
</html>
]]> <![CDATA[乱码问题（九）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24072 krf301 2007/4/16 22:19:18

深入剖析JSP和Servlet对中文的处理

世界上的各地区都有本地的语言。地区差异直接导致了语言环境的差异。在开发一个国际化程序的过程中，处理语言问题就显得很重要了。

　　这是一个世界范围内都存在的问题，所以，Java提供了世界性的解决方法。本文描述的方法是用于处理中文的，但是，推而广之，对于处理世界上其它国家和地区的语言同样适用。

　　汉字是双字节的。所谓双字节是指一个双字要占用两个BYTE的位置（即16位），分别称为高位和低位。中国规定的汉字编码为GB2312，这是强制性的，目前几乎所有的能处理中文的应用程序都支持GB2312。GB2312包括了一二级汉字和9区符号，高位从0xa1到0xfe，低位也是从0xa1到0xfe，其中，汉字的编码范围为0xb0a1到0xf7fe。

　　另外有一种编码，叫做GBK，但这是一份规范，不是强制的。GBK提供了20902个汉字，它兼容GB2312，编码范围为0x8140到0xfefe。GBK中的所有字符都可以一一映射到Unicode 2.0。

　　在不久的将来，中国会颁布另一种标准：GB18030-2000（GBK2K）。它收录了藏、蒙等少数民族的字型，从根本上解决了字位不足的问题。注意：它不再是定长的。其二字节部份与GBK兼容，四字节部分是扩充的字符、字形。它的首字节和第三字节从0x81到0xfe，二字节和第四字节从0x30到0x39。

　　本文不打算介绍Unicode，有兴趣的可以浏览“http://www.unicode.org/”查看更多的信息。Unicode有一个特性：它包括了世界上所有的字符字形。所以，各个地区的语言都可以建立与Unicode的映射关系，而Java正是利用了这一点以达到异种语言之间的转换。

　　在JDK中，与中文相关的编码有：

　　表1　JDK中与中文相关的编码列表
编码名称 说明
ASCII 7位，与ascii7相同
ISO8859-1 8-位，与 8859_1,ISO-8859-1,ISO_8859-1,latin1...等相同
GB2312-80 16位，与gb2312,gb2312-1980,EUC_CN,euccn,1381,Cp1381, 1383, Cp1383, ISO2022CN,ISO2022CN_GB...等相同
GBK 与MS936相同，注意：区分大小写
UTF8 与UTF-8相同
GB18030 与cp1392、1392相同，目前支持的JDK很少

　　在实际编程时，接触得比较多的是GB2312（GBK）和ISO8859-1。

　　为什么会有“?”号

　　上文说过，异种语言之间的转换是通过Unicode来完成的。假设有两种不同的语言A和B，转换的步骤为：先把A转化为Unicode，再把Unicode转化为B。

　　举例说明。有GB2312中有一个汉字“李”，其编码为“C0EE”，欲转化为ISO8859-1编码。步骤为：先把“李”字转化为Unicode，得到“674E”，再把“674E”转化为ISO8859-1字符。当然，这个映射不会成功，因为ISO8859-1中根本就没有与“674E”对应的字符。

　　当映射不成功时，问题就发生了！当从某语言向Unicode转化时，如果在某语言中没有该字符，得到的将是Unicode的代码“\uffffd”（“\u”表示是Unicode编码，）。而从Unicode向某语言转化时，如果某语言没有对应的字符，则得到的是“0x3f”（“?”）。这就是“?”的由来。

　　例如：把字符流buf =“0x80 0x40 0xb0 0xa1”进行new String(buf, "gb2312")操作，得到的结果是“\ufffd\u554a”，再println出来，得到的结果将是“?啊”，因为“0x80 0x40”是GBK中的字符，在GB2312中没有。

　　再如，把字符串String="\u00d6\u00ec\u00e9\u0046\u00bb\u00f9"进行new String (buf.getBytes("GBK"))操作，得到的结果是“3fa8aca8a6463fa8b4”，其中，“\u00d6”在“GBK”中没有对应的字符，得到“3f”，“\u00ec”对应着“a8ac”，“\u00e9”对应着“a8a6”，“0046”对应着“46”（因为这是ASCII字符），“\u00bb”没找到，得到“3f”，最后，“\u00f9”对应着“a8b4”。把这个字符串println一下，得到的结果是“?ìéF?ù”。看到没？这里并不全是问号，因为GBK与Unicode映射的内容中除了汉字外还有字符，本例就是最好的明证。

　　所以，在汉字转码时，如果发生错乱，得到的不一定都是问号噢！不过，错了终究是错了，50步和100步并没有质的差别。

　　或者会问：如果源字符集中有，而Unicode中没有，结果会如何？回答是不知道。因为我手头没有能做这个测试的源字符集。但有一点是肯定的，那就是源字符集不够规范。在Java中，如果发生这种情况，是会抛出异常的。

　　什么是UTF

　　UTF，是Unicode Text Format的缩写，意为Unicode文本格式。对于UTF，是这样定义的：

　　（1）如果Unicode的16位字符的头9位是0，则用一个字节表示，这个字节的首位是“0”，剩下的7位与原字符中的后7位相同，如“\u0034”（0000 0000 0011 0100），用“34” (0011 0100)表示；（与源Unicode字符是相同的）；

　　（2）如果Unicode的16位字符的头5位是0，则用2个字节表示，首字节是“110”开头，后面的5位与源字符中除去头5个零后的最高5位相同；第二个字节以“10”开头，后面的6位与源字符中的低6位相同。如“\u025d”（0000 0010 0101 1101），转化后为“c99d”（1100 1001 1001 1101）；

　　（3）如果不符合上述两个规则，则用三个字节表示。第一个字节以“1110”开头，后四位为源字符的高四位；第二个字节以“10”开头，后六位为源字符中间的六位；第三个字节以“10”开头，后六位为源字符的低六位；如“\u9da7”（1001 1101 1010 0111），转化为“e9b6a7”（1110 1001 1011 0110 1010 0111）；

　　可以这么描述JAVA程序中Unicode与UTF的关系，虽然不绝对：字符串在内存中运行时，表现为Unicode代码，而当要保存到文件或其它介质中去时，用的是UTF。这个转化过程是由writeUTF和readUTF来完成的。

　　好了，基础性的论述差不多了，下面进入正题。

　　先把这个问题想成是一个黑匣子。先看黑匣子的一级表示：

input(charsetA)->process(Unicode)->output(charsetB)

　　简单，这就是一个IPO模型，即输入、处理和输出。同样的内容要经过“从charsetA到unicode再到charsetB”的转化。

　　再看二级表示：

SourceFile(jsp,java)->class->output

　　在这个图中，可以看出，输入的是jsp和java源文件，在处理过程中，以Class文件为载体，然后输出。再细化到三级表示：

jsp->temp file->class->browser,os console,db

app,servlet->class->browser,os console,db

　　这个图就更明白了。Jsp文件先生成中间的Java文件，再生成Class。而Servlet和普通App则直接编译生成Class。然后，从Class再输出到浏览器、控制台或数据库等。

　　JSP：从源文件到Class的过程

　　Jsp的源文件是以“.jsp”结尾的文本文件。在本节中，将阐述JSP文件的解释和编译过程，并跟踪其中的中文变化。

　　1、JSP/Servlet引擎提供的JSP转换工具（jspc）搜索JSP文件中用<%@ page contentType ="text/html; charset=<Jsp-charset>"%>中指定的charset。如果在JSP文件中未指定<Jsp-charset>，则取JVM中的默认设置file.encoding，一般情况下，这个值是ISO8859-1；

　　2、jspc用相当于“javac –encoding <Jsp-charset>”的命令解释JSP文件中出现的所有字符，包括中文字符和ASCII字符，然后把这些字符转换成Unicode字符，再转化成UTF格式，存为JAVA文件。ASCII码字符转化为Unicode字符时只是简单地在前面加“00”，如“A”，转化为“\u0041”（不需要理由，Unicode的码表就是这么编的）。然后，经过到UTF的转换，又变回“41”了！这也就是可以使用普通文本编辑器查看由JSP生成的JAVA文件的原因；

　　3、引擎用相当于“javac –encoding UNICODE”的命令，把JAVA文件编译成CLASS文件；

　　先看一下这些过程中中文字符的转换情况。有如下源代码：

<%@ page contentType="text/html; charset=gb2312"%>
<html><body>
<%
　String a="中文";
　out.println(a);
%>
</body></html>

　　这段代码是在UltraEdit for Windows上编写的。保存后，“中文”两个字的16进制编码为“D6 D0 CE C4”（GB2312编码）。经查表，“中文”两字的Unicode编码为“\u4E2D\u6587”，用 UTF表示就是“E4 B8 AD E6 96 87”。打开引擎生成的由JSP文件转变而成的JAVA文件，发现其中的“中文”两个字确实被“E4 B8 AD E6 96 87”替代了，再查看由JAVA文件编译生成的CLASS文件，发现结果与JAVA文件中的完全一样。

　　再看JSP中指定的CharSet为ISO-8859-1的情况。

<%@ page contentType="text/html; charset=ISO-8859-1"%>
<html><body>
<%
　String a="中文";
　out.println(a);
%>
</body></html>

　　同样，该文件是用UltraEdit编写的，“中文”这两个字也是存为GB2312编码“D6 D0 CE C4”。先模拟一下生成的JAVA文件和CLASS文件的过程：jspc用ISO-8859-1来解释“中文”，并把它映射到Unicode。由于ISO-8859-1是8位的，且是拉丁语系，其映射规则就是在每个字节前加“00”，所以，映射后的Unicode编码应为“\u00D6\u00D0\u00CE\u00C4”，转化成UTF后应该是“C3 96 C3 90 C3 8E C3 84”。好，打开文件看一下，JAVA文件和CLASS文件中，“中文”果然都表示为“C3 96 C3 90 C3 8E C3 84”。

　　如果上述代码中不指定<Jsp-charset>，即把第一行写成“<%@ page contentType="text/html" %>”，JSPC会使用file.encoding的设置来解释JSP文件。在RedHat 6.2上，其处理结果与指定为ISO-8859-1是完全相同的。

　　到现在为止，已经解释了从JSP文件到CLASS文件的转变过程中中文字符的映射过程。一句话：从“JspCharSet到Unicode再到UTF”。下表总结了这个过程：

　　表2　“中文”从JSP到CLASS的转化过程
Jsp-CharSet JSP文件中 JAVA文件中 CLASS文件中
GB2312 D6 D0 CE C4(GB2312) 从\u4E2D\u6587(Unicode)到E4 B8 AD E6 96 87 (UTF) E4 B8 AD E6 96 87 (UTF)
ISO-8859-1 D6 D0 CE C4
(GB2312)		 从\u00D6\u00D0\u00CE\u00C4 (Unicode)到C3 96 C3 90 C3 8E C3 84 (UTF) C3 96 C3 90 C3 8E C3 84 (UTF)
无（默认＝file.encoding） 同ISO-8859-1 同ISO-8859-1 同ISO-8859-1

　　下节先讨论Servlet从JAVA文件到CLASS文件的转化过程，然后再解释从CLASS文件如何输出到客户端。之所以这样安排，是因为JSP和Servlet在输出时处理方法是一样的。

　　Servlet：从源文件到Class的过程

　　Servlet源文件是以“.java”结尾的文本文件。本节将讨论Servlet的编译过程并跟踪其中的中文变化。

　　用“javac”编译Servlet源文件。javac可以带“-encoding <Compile-charset>”参数，意思是“用< Compile-charset >中指定的编码来解释Serlvet源文件”。

　　源文件在编译时，用<Compile-charset>来解释所有字符，包括中文字符和ASCII字符。然后把字符常量转变成Unicode字符，最后，把Unicode转变成UTF。

　　在Servlet中，还有一个地方设置输出流的CharSet。通常在输出结果前，调用HttpServletResponse的setContentType方法来达到与在JSP中设置<Jsp-charset>一样的效果，称之为<Servlet-charset>。

　　注意，文中一共提到了三个变量：<Jsp-charset>、<Compile-charset>和<Servlet-charset>。其中，JSP文件只与<Jsp-charset>有关，而<Compile-charset>和<Servlet-charset>只与Servlet有关。

　　看下例：

import javax.servlet.*;

import javax.servlet.http.*;

class testServlet extends HttpServlet
{
　public void doGet(HttpServletRequest req,HttpServletResponse resp)
　throws ServletException,java.io.IOException
　{
　　resp.setContentType("text/html; charset=GB2312");
　　java.io.PrintWriter out=resp.getWriter();
　　out.println("<html>");
　　out.println("#中文#");
　　out.println("</html>");
　}
}

　　该文件也是用UltraEdit for Windows编写的，其中的“中文”两个字保存为“D6 D0 CE C4”（GB2312编码）。

　　开始编译。下表是<Compile-charset>不同时，CLASS文件中“中文”两字的十六进制码。在编译过程中，<Servlet-charset>不起任何作用。<Servlet-charset>只对CLASS文件的输出产生影响，实际上是<Servlet-charset>和<Compile-charset>一起，达到与JSP文件中的<Jsp-charset>相同的效果，因为<Jsp-charset>对编译和CLASS文件的输出都会产生影响。

　　表3　“中文”从Servlet源文件到Class的转变过程
Compile-charset Servlet源文件中 Class文件中 等效的Unicode码
GB2312 D6 D0 CE C4
(GB2312)		 E4 B8 AD E6 96 87 (UTF) \u4E2D\u6587 (在Unicode中＝“中文”)
ISO-8859-1 D6 D0 CE C4
(GB2312)		 C3 96 C3 90 C3 8E C3 84 (UTF) \u00D6 \u00D0 \u00CE \u00C4 (在D6 D0 CE C4前面各加了一个00)
无（默认） D6 D0 CE C4 (GB2312) 同ISO-8859-1 同ISO-8859-1

　　普通Java程序的编译过程与Servlet完全一样。

　　CLASS文件中的中文表示法是不是昭然若揭了？OK，接下来看看CLASS又是怎样输出中文的呢？

　　Class：输出字符串

　　上文说过，字符串在内存中表现为Unicode编码。至于这种Unicode编码表示了什么，那要看它是从哪种字符集映射过来的，也就是说要看它的祖先。这好比在托运行李时，外观都是纸箱子，里面装了什么就要看寄邮件的人实际邮了什么东西。

　　看看上面的例子，如果给一串Unicode编码“00D6 00D0 00CE 00C4”，如果不作转换，直接用Unicode码表来对照它时，是四个字符（而且是特殊字符）；假如把它与“ISO8859-1”进行映射，则直接去掉前面的“00”即可得到“D6 D0 CE C4”，这是ASCII码表中的四个字符；而假如把它当作GB2312来进行映射，得到的结果很可能是一大堆乱码，因为在GB2312中有可能没有（也有可能有）字符与00D6等字符对应（如果对应不上，将得到0x3f，也就是问号，如果对应上了，由于00D6等字符太靠前，估计也是一些特殊符号，真正的汉字在Unicode中的编码从4E00开始）。

　　各位看到了，同样的Unicode字符，可以解释成不同的样子。当然，这其中有一种是我们期望的结果。以上例而论，“D6 D0 CE C4”应该是我们所想要的，当把“D6 D0 CE C4”输出到IE中时，用“简体中文”方式查看，就能看到清楚的“中文”两个字了。（当然了，如果你一定要用“西欧字符”来看，那也没办法，你将得不到任何有何时何地的东西）为什么呢？因为“00D6 00D0 00CE 00C4”本来就是由ISO8859-1转化过去的。
　　给出如下结论：

　　在Class输出字符串前，会将Unicode的字符串按照某一种内码重新生成字节流，然后把字节流输入，相当于进行了一步“String.getBytes(???)”操作。???代表某一种字符集。

　　如果是Servlet，那么，这种内码就是在HttpServletResponse.setContentType()方法中指定的内码，也就是上文定义的＜Servlet-charset＞。

　　如果是JSP，那么，这种内码就是在＜%@ page contentType=""%＞中指定的内码，也就是上文定义的＜Jsp-charset＞。

　　如果是Java程序，那么，这种内码就是file.encoding中指定的内码，默认为ISO8859-1。

　　当输出对象是浏览器时

　　以流行的浏览器IE为例。IE支持多种内码。假如IE接收到了一个字节流“D6 D0 CE C4”，你可以尝试用各种内码去查看。你会发现用“简体中文”时能得到正确的结果。因为“D6 D0 CE C4”本来就是简体中文中“中文”两个字的编码。

　　OK，完整地看一遍。

　　JSP：源文件为GB2312格式的文本文件，且JSP源文件中有“中文”这两个汉字

　　如果指定了＜Jsp-charset＞为GB2312，转化过程如下表。

　　表4　Jsp-charset = GB2312时的变化过程
序号 步骤说明 结果
1 编写JSP源文件，且存为GB2312格式 D6 D0 CE C4
（D6D0=中 CEC4=文）
2 jspc把JSP源文件转化为临时JAVA文件，并把字符串按照GB2312映射到Unicode，并用UTF格式写入JAVA文件中 E4 B8 AD E6 96 87
3 把临时JAVA文件编译成CLASS文件 E4 B8 AD E6 96 87
4 运行时，先从CLASS文件中用readUTF读出字符串，在内存中的是Unicode编码 4E 2D 65 87（在Unicode中4E2D=中 6587=文）
5 根据Jsp-charset=GB2312把Unicode转化为字节流 D6 D0 CE C4
6 把字节流输出到IE中，并设置IE的编码为GB2312（作者按：这个信息隐藏在HTTP头中） D6 D0 CE C4
7 IE用“简体中文”查看结果 “中文”（正确显示）

　　如果指定了＜Jsp-charset＞为ISO8859-1，转化过程如下表。

　　表5　Jsp-charset = ISO8859-1时的变化过程

序号 步骤说明 结果
1 编写JSP源文件，且存为GB2312格式 D6 D0 CE C4
（D6D0=中 CEC4=文）
2 jspc把JSP源文件转化为临时JAVA文件，并把字符串按照ISO8859-1映射到Unicode，并用UTF格式写入JAVA文件中 C3 96 C3 90 C3 8E C3 84
3 把临时JAVA文件编译成CLASS文件 C3 96 C3 90 C3 8E C3 84
4 运行时，先从CLASS文件中用readUTF读出字符串，在内存中的是Unicode编码 00 D6 00 D0 00 CE 00 C4
（啥都不是！！！）
5 根据Jsp-charset=ISO8859-1把Unicode转化为字节流 D6 D0 CE C4
6 把字节流输出到IE中，并设置IE的编码为ISO8859-1（作者按：这个信息隐藏在HTTP头中） D6 D0 CE C4
7 IE用“西欧字符”查看结果 乱码，其实是四个ASCII字符，但由于大于128，所以显示出来的怪模怪样
8 改变IE的页面编码为“简体中文” “中文”（正确显示）

　　奇怪了！为什么把＜Jsp-charset＞设成GB2312和ISO8859-1是一个样的，都能正确显示？因为表4表5中的第2步和第5步互逆，是相互“抵消”的。只不过当指定为ISO8859-1时，要增加第8步操作，殊为不便。

　　再看看不指定＜Jsp-charset＞ 时的情况。

　　表6　未指定Jsp-charset 时的变化过程

序号 步骤说明 结果
1 编写JSP源文件，且存为GB2312格式 D6 D0 CE C4
（D6D0=中 CEC4=文）
2 jspc把JSP源文件转化为临时JAVA文件，并把字符串按照ISO8859-1映射到Unicode，并用UTF格式写入JAVA文件中 C3 96 C3 90 C3 8E C3 84
3 把临时JAVA文件编译成CLASS文件 C3 96 C3 90 C3 8E C3 84
4 运行时，先从CLASS文件中用readUTF读出字符串，在内存中的是Unicode编码 00 D6 00 D0 00 CE 00 C4
5 根据Jsp-charset=ISO8859-1把Unicode转化为字节流 D6 D0 CE C4
6 把字节流输出到IE中 D6 D0 CE C4
7 IE用发出请求时的页面的编码查看结果 视情况而定。如果是简体中文，则能正确显示，否则，需执行表5中的第8步

　　Servlet：源文件为JAVA文件，格式是GB2312，源文件中含有“中文”这两个汉字

　　如果＜Compile-charset＞＝GB2312，＜Servlet-charset＞=GB2312

　　表7　Compile-charset=Servlet-charset=GB2312 时的变化过程

序号 步骤说明 结果
1 编写Servlet源文件，且存为GB2312格式 D6 D0 CE C4
（D6D0=中 CEC4=文）
2 用javac –encoding GB2312把JAVA源文件编译成CLASS文件 E4 B8 AD E6 96 87　（UTF）
3 运行时，先从CLASS文件中用readUTF读出字符串，在内存中的是Unicode编码 4E 2D 65 87 (Unicode)
4 根据Servlet-charset=GB2312把Unicode转化为字节流 D6 D0 CE C4 (GB2312)
5 把字节流输出到IE中并设置IE的编码属性为Servlet-charset=GB2312 D6 D0 CE C4 (GB2312)
6 IE用“简体中文”查看结果 “中文”（正确显示）

　　如果＜Compile-charset＞＝ISO8859-1，＜Servlet-charset＞=ISO8859-1

　　表8　Compile-charset=Servlet-charset=ISO8859-1时的变化过程

序号 步骤说明 结果
1 编写Servlet源文件，且存为GB2312格式 D6 D0 CE C4
（D6D0=中 CEC4=文）
2 用javac –encoding ISO8859-1把JAVA源文件编译成CLASS文件 C3 96 C3 90 C3 8E C3 84　（UTF）
3 运行时，先从CLASS文件中用readUTF读出字符串，在内存中的是Unicode编码 00 D6 00 D0 00 CE 00 C4
4 根据Servlet-charset=ISO8859-1把Unicode转化为字节流 D6 D0 CE C4
5 把字节流输出到IE中并设置IE的编码属性为Servlet-charset=ISO8859-1 D6 D0 CE C4 (GB2312)
6 IE用“西欧字符”查看结果 乱码（原因同表5）
7 改变IE的页面编码为“简体中文” “中文”（正确显示）

　　如果不指定Compile-charset或Servlet-charset，其默认值均为ISO8859-1。

　　当Compile-charset=Servlet-charset时，第2步和第4步能互逆，“抵消”，显示结果均能正确。读者可试着写一下Compile-charset＜＞Servlet-charset时的情况，肯定是不正确的。

　　当输出对象是数据库时

　　输出到数据库时，原理与输出到浏览器也是一样的。本节只是Servlet为例，JSP的情况请读者自行推导。

　　假设有一个Servlet，它能接收来自客户端（IE，简体中文）的汉字字符串，然后把它写入到内码为ISO8859-1的数据库中，然后再从数据库中取出这个字符串，显示到客户端。

　　表9　输出对象是数据库时的变化过程（1）

序号 步骤说明 结果 域
1 在IE中输入“中文” D6 D0 CE C4 IE
2 IE把字符串转变成UTF，并送入传输流中 E4 B8 AD E6 96 87
3 Servlet接收到输入流，用readUTF读取 4E 2D 65 87(unicode) Servlet
4 编程者在Servlet中必须把字符串根据GB2312还原为字节流 D6 D0 CE C4
5 编程者根据数据库内码ISO8859-1生成新的字符串 00 D6 00 D0 00 CE 00 C4
6 把新生成的字符串提交给JDBC 00 D6 00 D0 00 CE 00 C4
7 JDBC检测到数据库内码为ISO8859-1 00 D6 00 D0 00 CE 00 C4 JDBC
8 JDBC把接收到的字符串按照ISO8859-1生成字节流 D6 D0 CE C4
9 JDBC把字节流写入数据库中 D6 D0 CE C4
10 完成数据存储工作 D6 D0 CE C4 数据库
以下是从数据库中取出数的过程
11 JDBC从数据库中取出字节流 D6 D0 CE C4 JDBC
12 JDBC按照数据库的字符集ISO8859-1生成字符串，并提交给Servlet 00 D6 00 D0 00 CE 00 C4 (Unicode)  
13 Servlet获得字符串 00 D6 00 D0 00 CE 00 C4 (Unicode) Servlet
14 编程者必须根据数据库的内码ISO8859-1还原成原始字节流 D6 D0 CE C4  
15 编程者必须根据客户端字符集GB2312生成新的字符串 4E 2D 65 87
（Unicode）		  
Servlet准备把字符串输出到客户端
16 Servlet根据＜Servlet-charset＞生成字节流 D6D0 CE C4 Servlet
17 Servlet把字节流输出到IE中，如果已指定＜Servlet-charset＞，还会设置IE的编码为＜Servlet-charset＞ D6 D0 CE C4
18 IE根据指定的编码或默认编码查看结果 “中文”（正确显示） IE

　　解释一下，表中第4第5步和第15第16步是用红色标记的，表示要由编码者来作转换。第4、5两步其实就是一句话：“new String(source.getBytes("GB2312"), "ISO8859-1")”。第15、16两步也是一句话：“new String(source.getBytes("ISO8859-1"), "GB2312")”。亲爱的读者，你在这样编写代码时是否意识到了其中的每一个细节呢？

　　至于客户端内码和数据库内码为其它值时的流程，和输出对象是系统控制台时的流程，请读者自己想吧。明白了上述流程的原理，相信你可以轻松地写出来。

　　行文至此，已可告一段落了。终点又回到了起点，对于编程者而言，几乎是什么影响都没有。

　　因为我们早就被告之要这么做了。

　　以下给出一个结论，作为结尾。

　　1、 在Jsp文件中，要指定contentType，其中，charset的值要与客户端浏览器所用的字符集一样；对于其中的字符串常量，不需做任何内码转换；对于字符串变量，要求能根据ContentType中指定的字符集还原成客户端能识别的字节流，简单地说，就是“字符串变量是基于＜Jsp-charset＞字符集的”；

　　2、 在Servlet中，必须用HttpServletResponse.setContentType()设置charset，且设置成与客户端内码一致；对于其中的字符串常量，需要在Javac编译时指定encoding，这个encoding必须与编写源文件的平台的字符集一样，一般说来都是GB2312或GBK；对于字符串变量，与JSP一样，必须“是基于＜Servlet-charset＞字符集的”。

]]> <![CDATA[乱码问题（八）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24071 krf301 2007/4/16 22:16:52 关于JAVA乱码！- -

                                      

=====乱码情况1：与jsp相关
现象：通过param = new String(param.getBytes("iso8859-1"), "gb2312");//对bytes[]内容按指定进行转码
>>>解决方法
1、加在jsp文件前面
<%@ page contentType="text/html;charset=gb2312" language="java"%>//只是指定显示的编码，不转码
<META http-equiv=Content-Type content="text/html; charset=gb2312">//只是指定显示的编码，不转码
2、也加在jsp文件前面
<%@page pageEncoding="GB2312"%>//指定*.jsp的编译时的编码方式。
<% request.setCharacterEncoding("gb2312");%>//对bytes[]内容按指定进行转码
3、在web.xml里面可以有filter(代码见附录)，作用与上一点是一样的，只是不需要每一个jsp都去写那句代码。
4、可能在tomcat4.1.24以后的版本中，如果不是在from中post出去的中文字符，都会有问题！

=====乱码情况2：与URL相关
http://127.0.0.1/encode/a.jsp?param=我爱小宝
现象：通过param = new String(param.getBytes("iso8859-1"), "gb2312");好像不可以转换这种乱码
是通过httpclient而后成了乱码，在tcp流里面是经过编码的，但转不成功
>>>解决方法
import java.net.URLEncoder;
import java.net.URLDecoder;
sourcePath = URLEncoder.encode(sourcePath);
this.sourcePath = URLDecoder.decode(sourcePath);//如果过来的是未encode的字符，不会出错，只是不decode

====其它
1、使得Java语言拥有16位的Java字符，而却只有8位的输入设备，这样就给Java带来了些不足
2、各种编码方式在转换时像GBK<-->Unicode/iso8859-1<-->Unicode之间是涵盖关系，不会丢失信息。
3、提问：GB2312被 Unicode涵盖，那为什么不可以都用UTF-8，只在显示的时候转成GB12312???
4、WEB容器在其内部默认的字符编码格式都是以ISO-8859-1为默认值的
5、浏览器在传递参数时都是默认以UTF-8的方式来传递参数的
6、只要入口和出口保证是GB2312，就可以了，其内容可能会在iso8859-1/Unicode之间转换。
 a、指定-encoding 2312对*.java文件进行编译
 b、输出时指定编码：charset=gb2312
 c、接受URL参数时指定编码：request.setCharacterEncoding("gb2312");
 d、保证系统default encoding是GBK
 e、把数据库默认支持的编码格式改为GBK或GB2312的。(如果不设，jdbc缺省以iso8859-1来存信息)
 f、在*.java文件中采用字符流来处理带中文的字符串
 g、指定我们的JSP源文件的编码格式：<%@page pageEncoding="GB2312"%>

====相关链接
深入Java中文问题及最优解决方法--上：http://www.pconline.com.cn/pcedu/empolder/gj/java/0404/366404.html
深入Java中文问题及最优解决方法-下：http://www.pconline.com.cn/pcedu/empolder/gj/java/0405/368760.html
JAVA字符编码：http://www.weiw.com/article/list.asp?id=741
JSP/Servlet 中的汉字编码问题【转载】＋【原创】：http://www.weiw.com/article/list.asp?id=741(中文转码时'?'、乱码的由来)

====附录
1、java类代码，编译后的class在CLASSPATH中能指定
package aaa;
import java.io.IOException;
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.UnavailableException;

public class EncodingFilter implements Filter {
    protected String encoding = null;
    protected FilterConfig filterConfig = null;
    public void destroy() {
        this.encoding = null;
        this.filterConfig = null;

    }
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  throws IOException, ServletException {
        // Select and set (if needed) the character encoding to be used
        String encoding = selectEncoding(request);
        if (encoding != null)
        {
            request.setCharacterEncoding(encoding);
        }
  // Pass control on to the next filter
        chain.doFilter(request, response);
    }
    public void init(FilterConfig filterConfig) throws ServletException {
  this.filterConfig = filterConfig;
        this.encoding = filterConfig.getInitParameter("encoding");
    }
    protected String selectEncoding(ServletRequest request) {
        return (this.encoding);
    }
}
同时，在web.xml中加入如下配置：
[code]
    <filter>
        <filter-name>Set Character Encoding</filter-name>
        <filter-class>aaa.EncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>GBK</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>Set Character Encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
[/code]

]]> <![CDATA[乱码问题（七）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24070 krf301 2007/4/16 22:10:33

按照jsp规范防止乱码

                                      

举个例子: 
1
2
 
<%@ page contentType="text/html;charset=utf-8" %>
你好吗？



resin等服务器大都会打印出乱码（tomcat除外），但是如果更改为 

1
2
 
<%@ page contentType="text/html;charset=utf-8" pageEncoding="GBK"%>
你好吗？



这样就服务器一定会是正确抓到“你好吗”了。

关于 contentType 和 pageEncoding 的差异 和 中文JSP页的设定技巧:

contentType -- 指定的是JSP页最终 Browser(客户端)所见到的网页内容的编码.
就是 Mozilla的 Character encoding, 或者是 IE6的 encoding. 例如 JSPtw Forum 用的contentType就是 Big5.

pageEncoding -- 指定JSP编写时所用的编码
如果你的是WIN98, 或 ME 的NOTEPAD记事本编写JSP, 就一定是常用的是Big5 或 gb2312, 如果是用 WIN2k winXP的NOTEPAD时, SAVE时就可以选择不同的编,码, 包括 ANSI(BIG5/GB2312)或 UTF-8 或 UNIONCODE(估是 UCS 16).

因为 JSP要经过 两次的"编码", 第一阶段会用 pageEncoding, 第二阶段会用 utf-8 至utf-8, 第三阶段就是由TOMCAT出来的网页, 用的是contentType.

阶段一是 JSPC的 JSP至JAVA(.java)原码的"翻译", 它会跟据 pageEncoding 的设定读取JSP. 结果是 由指定的 pageEncoding(utf-8,Big5,gb2312)的JSP 翻译成统一的utf-8 JAVA原码(.java). 如果pageEncoding设定错了, 或没设定(预设 ISO8859-1), 出来的 在这个阶段 就已是中文乱码.

阶段二是由 JAVAC的JAVA原码至JAVA BYTECODE的编译. 不论JSP的编写时是用(utf-8,Big5,gb2312),经过阶段一的结果全都是utf-8的ENCODING的JAVA原码.
JAVAC用 utf-8的ENCODING读取AVA原码, 编译成字符串是 utf-8 ENCODING的二进制码(.class). 这是 JAVA VIRTUAL MACNHINE 对常数字符串在 二进制码(JAVA BYTECODE)内表逹的规范.

阶段三是TOMCAT(或其的application container)加载和执行 阶段二得来的JAVA二进制码, 输出的结果( 也就是BROWSER(客户端)) 见到的. 这时一早隐藏在阶段一和二的参数contentType, 就发挥了功效.

(见 阶段一的

1

 response.setContentType("text/html; charset=UTF-8");

).
出来的可以是 utf-8, Big5, gb2312, 看的就是JSP

1

<%@ page session="false" pageEncoding="big5" contentType="text/html; charset=UTF-8" %>

? contentType的设定.

**还有, pageEncoding 和contentType的预设都是 ISO8859-1. 而随便设定了其中一个, 另一个就跟着一样了(TOMCAT4.1.27是如此). 但这不是绝对, 看的各自JSPC的处理方式. 而pageEncoding不等于contentType, 更有利亚洲区的文字 CJKV系JSP网页的开发和展示, (例pageEncoding=Big5 不等于 contentType=utf-8).

小结：为了能使应用兼容多服务器，应按照jsp标准。对于编码问题统一使用
 
1

 
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8"%>

]]> <![CDATA[乱码问题（六）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24069 krf301 2007/4/16 22:06:55 Tomcat中文乱码问题的原理和解决方法
 　　自从接触Java和JSP以来，就不断与Java的中文乱码问题打交道，现在终于得到了彻底的解决，现将我们的解决心得与大家共享。

　　一、Java中文问题的由来

　　Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，Java和JSP文件本身编译时产生的乱码问题和Java程序于其他媒介交互产生的乱码问题。

　　首先Java（包括JSP）源文件中很可能包含有中文，而Java和JSP源文件的保存方式是基于字节流的，如果Java和JSP编译成class文件过程中，使用的编码方式与源文件的编码不一致，就会出现乱码。基于这种乱码，建议在Java文件中尽量不要写中文（注释部分不参与编译，写中文没关系），如果必须写的话，尽量手动带参数－ecoding GBK或－ecoding gb2312编译；对于JSP，在文件头加上<%@ page contentType="text/html;charset=GBK"%>或<%@ page contentType="text/html;charset=gb2312"%>基本上就能解决这类乱码问题。

　　本文要重点讨论的是第二类乱码，即Java程序与其他存储媒介交互时产生的乱码。很多存储媒介，如数据库，文件，流等的存储方式都是基于字节流的，Java程序与这些媒介交互时就会发生字符(char)与字节(byte)之间的转换，例如从页面提交表单中提交的数据在Java程序里显示乱码等情况。

　　如果在以上转换过程中使用的编码方式与字节原有的编码不一致，很可能就会出现乱码。

　　二、解决方法

　　对于流行的Tomcat来说，有以下两种解决方法：

　　1) 更改 D:\Tomcat\conf\server.xml，指定浏览器的编码格式为“简体中文”：

　　方法是找到 server.xml 中的

    <Connector port="8080" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
    enableLookups="false" redirectPort="8443" acceptCount="100"
    connectionTimeout="20000" disableUploadTimeout="true" URIEncoding='GBK' />

　　标记，粗体字是我添加的。

　　可以这样验证你的更改是否成功：在更改前，在你出现乱码的页面的IE浏览器，点击菜单“查看｜编码”，会发现“西欧(ISO)”处于选中状态。而更改后，点击菜单“查看｜编码”，会发现“简体中文(GB2312)”处于选中状态。

　　b)更该 Java 程序，我的程序是这样的：

public class ThreeParams extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
      response.setContentType("text/html; charset=GBK");
      ...
  } 
}

]]> <![CDATA[乱码问题（五）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24068 krf301 2007/4/16 22:02:33 jsp,struts处理中文乱码问题
一、关于jsp处理中文乱码的问题
  在web.xml中设置正确的编码类型，使网页在发送表单时不会出现中文乱码。
/*
 * 解决中文乱码问题，该类必须在web.xml设置，指定编码类型
 */
package com.login.app;
 
import java.io.IOException;
 
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
 
public class SetCharacterEncodingFilter implements Filter {
    protected String encoding = null;
 
    protected FilterConfig filterConfig = null;
 
    protected boolean ignore = true;
 
    /**
     * Take this filter out of service.
     */
    public void destroy() {
 
        this.encoding = null;
        this.filterConfig = null;
 
    }
 
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain)
        throws IOException, ServletException {
 
        // Conditionally select and set the character encoding to be used
        if (ignore || (request.getCharacterEncoding() == null)) {
            String encoding = selectEncoding(request);
            if (encoding != null)
                request.setCharacterEncoding(encoding);
        }
 
        // Pass control on to the next filter
        chain.doFilter(request, response);
 
    }
 
 
    /**
     * Place this filter into service.
     *
     * @param filterConfig The filter configuration object
     */
    public void init(FilterConfig filterConfig) throws ServletException {
 
        this.filterConfig = filterConfig;
        this.encoding = filterConfig.getInitParameter("encoding");
        String value = filterConfig.getInitParameter("ignore");
        if (value == null)
            this.ignore = true;
        else if (value.equalsIgnoreCase("true"))
            this.ignore = true;
        else if (value.equalsIgnoreCase("yes"))
            this.ignore = true;
        else
            this.ignore = false;
 
    }
 
    protected String selectEncoding(ServletRequest request) {
 
        return (this.encoding);
 
    }
}
参照tomcat自带的filter类，自己写一个filter的子类，用来设置编码。并在web.xml上指定就可以了：
<!--filer in Chinese--> 
 <filter>
     <filter-name>Set Character Encoding</filter-name>
     <filter-class>com.login.app.SetCharacterEncodingFilter</filter-class>
             <init-param>
              <param-name>encoding</param-name>
              <param-value>GBK</param-value><!—在此处设置相应的编码à
             </init-param>
 </filter>
 
 <filter-mapping>
            <filter-name>Set Character Encoding</filter-name>
            <url-pattern>*.jsp</url-pattern>
 </filter-mapping>
把以上代码放在web.xml中<display-name>Encoding Application</display-name>的后面.
二、在struts中处理中文乱码问题：
要解决在提交表单时，中文不会出显乱码，只须继承RequestProcessor类，重写processPreprocess这个方法，则可以解决。
package com.login.app;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.RequestProcessor;
public class MyRequestProcessor extends RequestProcessor{
 public MyRequestProcessor(){}
 protected boolean processPreprocess(HttpServletRequest request,
   HttpServletResponse response){
  try{
   request.setCharacterEncoding("UTF-8");//在此设置字符集
  }
  catch(Exception ex){
   System.out.println("字符集设置失败");
  }
  return true;
 }
}
并在struts-config.xml设置相应的<controller>，如下所示：
<controller processorClass="com.login.app.MyRequestProcessor"/>
 三、解决插入和读取数据库数据时出现的中文乱码
插入数据到数据库时出现乱码：
这种乱码会使你插入数据库的中文变成乱码，或者读出显示时也是乱码，解决方法如下：
在数据库连接字符串中加入编码字符集
String url=”jdbc:mysql://localhost/test?user=root&password=root&useUnicode=true&characterEncoding=UTF-8"
把characterEncoding的值设置成你期望的编码。
无论你是用哪种方式连接数据库，只要在url后面加上useUnicode=true&characterEncoding=UTF-8"就可以解决中文乱码问题，当然你提交的数据编码也必须是UTF-8的，总而言之，在构造一个网站，整个网站必须采用统一的编码。支持中文的编码有GBK,gb2312,UTF-8等。
例如在struts中利用数据源连接数据库，必须在struts-config.xml做如下配置：
<data-sources>
<!-- 设置数据源标识 -->
<data-source key="mysqlDB1" type="org.apache.tomcat.dbcp.dbcp.BasicDataSource">
<!-- 设置数据库驱动对应类名 -->
<set-property property="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<!-- 设置待连接数据源URL -->
<set-property property="url" value="jdbc:mysql://localhost/firststruts?useUnicode=true&charact erEncoding=UTF-8"/>
<!-- 设置同时打开连接的最大数目 -->
<set-property property="maxActive" value="5"/>
<!-- 设置登录数据库服务器用户名及密码 -->
<set-property property="username" value="root"/>
<set-property property="password" value=""/>
<!-- 设置事务处理中的自动提交 -->
<set-property property="autoCommit" value
]]> <![CDATA[乱码问题（四）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24066 krf301 2007/4/16 20:42:25 标题     java中文内部乱码处理    关键字     java， 中文内部

在jsp中，中文乱码常会让人心乱如麻。一般的解决方案
一、本页显示问题
"<%@ page contentType="text/html;charset=GB2312"%>"
二、提交问题
鉴于此问题，你可以将读出来的字符串进行转换，这很简单：
str = request.getParameter("s");
str = new String(str.getBytes("ISO-8859-1"),"GBK");
或者设置
request.setCharacterEncoding("GBK");　

然而，你遇到这种情况吗，使用out.println是中文，Systemout.println是乱码，看下面的例子

jsp1.jsp建立

<%@ page contentType="text/html;charset=GB2312"%>
<html>
<head>
<title>
mm
</title>
</head>
<body background="">
<form method="POST" action="servlet1">
<input type="text" name="myt" size="30" value ="&nbsp;">
<br>
<input type="text" name="myedit" size="30" value ="">
<input type="submit" value="保  存" name="B5" >
</form>
</body>
</html>

-----

servlet1 建立

package untitled2;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

public class Servlet1 extends HttpServlet {

    public void doPost(HttpServletRequest request,
                       HttpServletResponse response) throws ServletException, IOException
    {
        response.setContentType("text/html;charset=GBK") ;
        request.setCharacterEncoding("GBK");
        PrintWriter out = response.getWriter() ;

       out.println(request.getParameter("myedit"));
       System.out.println(request.getParameter("myedit"));
 
    }

}

编译后在ie运行，myedit中输入汉字，就会出现我说乱码，可别小看，对你有用System.out.println的输出，本人经过反复的调试，发现将

<input type="text" name="myt" size="30" value ="&nbsp;">中"&nbsp;"修改为""，就没有问题了。"&nbsp;"我们经常用就是空，到底是什么问题导致，我还不清楚。

我用的jbuild7.0,jdevelop9.03都有此问题。

]]> <![CDATA[乱码问题（三）]]> http://blogger.org.cn/blog/more.asp?name=krf301&id=24065 krf301 2007/4/16 20:39:11 java中文乱码解决方案和经验
　
1.字节和unicode
java内核是unicode的，就连class文件也是，但是很多媒体，包括文件/流的保存方式是使用字节流的。因此java要对这些字节流经行转化。char是unicode的，而byte是字节。java中byte/char互转的函数在sun.io的包中间有。其中ByteToCharConverter类是中调度，可以用来告诉你，你用的convertor。其中两个很常用的静态函数是
public static ByteToCharConverter getDefault();
public static ByteToCharConverter getConverter(String encoding);
如果你不指定converter，则系统会自动使用当前的encoding,gb平台上用gbk,en平台上用8859_1。
byte ——〉char：
"你"的gb码是：0xc4e3 ,unicode是0x4f60
String encoding = "gb2312";
byte b[] = {(byte)'\u00c4',(byte)'\u00e3'};
ByteToCharConverter converter = ByteToCharConverter.getConverter(encoding);
char c[] = converter.convertAll(b);
for (int i = 0; i < c.length; i++) {
System.out.println(Integer.toHexString(c[i]));
}
结果是什么？0x4f60
如果encoding ="8859_1"，结果又是什么？0x00c4,0x00e3
如果代码改为
byte b[] = {(byte)'\u00c4',(byte)'\u00e3'};
ByteToCharConverter converter = ByteToCharConverter. getDefault();
char c[] = converter.convertAll(b);
for (int i = 0; i < c.length; i++) {
System.out.println(Integer.toHexString(c[i]));
}
结果将又是什么？根据平台的编码而定。

char ——〉byte：
String encoding = "gb2312";
char c[] = {'\u4f60'};
CharToByteConverter converter = CharToByteConverter.getConverter(encoding);
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}
结果是什么？0x00c4,0x00e3
如果encoding ="8859_1"，结果又是什么？0x3f
如果代码改为
String encoding = "gb2312";
char c[] = {'\u4f60'};
CharToByteConverter converter = CharToByteConverter.getDefault();
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}
结果将又是什么？根据平台的编码而定。
很多中文问题就是从这两个最简单的类派生出来的。而却有很多类不直接支持把encoding输入，这给我们带来诸多不便。很多程序难得用encoding了，直接用default的encoding，这就给我们移植带来了很多困难。

2.utf-8
utf-8是和unicode一一对应的，其实现很简单
7位的unicode: 0 _ _ _ _ _ _ _
11位的unicode: 1 1 0 _ _ _ _ _ 1 0 _ _ _ _ _ _
16位的unicode: 1 1 1 0 _ _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _
21位的unicode: 1 1 1 1 0 _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _
大多数情况是只使用到16位以下的unicode:
"你"的gb码是：0xc4e3 ,unicode是0x4f60
0xc4e3的二进制：
1100 ，0100 ，1110 ，0011
由于只有两位我们按照两位的编码来排，但是我们发现这行不通，因为第７位不是0因此，返回"?"
0x4f60的二进制：
0100 ，1111 ，0110 ，0000
我们用utf-8补齐，变成：
1110 ，0100 ，1011 ，1101 ，1010 ，0000
e4--bd-- a0
于是返回：0xe4,0xbd,0xa0。

3.string和byte[]
string其实核心是char[],然而要把byte转化成string，必须经过编码。string.length()其实就是char数组的长度，如果使用不同的编码，很可能会错分，造成散字和乱码。
例如：
String encoding = “”;
byte [] b={(byte)'\u00c4',(byte)'\u00e3'};
String str=new String(b,encoding);　　
如果encoding=8859_1，会有两个字，但是encoding=gb2312只有一个字这个问题在处理分页是经常发生 。

4.Reader,Writer / InputStream,OutputStream
Reader和Writer核心是char，InputStream和OutputStream核心是byte。但是Reader和Writer的主要目的是要把char读/写InputStream/OutputStream。
例如：
文件test.txt只有一个"你"字，0xc4,0xe3
String encoding = "gb2312";
InputStreamReader reader = new InputStreamReader(new FileInputStream(
"text.txt"), encoding);
char c[] = new char[10];
int length = reader.read(c);
for (int i = 0; i < length; i++) {
System.out.println(c[i]);
}
结果是什么？你
如果encoding ="8859_1"，结果是什么？??两个字符，表示不认识。
反过来的例子自己做。

5.我们要对java的编译器有所了解 ：
javac ?encoding
我们常常没有用到encoding这个参数。其实encoding这个参数对于跨平台的操作是很重要的。如果没有指定encoding，则按照系统的默认encoding,gb平台上是gb2312，英文平台上是iso8859_1。
java的编译器实际上是调用sun.tools.javac.main的类，对文件进行编译，这个类有compile函数中间有一个encoding的变量,-encoding的参数其实直接传给encoding变量。编译器就是根据这个变量来读取java文件的，然后把用utf-8形式编译成class文件。
例子代码：
String str = "你";
FileWriter writer = new FileWriter("text.txt");
write.write(str);
writer.close();

如果用gb2312编译，你会找到e4 bd a0的字段 ；
如果用8859_1编译， 00c4 00e3的二进制：
0000，0000 ，1100，0100 ，0000，0000 ，1110，0011
因为每个字符都大于7位，因此用11位编码：
1100，0001，1000，0100，1100，0011，1010，0011
c1-- 84--　c3--　 a3
你会找到c1 84 c3 a3 。

但是我们往往忽略掉这个参数，因此这样往往会有跨平台的问题：
样例代码在中文平台上编译，生成zhclass
样例代码在英文平台上编译，输出enclass
(1).　 zhclass在中文平台上执行ok,但是在英文平台上不行
(2). enclass在英文平台上执行ok,但是在中文平台上不行
原因：
(1). 在中文平台上编译后，其实str在运行态的char[]是0x4f60,　在中文平台上运行，filewriter的缺省编码是gb2312,因此 chartobyteconverter会自动用调用gb2312的converter,把str转化成byte输入到fileoutputstream中，于是0xc4,0xe3放进了文件。
但是如果是在英文平台下，chartobyteconverter的缺省值是8859_1, filewriter会自动调用8859_1去转化str,但是他无法解释，因此他会输出"?"
(2). 在英文平台上编译后，其实str在运行态的char[]是0x00c4 0x00e3, 在中文平台上运行，中文无法识别，因此会出现??；
在英文平台上，0x00c4-->0xc4,0x00e3->0xe3，因此0xc4,0xe3被放进了文件。

6. 其它原因： <%@ page contentType="text/html; charset=GBK" %>
设置浏览器的显示编码，如果response的数据是utf8编码，显示将是乱码，但是乱码和上述原因还不一样。

7. 发生编码的地方 ：
 从数据库到java程序 byte——〉char
 从java程序到数据库 char——〉byte
 从文件到java程序 byte——〉char
 从java程序到文件 char——〉byte
 从java程序到页面显示 char——〉byte
 从页面form提交数据到java程序byte——〉char
 从流到java程序byte——〉char
 从java程序到流char——〉byte

谢志钢的解决方法：
我是使用配置过滤器的方法解决中文乱码的：

＜web-app>
＜filter>
＜filter-name>RequestFilter</filter-name>
＜filter-class>net.golden.uirs.util.RequestFilter</filter-class>
＜init-param>
＜param-name>charset</param-name>
＜param-value>gb2312</param-value>
＜/init-param>
＜/filter>
＜filter-mapping>
＜filter-name>RequestFilter</filter-name>
＜url-pattern>*.jsp</url-pattern>
＜/filter-mapping>
＜/web-app>


public void doFilter(ServletRequest req, ServletResponse res,
FilterChain fChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
HttpSession session = request.getSession();
String userId = (String) session.getAttribute("userid");
req.setCharacterEncoding(this.filterConfig.getInitParameter("charset")); // 设置字符集？
实际上是设置了byte ——〉char的encoding
try {
if (userId == null || userId.equals("")) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}\\x2Ejsp$")) {
session.invalidate();
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
}
else { // 看看是否具有信息上报系统的权限
if (!net.golden.uirs.util.UirsChecker.check(userId, "信息上报系统",
net.golden.uirs.util.UirsChecker.ACTION_DO)) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}\\x2Ejsp$")) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logonController.jsp");
}
}
}
}
catch (Exception ex) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
fChain.doFilter(req, res);
}
]]>