所以，在程序中，可以用類似Table Query的方式來讀取XML節點(Node)上面的屬性值！

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE managers SYSTEM "manager-config.dtd">
<managers>
  <manager name="DBConnectionManager" >
    <service>net.csdn.blog.xport.IDBConnectionManager</service>
    <implementation>net.csdn.blog.xport.impl.DBConnectionManagerCommonImpl</implementation>
  </manager>
  <manager name="NTAccountIdendify" >
        <service>net.csdn.blog.xport.IDomainIdentify</service>
        <implementation>net.csdn.blog.xport.impl.DomainIdentifyImpl</implementation>
  </manager>
</managers>

按照下面的代碼讀取：

// 查找以manager作為tag標記，屬性中存在name且屬性值為"DBConnectionManager"的
// XML節點, 并返回此節點的DOM Element對象！
// 類似name字段為PK值，且name="DBConnectionManager"
managerElement
        = XMLFileUtil.findElement(xmlDomContent.getRootElement(),
                                  "manager",
                                  "name",
                                  "DBConnectionManager");
if (managerElement != null) {
  //取得Element中的implementation屬性對象...
  serviceImplElement = managerElement.element("implementation");
  if (serviceImplElement != null) {
    //取這個屬性的值...
    serviceImplClassString = serviceImplElement.getText();
  }
}

Source of XML Utility Class：

/*

 * @(#)XMLFileUtil.java    1.0 2004/12/20
 *
 * Copyright 2004 Shark Wang, All rights reserved.
 
 */
 
package net.csdn.blog.xport;

import java.net.URL;
import java.util.Iterator;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * The <code>XmlUtil</code> class supported your code to read/write xml
 * data from the file. all methods in this class depend on <code>dom4j</code>.
 *
 * @author  Shark Wang
 * @version 1.0, 2004/12/20
 * @since   Tutorial 1.0
 */
public class XMLFileUtil {

  private static Logger logger = LogManager.getLogger(XMLFileUtil.class);

  /**
   * read xml content from some file, and load xml data into the
   * Document object.
   *
   * @param filePath String
   * @return Document
   */
  public static Document LoadXmlFile(String filePath) {

    /* marked by Shark Wang
     *****************************************************************
       //get resolver to ignore the DTD validation
       EntityResolver resolver = new EntityResolver() {
           public InputSource resolveEntity(String publicId,
                                            String systemId) {
               return new InputSource(new StringBufferInputStream(""));
           }
       };
       //create reader
       SAXReader reader = new SAXReader();
       //set reader attribute to ignore DTD validation
       reader.setEntityResolver(resolver);
       reader.setValidation(false);
       reader.setIncludeExternalDTDDeclarations(false);
       reader.setIncludeInternalDTDDeclarations(false);
     *******************************************************************
     */
    SAXReader reader = new SAXReader();
    //try to load xml data into Document object
    Document doc = null;
    try {
      String urlString = null;
      if (filePath.startsWith("/")) {
        urlString = "file://" + filePath;
      }
      else {
        urlString = "file:///" + filePath;
      }
      logger.debug("XML File's URL :" + urlString);
      doc = reader.read(new URL(urlString));
    }
    catch (Exception ex) {
      logger.info("Can not load " + filePath);
      logger.debug(ex.getMessage(), ex);
    }
    //return Document object
    return doc;
  }

  /**
   * Get attribute value by name for some xml element.
   *
   * @param element Element
   * @param attributeName String
   * @return String
   */
  public static String getAttributeValue(Element element,
                                         String attributeName) {
    String attributeValue = null;
    for (Iterator i = element.attributeIterator(); i.hasNext(); ) {
      Attribute attribute = (Attribute) i.next();
      if (attribute.getName().equals(attributeName)) {
        attributeValue = (String) attribute.getData();
        break;
      }
    }
    return attributeValue;
  }

  public static Element findElement(Element searchedElement,
                                    String targetNodePrefix,
                                    String targetNodeAttributeName,
                                    String targetNodeAttributeValue) {
    Element elementTarget = null;
    for (Iterator i = searchedElement.elementIterator(targetNodePrefix);
         i.hasNext(); ) {
      Element element = (Element) i.next();
      String strManagerName =
          XMLFileUtil.getAttributeValue(element,
                                        targetNodeAttributeName);
      if (strManagerName.equals(targetNodeAttributeValue)) {
        elementTarget = element;
        break;
      }
    }
    return elementTarget;
  }

