所以，在程序中，可以用类似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 能够严格地测试它的产品，为用户带来更多的方便。