  private XMLFileUtil() {
  }
}

我們可以看到，這樣會長期占用數據庫連接的資源，是一個有點不爽的問題...

其實，在JSTL中提供了另外一種機制，讓我們在返回查詢結果到表示層的時候，可以做到離線使用！它就是javax.servlet.jsp.jstl.sql.Result類！

 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 <%@page contentType="text/html; charset=UTF-8"%>
 <%@page import="java.sql.Connection"%>
 <%@page import="java.sql.DriverManager"%>
 <%@page import="java.sql.ResultSet"%>
 <%@page import="java.sql.SQLException"%>
 <%@page import="java.sql.Statement"%>
 <%@page import="javax.servlet.jsp.jstl.sql.Result"%>
 <%@page import="javax.servlet.jsp.jstl.sql.ResultSupport"%>
 <%
   // 暫且把這個下面的內容看作多層架構中的DAO好了，我偷懶了! 
   Connection conn = null;
   Statement stmt = null;
   ResultSet rs = null;
   String strDbUrl
       = "jdbc:mysql://localhost/tutorial?user=tutorial&password=tutpwd";
   try {
     //開始與數據庫作查詢
     Class.forName("com.mysql.jdbc.Driver").newInstance();
     conn = DriverManager.getConnection(strDbUrl);
     stmt = conn.createStatement();
     String strSql = "SELECT * FROM R_TUT_USERS";
     rs = stmt.executeQuery(strSql);
     //把ResultSet轉化成Result
     Result userData = ResultSupport.toResult(rs);
     //當我們把結果放到某個Model bean后，就可以關閉數據庫連接了.
     //為了簡化，我們暫且把pageContext看作Model Bean好了！
     pageContext.setAttribute("userData", userData);
   }
   catch (Exception ex) {
     // handle any errors
     System.out.println("SQLException: " + ex.getMessage());
   }
   finally {
     try {
       if (rs != null) {
         rs.close();
       }
       if (stmt != null) {
         stmt.close();
       }
       if (conn != null) {
         conn.close();
       }
     }
     catch (SQLException ex) {
       System.out.println("SQL Exception: " + ex.getMessage());
     }
   }
   //DAO的邏輯結束
 %>
 <html>
 <head>
 <title>test</title>
 </head>
 <body>
 <!--// 下面當作是表示層吧 //-->
 <c:forEach items="${userData.rows}" var="user">
   <c:out value='${user.name}'/>
 </c:forEach>
 </body>
 </html>

public class OneTimePadUtil {
    public static byte[] xor(byte[] bytes, byte[] keyBytes) {
        if (keyBytes.length != bytes.length) {
            throw new IllegalArgumentException();
        }

        byte[] resultBytes = new byte[bytes.length];

        for (int i = 0; i < resultBytes.length; ++i) {
            resultBytes[i] = (byte) (keyBytes[i] ^ bytes[i]);
        }

        return resultBytes;
    }
}

String plainText = "溫少";
String keyText = "密碼";

byte[] plainBytes = plainText.getBytes();
byte[] keyBytes = keyText.getBytes();

assert plainBytes.length == keyBytes.length;

//加密
byte[] cipherBytes = OneTimePadUtil.xor(plainBytes, keyBytes);

//解密
byte[] cipherPlainBytes = OneTimePadUtil.xor(cipherBytes, keyBytes);

這是最簡單的加密算法，但也是最安全的機密算法。前天和朋友討論到了這個問題，所以寫了這篇文章。

　　當JSP調用一個必須長時間運行的操作，且該操作的結果不能（在服務器端）緩沖，用戶每次請求該頁面時都必須長時間等待。很多時候，用戶會失去耐心，接著嘗試點擊瀏覽器的刷新按鈕，最終失望地離開。

　　本文介紹的技術是把繁重的計算任務分離開來，由一個獨立的線程運行，從而解決上述問題。當用戶調用JSP頁面時，JSP頁面會立即返回，并提示用戶任務已經啟動且正在執行JSP頁面自動刷新自己，報告在獨立線程中運行的繁重計算任務的當前進度，直至任務完成。

一、模擬任務

　　首先我們設計一個TaskBean類，它實現java.lang.Runnable接口，其run()方法在一個由JSP頁面（start.jsp）啟動的獨立線程中運行。終止run()方法執行由另一個JSP頁面stop.jsp負責。TaskBean類還實現了java.io.Serializable接口，這樣JSP頁面就可以將它作為JavaBean調用：
package test.barBean;
import java.io.Serializable;

public class TaskBean implements Runnable, Serializable {
private int counter;
private int sum;
private boolean started;
private boolean running;
private int sleep;

public TaskBean() {
counter = 0;
sum = 0;
started = false;
running = false;
sleep = 100;
}
}

　　TaskBean包含的“繁重任務”是計算1+2+3…+100的值，不過它不通過100*(100+1)/2=5050公式計算，而是由run()方法調用work()方法100次完成計算。work()方法的代碼如下所示，其中調用Thread.sleep()是為了確保任務總耗時約10秒。

protected void work() {
try {
Thread.sleep(sleep);
counter++;
sum += counter;
} catch (InterruptedException e) {
setRunning(false);
}
}

　　status.jsp頁面通過調用下面的getPercent()方法獲得任務的完成狀況：

public synchronized int getPercent() {
return counter;
}

如果任務已經啟動，isStarted()方法將返回true：

public synchronized boolean isStarted() {
return started;
}

　　如果任務已經完成，isCompleted()方法將返回true：

public synchronized boolean isCompleted() {
return counter == 100;
}

　　如果任務正在運行，isRunning()方法將返回true：

public synchronized boolean isRunning() {
return running;
}

　　SetRunning()方法由start.jsp或stop.jsp調用，當running參數是true時。SetRunning()方法還要將任務標記為“已經啟動”。調用setRunning(false)表示要求run()方法停止執行。

public synchronized void setRunning(boolean running) {
this.running = running;
if (running)
started = true;
}

　　任務執行完畢后，調用getResult()方法返回計算結果如果任務尚未執行完畢，它返回null：

public synchronized Object getResult() {
if (isCompleted())
return new Integer(sum);
else
return null;
}

　　當running標記為true、completed標記為false時，run()方法調用work()。在實際應用中，run()方法也許要執行復雜的SQL查詢、解析大型XML文檔，或者調用消耗大量CPU時間的EJB方法。注意“繁重的任務”可能要在遠程服務器上執行。報告結果的JSP頁面有兩種選擇：或者等待任務結束，或者使用一個進度條。

public void run() {
try {
setRunning(true);
while (isRunning() && !isCompleted())
work();
} finally {
setRunning(false);
}
}

二、啟動任務

　　start.jsp是web.xml部署描述符中聲明的歡迎頁面，web.xml的內容是：

<?xml version="1.0" encoding="GB2312"?>

<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<welcome-file-list>
<welcome-file>start.jsp</welcome-file>
</welcome-file-list>
</web-app>

　　start.jsp啟動一個專用的線程來運行“繁重的任務”，然后把HTTP請求傳遞給status.jsp。

　　start.jsp頁面利用<jsp:useBean>標記創建一個TaskBean的實例，將scope屬性定義為session使得對于來自同一瀏覽器的HTTP請求，其他頁面也能提取到同一個Bean對象。start.jsp通過調用session.removeAttribute("task")確保<jsp:useBean>創建了一個新的Bean對象，而不是提取一個舊對象（例如，同一個用戶會話中更早的JSP頁面所創建的Bean對象）。

　　下面是start.jsp頁面的代碼清單：

<% session.removeAttribute("task"); %>

<jsp:useBean id="task" scope="session"
class="test.barBean.TaskBean"/>

<% task.setRunning(true); %>
<% new Thread(task).start(); %>
<jsp:forward page="status.jsp"/>

　　start.jsp創建并設置好TaskBean對象之后，接著創建一個Thread，并將Bean對象作為一個Runnable實例傳入。調用start()方法時新創建的線程將執行TaskBean對象的run()方法。

　　現在有兩個線程在并發執行：執行JSP頁面的線程（稱之為“JSP線程”），由JSP頁面創建的線程（稱之為“任務線程”）。接下來，start.jsp利用調用status.jsp，status.jsp顯示出進度條以及任務的執行情況。注意status.jsp和start.jsp在同一個JSP線程中運行。

　　start.jsp在創建線程之前就把TaskBean的running標記設置成了true，這樣，即使當JSP線程已開始執行status.jsp而任務線程的run()方法尚未啟動，也能夠確保用戶會得到“任務已開始運行”的狀態報告。

　　將running標記設置成true、啟動任務線程這兩行代碼可以移入TaskBean構成一個新的方法，然后由JSP頁面調用這個新方法。一般而言，JSP頁面應當盡量少用Java代碼，即我們應當盡可能地把Java代碼放入Java類。不過本例中我們不遵從這一規則，把new Thread(task).start()直接放入start.jsp突出表明JSP線程創建并啟動了任務線程。

　　在JSP頁面中操作多線程必須謹慎，注意JSP線程和其他線程實際上是并發執行的，就象在桌面應用程序中，我們用一個線程來處理GUI事件，另外再用一個或多個線程來處理后臺任務。不過在JSP環境中，考慮到多個用戶同時請求某一個頁面的情況，同一個JSP頁面可能會在多個線程中同時運行另外，有時同一個用戶可能會向同一個頁面發出多個請求，雖然這些請求來自同一個用戶，它們也會導致服務器同時運行一個JSP頁面的多個線程。

三、任務進度

　　status.jsp頁面利用一個HTML進度條向用戶顯示任務的執行情況。首先，status.jsp利用<jsp:useBean>標記獲得start.jsp頁面創建的Bean對象：

<jsp:useBean id="task" scope="session"
class="test.barBean.TaskBean"/>

　　為了及時反映任務執行進度，status.jsp會自動刷新。JavaScript代碼setTimeout("location='status.jsp'", 1000)將每隔1000毫秒刷新頁面，重新請求status.jsp，不需要用戶干預。

<HTML>

<HEAD>
<TITLE>JSP進度條</TITLE>
<% if (task.isRunning()) { %>
<SCRIPT LANGUAGE="JavaScript">
setTimeout("location='status.jsp'", 1000);
</SCRIPT>
<% } %>
</HEAD>

<ODY>

　　進度條實際上是一個HTML表格，包含10個單元——即每個單元代表任務總體的10%進度。

<H1 ALIGN="CENTER">JSP進度條</H1>

<H2 ALIGN="CENTER">
結果: <%= task.getResult() %><BR>
<% int percent = task.getPercent(); %>
<%= percent %>%
</H2>

<TABLE WIDTH="60%" ALIGN="CENTER"
BORDER=1 CELLPADDING=0 CELLSPACING=2>
<TR>
<% for (int i = 10; i <= percent; i += 10) { %>
<TD WIDTH="10%" BGCOLOR="#000080">&nbsp;</TD>
<% } %>
<% for (int i = 100; i > percent; i -= 10) { %>
<TD WIDTH="10%">&nbsp;</TD>
<% } %>
</TR>
</TABLE>

　　任務執行情況分下面幾種狀態：正在執行，已完成，尚未開始，已停止：

<TABLE WIDTH="100%" BORDER=0 CELLPADDING=0 CELLSPACING=0>
<TR>
<TD ALIGN="CENTER">
<% if (task.isRunning()) { %>
正在執行
<% } else { %>
<% if (task.isCompleted()) { %>
完成
<% } else if (!task.isStarted()) { %>
尚未開始
<% } else { %>
已停止
<% } %>
<% } %>
</TD>
</TR>

頁面底部提供了一個按鈕，用戶可以用它來停止或重新啟動任務：

<TR>
<TD ALIGN="CENTER">
<BR>
<% if (task.isRunning()) { %>
<FORM METHOD="GET" ACTION="stop.jsp">
<INPUT TYPE="SUBMIT" VALUE="停止">
</FORM>
<% } else { %>
<FORM METHOD="GET" ACTION="start.jsp">
<INPUT TYPE="SUBMIT" VALUE="開始">
</FORM>
<% } %>
</TD>
</TR>
</TABLE>
</BODY></HTML>

　　只要不停止任務，約10秒后瀏覽器將顯示出計算結果5050：

　　四、停止任務

　　stop.jsp頁面把running標記設置成false，從而停止當前的計算任務：

<jsp:useBean id="task" scope="session"
class="test.barBean.TaskBean"/>

<% task.setRunning(false); %>
<jsp:forward page="status.jsp"/>

　　注意最早的Java版本提供了Thread.stop方法，但JDK從1.2版開始已經不贊成使用Thread.stop方法，所以我們不能直接調用Thread.stop()。

　　第一次運行本文程序的時候，你會看到任務的啟動有點延遲同樣地，第一次點擊“停止”按鈕時也可以看到任務并沒有立即停止運行（特別是如果機器配置較低的話，延遲的感覺更加明顯），這些延遲都是由于編譯JSP頁面導致的。編譯好JSP頁面之后，應答速度就要快多了。

　　五、實際應用

　　進度條不僅使得用戶界面更加友好，而且對服務器的性能也有好處，因為進度條會不斷地告訴用戶當前的執行進度，用戶不會再頻繁地停止并重新啟動（刷新）當前的任務。另一方面，創建單獨的線程來執行后臺任務也會消耗不少資源，必要時可考慮通過一個線程池來實現Thread對象的重用。另外，頻繁地刷新進度頁面也增加了網絡通信開銷，所以務必保持進度頁面簡潔短小。

　　在實際應用中，后臺執行的繁重任務可能不允許停止，或者它不能提供詳細的執行進度數據。例如，查找或更新關系數據庫時，SQL命令執行期間不允許中途停止——不過如果用戶表示他想要停止或中止任務，程序可以在SQL命令執行完畢后回退事務。

　　解析XML文檔的時候，我們沒有辦法獲知已解析內容精確的百分比。如果用DOM解析XML文檔，直到解析完成后才得到整個文檔樹如果用SAX，雖然可以知道當前解析的內容，但通常不能確定還有多少內容需要解析。在這些場合，任務的執行進度只能靠估計得到。

　　估計一個任務需要多少執行時間通常是很困難的，因為它涉及到許多因素，即使用實際測試的辦法也無法得到可靠的結論，因為服務器的負載隨時都在變化之中。一種簡單的辦法是測量任務每次執行所需時間，然后根據最后幾次執行的平均時間估算。如果要提高估計時間的精確度，應當考慮實現一種針對應用特點的算法，綜合考慮多種因素，例如要執行的SQL語句類型、要解析的XML模式的復雜程度，等等。

　　結束語：本文例子顯示出用JSP、Java、HTML和JavaScript構造進度條是相當容易的，真正困難的是如何將它用到實際應用之中，特別是獲得后臺任務的進度信息，但這個問題沒有通用的答案，每一種后臺執行的任務都有它自己的特點，必須按照具體情況具體分析。

段明輝
自由撰稿人
2000 年 11月 8日

在基于 Java 語言的編程中，我們經常碰到漢字的處理及顯示的問題。一大堆看不懂的亂碼肯定不是我們愿意看到的顯示效果，怎樣才能夠讓那些漢字正確顯示呢？Java 語言默認的編碼方式是UNICODE ，而我們中國人通常使用的文件和數據庫都是基于 GB2312 或者 BIG5 等方式編碼的，怎樣才能夠恰當地選擇漢字編碼方式并正確地處理漢字的編碼呢？本文將從漢字編碼的常識入手，結合 Java 編程實例，分析以上兩個問題并提出解決它們的方案。

現在 Java 編程語言已經廣泛應用于互聯網世界，早在 Sun 公司開發 Java 語言的時候，就已經考慮到對非英文字符的支持了。Sun 公司公布的 Java 運行環境（JRE）本身就分英文版和國際版，但只有國際版才支持非英文字符。不過在 Java 編程語言的應用中，對中文字符的支持并非如同 Java Soft 的標準規范中所宣稱的那樣完美，因為中文字符集不只一個，而且不同的操作系統對中文字符的支持也不盡相同，所以會有許多和漢字編碼處理有關的問題在我們進行應用開發中困擾著我們。有很多關于這些問題的解答，但都比較瑣碎，并不能夠滿足大家迫切解決問題的愿望，關于 Java 中文問題的系統研究并不多，本文從漢字編碼常識出發，分析 Java 中文問題，希望對大家解決這個問題有所幫助。

漢字編碼的常識

我們知道，英文字符一般是以一個字節來表示的，最常用的編碼方法是 ASCII 。但一個字節最多只能區分256個字符，而漢字成千上萬，所以現在都以雙字節來表示漢字，為了能夠與英文字符分開，每個字節的最高位一定為1，這樣雙字節最多可以表示64K格字符。我們經常碰到的編碼方式有 GB2312、BIG5、UNICODE 等。關于具體編碼方式的詳細資料，有興趣的讀者可以查閱相關資料。我膚淺談一下和我們關系密切的 GB2312 和 UNICODE。GB2312 碼，中華人民共和國國家標準漢字信息交換用編碼，是一個由中華人民共和國國家標準總局發布的關于簡化漢字的編碼，通行于中國大陸地區及新加坡，簡稱國標碼。兩個字節中，第一個字節（高字節）的值為區號值加32（20H），第二個字節（低字節）的值為位號值加32（20H），用這兩個值來表示一個漢字的編碼。UNICODE 碼是微軟提出的解決多國字符問題的多字節等長編碼，它對英文字符采取前面加“0”字節的策略實現等長兼容。如 “A” 的 ASCII 碼為0x41，UNICODE 就為0x00，0x41。利用特殊的工具各種編碼之間可以互相轉換。

Java 中文問題的初步認識

我們基于 Java 編程語言進行應用開發時，不可避免地要處理中文。Java 編程語言默認的編碼方式是 UNICODE，而我們通常使用的數據庫及文件都是基于 GB2312 編碼的，我們經常碰到這樣的情況：瀏覽基于 JSP 技術的網站看到的是亂碼，文件打開后看到的也是亂碼，被 Java 修改過的數據庫的內容在別的場合應用時無法繼續正確地提供信息。

String sEnglish = “apple”;

String sChinese = “蘋果”;

String s = “蘋果 apple ”;

sEnglish 的長度是5，sChinese的長度是4，而 s 默認的長度是14。對于 sEnglish來說， Java 中的各個類都支持得非常好，肯定能夠正確顯示。但對于 sChinese 和 s 來說，雖然 Java Soft 聲明 Java 的基本類已經考慮到對多國字符的支持（默認 UNICODE 編碼），但是如果操作系統的默認編碼不是 UNICODE ，而是國標碼等。從 Java 源代碼到得到正確的結果，要經過 “Java 源代碼-> Java 字節碼-> ;虛擬機->操作系統->顯示設備”的過程。在上述過程中的每一步驟，我們都必須正確地處理漢字的編碼，才能夠使最終的顯示結果正確。

“ Java 源代碼-> Java 字節碼”，標準的 Java 編譯器 javac 使用的字符集是系統默認的字符集，比如在中文 Windows 操作系統上就是 GBK ,而在 Linux 操作系統上就是ISO-8859-1，所以大家會發現在 Linux 操作系統上編譯的類中源文件中的中文字符都出了問題，解決的辦法就是在編譯的時候添加 encoding 參數，這樣才能夠與平臺無關。用法是

javac –encoding GBK。

“ Java 字節碼->虛擬機->操作系統”， Java 運行環境 （JRE） 分英文版和國際版，但只有國際版才支持非英文字符。 Java 開發工具包 （JDK） 肯定支持多國字符，但并非所有的計算機用戶都安裝了 JDK 。很多操作系統及應用軟件為了能夠更好的支持 Java ，都內嵌了 JRE 的國際版本，為自己支持多國字符提供了方便。

“操作系統->顯示設備”，對于漢字來說，操作系統必須支持并能夠顯示它。英文操作系統如果不搭配特殊的應用軟件的話，是肯定不能夠顯示中文的。

還有一個問題，就是在 Java 編程過程中，對中文字符進行正確的編碼轉換。例如，向網頁輸出中文字符串的時候，不論你是用

out.println(string);還是用

<%=string%>，都必須作 UNICODE 到 GBK 的轉換，或者手動，或者自動。在 JSP 1.0中，可以定義輸出字符集，從而實現內碼的自動轉換。用法是

<%@page contentType=”text/html;charset=gb2312” %>

但是在一些 JSP 版本中并沒有提供對輸出字符集的支持，（例如 JSP 0.92），這就需要手動編碼輸出了，方法非常多。最常用的方法是

String s1 = request.getParameter(“keyword”);

String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”);

getBytes 方法用于將中文字符以“ISO-8859-1”編碼方式轉化成字節數組，而“GBK” 是目標編碼方式。我們從以ISO-8859-1方式編碼的數據庫中讀出中文字符串 s1 ，經過上述轉換過程，在支持 GBK 字符集的操作系統和應用軟件中就能夠正確顯示中文字符串 s2 。

Java 中文問題的表層分析及處理

.CLASS 文件存放在服務器端，由客戶端的瀏覽器運行 APPLET ， APPLET 只起調入 FRAME 類等主程序的作用。界面包括 Textfield ，TextArea，List，Choice 等。

I.用 JDBC 執行 SELECT 語句從服務器端讀取數據（中文）后，將數據用 APPEND 方法加到 TextArea（TA） ，不能正確顯示。但加到 List 中時，大部分漢字卻可正確顯示。

將數據按“ISO-8859-1” 編碼方式轉化為字節數組，再按系統缺省編碼方式 （Default Character Encoding） 轉化為 STRING ，即可在 TA 和 List 中正確顯示。

程序段如下：

dbstr2 = results.getString(1);

//After reading the result from DB server，converting it to string.

dbbyte1 = dbstr2.getBytes(“iso-8859-1”);

dbstr1 = new String(dbbyte1);

在轉換字符串時不采用系統默認編碼方式，而直接采用“ GBK” 或者 “GB2312” ,在 A 和 B 兩種情況下，從數據庫取數據都沒有問題。

II.處理方式與“取中文”相逆，先將 SQL 語句按系統缺省編碼方式轉化為字節數組，再按“ISO-8859-1”編碼方式轉化為 STRING ，最后送去執行，則中文信息可正確寫入數據庫。

程序段如下：

sqlstmt = tf_input.getText();

//Before sending statement to DB server，converting it to sql statement.

dbbyte1 = sqlstmt.getBytes();

sqlstmt = newString(dbbyte1,”iso-8859-1”);

_stmt = _con.createStatement();

_stmt.executeUpdate(sqlstmt);

……

問題：如果客戶機上存在 CLASSPATH 指向 JDK 的 CLASSES.ZIP 時（稱為 A 情況），上述程序代碼可正確執行。但是如果客戶機只有瀏覽器，而沒有 JDK 和 CLASSPATH 時（稱為 B 情況），則漢字無法正確轉換。

我們的分析：

1.經過測試，在 A 情況下，程序運行時系統的缺省編碼方式為 GBK 或者 GB2312 。在 B 情況下，程序啟動時瀏覽器的 JAVA 控制臺中出現如下錯誤信息：

Can't find resource for sun.awt.windows.awtLocalization_zh_CN

然后系統的缺省編碼方式為“8859-1”。

2.如果在轉換字符串時不采用系統缺省編碼方式，而是直接采用 “GBK” 或“GB2312”，則在 A 情況下程序仍然可正常運行，在 B 情況下，系統出現錯誤：

UnsupportedEncodingException。

3.在客戶機上，把 JDK 的 CLASSES.ZIP 解壓后，放在另一個目錄中， CLASSPATH 只包含該目錄。然后一邊逐步刪除該目錄中的 .CLASS 文件，另一邊運行測試程序，最后發現在一千多個 CLASS 文件中，只有一個是必不可少的，該文件是：

sun.io.CharToByteDoubleByte.class。

將該文件拷到服務器端和其它的類放在一起，并在程序的開頭 IMPORT 它，在 B 情況下程序仍然無法正常運行。

4.在 A 情況下，如果在 CLASSPTH 中去掉 sun.io.CharToByteDoubleByte.class ，則程序運行時測得默認編碼方式為“8859-1”，否則為 “GBK” 或 “GB2312” 。

如果 JDK 的版本為1.2以上的話，在 B 情況下遇到的問題得到了很好的解決，測試的步驟同上，有興趣的讀者可以嘗試一下。

Java 中文問題的根源分析及解決

在簡體中文 MS Windows 98 + JDK 1.3 下，可以用 System.getProperties() 得到 Java 運行環境的一些基本屬性，類 PoorChinese 可以幫助我們得到這些屬性。

類 PoorChinese 的源代碼：

public class PoorChinese {

}

執行 java PoorChinese 后，我們會得到:

系統變量 file.encoding 的值為 GBK ，user.language 的值為 zh ， user.region 的值為 CN ，這些系統變量的值決定了系統默認的編碼方式是 GBK 。

在上述系統中，下面的代碼將 GB2312 文件轉換成 Big5 文件，它們能夠幫助我們理解 Java 中漢字編碼的轉化:

?

import java.io.*;

import java.util.*;

?

public class gb2big5 {

?

static int iCharNum=0;

?

public static void main(String[] args) {

System.out.println("Input GB2312 file, output Big5 file.");

if (args.length!=2) {

System.err.println("Usage: jview gb2big5 gbfile big5file");

System.exit(1);

String inputString = readInput(args[0]);

writeOutput(inputString,args[1]);

System.out.println("Number of Characters in file: "+iCharNum+".");

}

?

static void writeOutput(String str, String strOutFile) {

try {

FileOutputStream fos = new FileOutputStream(strOutFile);

Writer out = new OutputStreamWriter(fos, "Big5");

out.write(str);

out.close();

}

catch (IOException e) {

e.printStackTrace();

e.printStackTrace();

}

}

?

static String readInput(String strInFile) {

StringBuffer buffer = new StringBuffer();

try {

FileInputStream fis = new FileInputStream(strInFile);

InputStreamReader isr = new InputStreamReader(fis, "GB2312");

Reader in = new BufferedReader(isr);

int ch;

while ((ch = in.read()) > -1) {

iCharNum += 1;

buffer.append((char)ch);

}

in.close();

return buffer.toString();

}

catch (IOException e) {

e.printStackTrace();

return null;

}

}

}

?

編碼轉化的過程如下：

GB2312------------------>Unicode------------->Big5

執行 java gb2big5 gb.txt big5.txt ，如果 gb.txt 的內容是“今天星期三”，則得到的文件 big5.txt 中的字符能夠正確顯示；而如果 gb.txt 的內容是“情人節快樂”，則得到的文件 big5.txt 中對應于“節”和“樂”的字符都是符號“？”（0x3F），可見 sun.io.ByteToCharGB2312 和 sun.io.CharToByteBig5 這兩個基本類并沒有編好。

正如上例一樣， Java 的基本類也可能存在問題。由于國際化的工作并不是在國內完成的，所以在這些基本類發布之前，沒有經過嚴格的測試，所以對中文字符的支持并不像 Java Soft 所聲稱的那樣完美。前不久，我的一位技術上的朋友發信給我說，他終于找到了 Java Servlet 中文問題的根源。兩周以來，他一直為 Java Servlet 的中文問題所困擾，因為每面對一個含有中文字符的字符串都必須進行強制轉換才能夠得到正確的結果（這好象是大家公認的唯一的解決辦法）。后來，他確實不想如此繼續安分下去了，因為這樣的事情確實不應該是高級程序員所要做的工作，他就找出 Servlet 解碼的源代碼進行分析，因為他懷疑問題就出在解碼這部分。經過四個小時的奮斗，他終于找到了問題的根源所在。原來他的懷疑是正確的， Servlet 的解碼部分完全沒有考慮雙字節，直接把 %XX 當作一個字符。（原來 Java Soft 也會犯這幺低級的錯誤！）

如果你對這個問題有興趣或者遇到了同樣的煩惱的話，你可以按照他的步驟對Servlet.jar 進行修改：

找到源代碼 HttpUtils 中的 static private String parseName ，在返回前將 sb（StringBuffer） 復制成 byte bs[] ，然后 return new String(bs,”GB2312”)。作上述修改后就需要自己解碼了：

HashTable form=HttpUtils .parseQueryString(request.getQueryString())或者

form=HttpUtils.parsePostData(……)

千萬別忘了編譯后放到 Servlet.jar 里面。

五、 關于 Java 中文問題的總結

Java 編程語言成長于網絡世界，這就要求 Java 對多國字符有很好的支持。 Java 編程語言適應了計算的網絡化的需求，為它能夠在網絡世界迅速成長奠定了堅實的基礎。 Java 的締造者 （Java Soft） 已經考慮到 Java 編程語言對多國字符的支持，只是現在的解決方案有很多缺陷在里面，需要我們付諸一些補償性的措施。而世界標準化組織也在努力把人類所有的文字統一在一種編碼之中，其中一種方案是 ISO10646 ，它用四個字節來表示一個字符。當然，在這種方案未被采用之前，還是希望 Java Soft 能夠嚴格地測試它的產品，為用戶帶來更多的方便。