中文问题-下

China-S·J

中文问题-技术篇
JSP中文问题解决方案
只需要保持下面几处地方设置统一，你的JSP就不会有中文问题
1、JSP的charset，
2、你的JSP　SERVER编译JSP是使用的字符集，默认和操作系统是一样的。你可能需要进行修改
3、你的BEAN编译时候所采用的字符集，一般用JAVAC编译，都是和操作系统一样的，但你可以通过带参数来改变。如果用其它的编程工具，可以编译的话，你可能需要修改其默认参数。
4、和数据库连接时，大多数JDBC驱动程序都可以设置其字符集的，这样JDBC驱动会自己进行转换，也不会出现汉字问题。
以jConnect为例，就有这样一个属性参数：
CHARSET
Specifies the character set for strings passed through TDS. If you specify a CHARSET, it must match a CHARSET listed in syscharsets.
If null, jConnect uses the server’s default CHARSET.
明白？jdbc-odbc桥也有这样的参数的(charSet)。 不同的驱动，请参阅文档。
对于中文处理的常见对策，在网上经常可见的主要是下面2种：

或者：
String Hi="你好";
byte[] tmpbyte=Hi.getBytes("ISO8859_1");
Hi=new String(tmpbyte);
out.print(Hi);
% >
通过简单总结，示例中的中文处理发生于以下几个地方：
1 在url附带中文参数，可以直接读取。
例如：

2 与数据库有关的各种sql操作
这里使用的Access没有发生问题。
3 读取HTML form表单中递交的中文值
在jswdk中需要加以编码，较为简洁的写法如：
String name1=new String(request.getParameter("user_id").getBytes("ISO8859_1"));
另外，在jdk1.3的支持下，不需要加入

而在jdk1.2.2下面，即使2种方法同时运用也很不稳定。
而在resin平台，情况较好。只要在页面第一行加入：
即可正确处理中文。
如果再加编码则反而不对。
5 session中包含的中文
在jswdk中，奇怪的是如果从form中读出的值经过编码则可正确显示；但直接赋予中文值则不行。
resin平台很好，同上。
6 对于对变量赋中文值后正确显示中文。
例如以下程序：


String Hi="你好";
byte[] tmpbyte=Hi.getBytes("ISO8859_1");
Hi=new String(tmpbyte);
out.print(Hi);
% >

同样是jswdk1.0.1,以上的表示方法在jdk1.2.2中没有问题，但在jdk1.3下却无法显示。
resin平台很好，同上，经过测试，只需要在中补上

而不需要也能正确显示中文。
体会：
jswdk也许只能用于普通开发，稳定性和其它问题可能不如商业软件。
由于jdk1.3版性能要好于jdk1.2.2很多倍，并且对中文的支持也较好，所以应该加以采用。
作为免费的商业软件，resin不仅速度快，稳定，自动编译，可指出出错行，可在服务器端支持使用javascript等，而且，至少我觉得对中文的支持很好。
当然，如果不必做任何处理即可正确显示中文将是我们所期待的。
另外，相信在unix/linux/solaris下应该没有这样的问题.
一般来说，只要你做到了以上几点，你的JSP几乎（根本各人的配置吧）不会再有中文问题了！
JSP/Servlet 中的汉字编码问题
网上就 JSP/Servlet 中 DBCS 字符编码问题有许多优秀的文章和讨论，本文对它们作一些整理，并结合 IBM WebSphere Application Server 3.5（WAS）的解决方法作一些说明，希望它不是多余的。
内容：
问题的起源
GB2312-80，GBK，GB18030-2000 汉字字符集及 Encoding
中文转码时´?´、乱码的由来
JSP/Servlet 汉字编码问题及在 WAS 中的解决办法
结束语
参考文章
1. 问题的起源
每个国家（或区域）都规定了计算机信息交换用的字符编码集，如美国的扩展 ASCII码, 中国的 GB2312-80，日本的 JIS 等，作为该国家/区域内信息处理的基础，有着统一编码的重要作用。字符编码集按长度分为 SBCS（单字节字符集），DBCS（双字节字符集）两大类。早期的软件（尤其是操作系统），为了解决本地字符信息的计算机处理，出现了各种本地化版本（L10N），为了区分，引进了 LANG, Codepage 等概念。但是由于各个本地字符集代码范围重叠，相互间信息交换困难；软件各个本地化版本独立维护成本较高。因此有必要将本地化工作中的共性抽取出来，作一致处理，将特别的本地化处理内容降低到最少。这也就是所谓的国际化（I18N）。各种语言信息被进一步规范为 Locale 信息。处理的底层字符集变成了几乎包含了所有字形的 Unicode。
现在大部分具有国际化特征的软件核心字符处理都是以 Unicode 为基础的，在软件运行时根据当时的 Locale/Lang/Codepage 设置确定相应的本地字符编码设置，并依此处理本地字符。在处理过程中需要实现 Unicode 和本地字符集的相互转换，甚或以 Unicode 为中间的两个不同本地字符集的相互转换。这种方式在网络环境下被进一步延伸，任何网络两端的字符信息也需要根据字符集的设置转换成可接受的内容。
Java 语言内部是用 Unicode 表示字符的，遵守 Unicode V2.0。Java 程序无论是从/往文件系统以字符流读/写文件，还是往 URL 连接写 HTML 信息，或从 URL 连接读取参数值，都会有字符编码的转换。这样做虽然增加了编程的复杂度，容易引起混淆，但却是符合国际化的思想的。
从理论上来说，这些根据字符集设置而进行的字符转换不应该产生太多问题。而事实是由于应用程序的实际运行环境不同，Unicode 和各个本地字符集的补充、完善，以及系统或应用程序实现的不规范，转码时出现的问题时时困扰着程序员和用户。
2. GB2312-80，GBK，GB18030-2000 汉字字符集及 Encoding
其实解决 JAVA 程序中的汉字编码问题的方法往往很简单，但理解其背后的原因，定位问题，还需要了解现有的汉字编码和编码转换。
GB2312-80 是在国内计算机汉字信息技术发展初始阶段制定的，其中包含了大部分常用的一、二级汉字，和 9 区的符号。该字符集是几乎所有的中文系统和国际化的软件都支持的中文字符集，这也是最基本的中文字符集。其编码范围是高位0xa1－0xfe，低位也是 0xa1-0xfe；汉字从 0xb0a1 开始，结束于 0xf7fe；
GBK 是 GB2312-80 的扩展，是向上兼容的。它包含了 20902 个汉字，其编码范围是 0x8140-0xfefe，剔除高位 0x80 的字位。其所有字符都可以一对一映射到 Unicode 2.0，也就是说 JAVA 实际上提供了 GBK 字符集的支持。这是现阶段 Windows 和其它一些中文操作系统的缺省字符集，但并不是所有的国际化软件都支持该字符集，感觉是他们并不完全知道 GBK 是怎么回事。值得注意的是它不是国家标准，而只是规范。随着 GB18030-2000国标的发布，它将在不久的将来完成它的历史使命。
GB18030-2000(GBK2K) 在 GBK 的基础上进一步扩展了汉字，增加了藏、蒙等少数民族的字形。GBK2K 从根本上解决了字位不够，字形不足的问题。它有几个特点，
它并没有确定所有的字形，只是规定了编码范围，留待以后扩充。
编码是变长的，其二字节部分与 GBK 兼容；四字节部分是扩充的字形、字位，其编码范围是首字节 0x81-0xfe、二字节0x30-0x39、三字节 0x81-0xfe、四字节0x30-0x39。
它的推广是分阶段的，首先要求实现的是能够完全映射到 Unicode 3.0 标准的所有字形。
它是国家标准，是强制性的。
现在还没有任何一个操作系统或软件实现了 GBK2K 的支持，这是现阶段和将来汉化的工作内容。
Unicode 的介绍......就免了吧。
JAVA 支持的encoding中与中文编程相关的有：(有几个在JDK文档中未列出)
ASCII 7-bit, 同 ascii7
ISO8859-1 8-bit, 同 8859_1,ISO-8859-1,ISO_8859-1,latin1...
GB2312-80 同gb2312,gb2312-1980,EUC_CN,euccn,1381,Cp1381, 1383, Cp1383, ISO2022CN,ISO2022CN_GB......
GBK (注意大小写),同MS936
UTF8 UTF-8
GB18030 (现在只有IBM JDK1.3.?有支持), 同Cp1392,1392
JAVA 语言采用Unicode处理字符. 但从另一个角度来说，在java程序中也可以采用非Unicode的转码，重要的是保证程序入口和出口的汉字信息不失真。如完全采用ISO-8859-1来处理汉字也能达到正确的结果。网络上流行的许多解决方法，都属于这种类型。为了不致引起混淆，本文不对这种方法作讨论。
3. 中文转码时´?´、乱码的由来
两个方向转换都有可能得到错误的结果：
Unicode-->Byte, 如果目标代码集不存在对应的代码，则得到的结果是0x3f.
如：
"u00d6u00ecu00e9u0046u00bbu00f9".getBytes("GBK") 的结果是 "?ìéF?ù", Hex 值是3fa8aca8a6463fa8b4.
仔细看一下上面的结果，你会发现u00ec被转换为0xa8ac, u00e9被转换为xa8a6... 它的实际有效位变长了！这是因为GB2312符号区中的一些符号被映射到一些公共的符号编码，由于这些符号出现在ISO-8859-1或其它一些SBCS字符集中，故它们在Unicode中编码比较靠前，有一些其有效位只有8位，和汉字的编码重叠(其实这种映射只是编码的映射，在显示时仔细不是一样的。Unicode 中的符号是单字节宽，汉字中的符号是双字节宽) . 在Unicodeu00a0--u00ff 之间这样的符号有20个。了解这个特征非常重要！由此就不难理解为什么JAVA编程中，汉字编码的错误结果中常常会出现一些乱码(其实是符号字符), 而不全是´?´字符, 就比如上面的例子。
Byte-->Unicode, 如果Byte标识的字符在源代码集不存在，则得到的结果是0xfffd.
如：
Byte ba[] = {(byte)0x81,(byte)0x40,(byte)0xb0,(byte)0xa1}; new String(ba,"gb2312");
结果是"?啊", hex 值是"ufffdu554a". 0x8140 是GBK字符，按GB2312转换表没有对应的值，取ufffd. (请注意：在显示该uniCode时，因为没有对应的本地字符，所以也适用上一种情况，显示为一个"?".)
实际编程中，JSP/Servlet 程序得到错误的汉字信息，往往是这两个过程的叠加，有时甚至是两个过程叠加后反复作用的结果.
4. JSP/Servlet 汉字编码问题及在 WAS 中的解决办法
4.1 常见的 encoding 问题的现象
网上常出现的 JSP/Servlet encoding 问题一般都表现在 browser 或应用程序端，如:
浏览器中看到的 Jsp/Servlet 页面中的汉字怎么都成了 ’?’ ?
浏览器中看到的 Servlet 页面中的汉字怎么都成了乱码？
JAVA 应用程序界面中的汉字怎么都成了方块？
Jsp/Servlet 页面无法显示 GBK 汉字。
JSP 页面中内嵌在,等Tag包含的 JAVA code 中的中文成了乱码，但页面的其它汉字是对的。
Jsp/Servlet 不能接收 form 提交的汉字。
JSP/Servlet 数据库读写无法获得正确的内容。
隐藏在这些问题后面的是各种错误的字符转换和处理（除第3个外，是因为 Java font 设置错误引起的）。解决类似的字符 encoding 问题，需要了解 Jsp/Servlet 的运行过程，检查可能出现问题的各个点。
4.2 JSP/Servlet web 编程时的 encoding 问题
运行于Java 应用服务器的 JSP/Servlet 为 Browser 提供 HTML 内容，其过程如下图所示：
其中有字符编码转换的地方有:
JSP 编译。Java 应用服务器将根据 JVM 的 file.encoding 值读取 JSP 源文件，编译生成 JAVA 源文件，再根据 file.encoding 值写回文件系统。如果当前系统语言支持 GBK，那么这时候不会出现 encoding 问题。如果是英文的系统，如 LANG 是 en_US 的 Linux, AIX 或 Solaris，则要将 JVM 的 file.encoding 值置成 GBK 。系统语言如果是 GB2312，则根据需要，确定要不要设置 file.encoding，将 file.encoding 设为 GBK 可以解决潜在的 GBK 字符乱码问题
Java 需要被编译为 .class 才能在 JVM 中执行，这个过程存在与a.同样的 file.encoding 问题。从这里开始 servlet 和 jsp 的运行就类似了，只不过 Servlet 的编译不是自动进行的。对于JSP程序, 对产生的JAVA 中间文件的编译是自动进行的(在程序中直接调用sun.tools.javac.Main类). 因此如果在这一步出现问题的话, 也要检查encoding和OS的语言环境，或者将内嵌在JSP JAVA Code 中的静态汉字转为 Unicode, 要么静态文本输出不要放在 JAVA code 中。对于Servlet, javac 编译时手工指定-encoding 参数就可以了。
Servlet 需要将 HTML 页面内容转换为 browser 可接受的 encoding 内容发送出去。依赖于各 JAVA App Server 的实现方式，有的将查询 Browser 的 accept-charset 和 accept-language 参数或以其它猜的方式确定 encoding 值，有的则不管。因此采用固定encoding 也许是最好的解决方法。对于中文网页，可在 JSP 或 Servlet 中设置 contentType="text/html; charset=GB2312"；如果页面中有GBK字符，则设置为contentType="text/html; charset=GBK"，由于IE 和 Netscape对GBK的支持程度不一样，作这种设置时需要测试一下。
因为16位 JAVA char在网络传送时高8位会被丢弃，也为了确保Servlet页面中的汉字（包括内嵌的和servlet运行过程中得到的）是期望的内码，可以用 PrintWriter out=res.getWriter() 取代 ServletOutputStream out=res.getOutputStream(). PrinterWriter 将根据contentType中指定的charset作转换 (ContentType需在此之前指定！); 也可以用OutputStreamWriter封装 ServletOutputStream 类并用write(String)输出汉字字符串。
对于 JSP，JAVA Application Server 应当能够确保在这个阶段将嵌入的汉字正确传送出去。
这是解释 URL 字符 encoding 问题。如果通过 get/post 方式从 browser 返回的参数值中包含汉字信息， servlet 将无法得到正确的值。SUN的 J2SDK 中，HttpUtils.parseName 在解析参数时根本没有考虑 browser 的语言设置，而是将得到的值按 byte 方式解析。这是网上讨论得最多的 encoding 问题。因为这是设计缺陷，只能以 bin 方式重新解析得到的字符串；或者以 hack HttpUtils 类的方式解决。参考文章 2 均有介绍，不过最好将其中的中文 encoding GB2312、 CP1381 都改为 GBK，否则遇到 GBK 汉字时，还是会有问题。
Servlet API 2.3 提供一个新的函数 HttpServeletRequest.setCharacterEncoding 用于在调用 request.getParameter(“param_name”) 前指定应用程序希望的 encoding，这将有助于彻底解决这个问题。
4.3 IBM Websphere Application Server 中的解决方法
WebSphere Application Server 对标准的 Servlet API 2.x 作了扩展，提供较好的多语言支持。运行在中文的操作系统中，可以不作任何设置就可以很好地处理汉字。下面的说明只是对WAS是运行在英文的系统中，或者需要有GBK支持时有效。
上述c,d情况，WAS 都要查询 Browser 的语言设置，在缺省状况下， zh, zh-cn 等均被映射为 JAVA encoding CP1381（注意： CP1381 只是等同于 GB2312 的一个 codepage，没有 GBK 支持）。这样做我想是因为无法确认 Browser 运行的操作系统是支持GB2312, 还是 GBK，所以取其小。但是实际的应用系统还是要求页面中出现 GBK 汉字，最著名的是朱总理名字中的“?"(rong2 ，0xe946，u9555)，所以有时还是需要将 Encoding/Charset 指定为 GBK。当然 WAS 中变更缺省的 encoding 没有上面说的那么麻烦，针对 a,b，参考文章 5，在 Application Server 的命令行参数中指定 -Dfile.encoding=GBK 即可； 针对 d，在 Application Server 的命令行参数中指定-Ddefault.client.encoding=GBK。如果指定了-Ddefault.client.encoding=GBK，那么c情况下可以不再指定charset。
上面列出的问题中还有一个关于Tag,中的 JAVA 代码里包含的静态文本未能正确显示的问题，在WAS中的解决方法是除了设置正确的file.encoding, 还需要以相同方法设置-Duser.language=zh -Duser.region=CN。这与JAVA locale的设置有关。
4.4 数据库读写时的 encoding 问题
JSP/Servlet 编程中经常出现 encoding 问题的另一个地方是读写数据库中的数据。
流行的关系数据库系统都支持数据库 encoding，也就是说在创建数据库时可以指定它自己的字符集设置，数据库的数据以指定的编码形式存储。当应用程序访问数据时，在入口和出口处都会有 encoding 转换。对于中文数据，数据库字符编码的设置应当保证数据的完整性. GB2312，GBK，UTF-8 等都是可选的数据库 encoding；也可以选择 ISO8859-1 (8-bit)，那么应用程序在写数据之前须将 16Bit 的一个汉字或 Unicode 拆分成两个 8-bit 的字符，读数据之后则需将两个字节合并起来，同时还要判别其中的 SBCS 字符。没有充分利用数据库 encoding 的作用，反而增加了编程的复杂度，ISO8859-1不是推荐的数据库 encoding。JSP/Servlet编程时，可以先用数据库管理系统提供的管理功能检查其中的中文数据是否正确。
然后应当注意的是读出来的数据的 encoding，JAVA 程序中一般得到的是 Unicode。写数据时则相反。
4.5 定位问题时常用的技巧
定位中文encoding问题通常采用最笨的也是最有效的办法??在你认为有嫌疑的程序处理后打印字符串的内码。通过打印字符串的内码，你可以发现什么时候中文字符被转换成Unicode，什么时候Unicode被转回中文内码，什么时候一个中文字成了两个 Unicode 字符，什么时候中文字符串被转成了一串问号，什么时候中文字符串的高位被截掉了……
取用合适的样本字符串也有助于区分问题的类型。如：”aa啊aa?aa” 等中英相间、GB、GBK特征字符均有的字符串。一般来说，英文字符无论怎么转换或处理，都不会失真（如果遇到了，可以尝试着增加连续的英文字母长度）。
5. 结束语
其实 JSP/Servlet 的中文encoding 并没有想像的那么复杂，虽然定位和解决问题没有定规，各种运行环境也各不尽然，但后面的原理是一样的。了解字符集的知识是解决字符问题的基础。不过，随着中文字符集的变化，不仅仅是 java 编程，中文信息处理中的问题还是会存在一段时间的。
关于Servlet、Jsp中的多国语言显示
因为一直不信Java竟会有不能混排显示多国语言的BUG，这个周末研究了一下Servlet、Jsp的多国语言显示的问题，也就是Servlet的多字符集问题，由于我对字符集的概念还不是很清晰所以写出的东西未必是准确的，我是这样理解Java中的字符集的：在运行时，每个字符串对象中存储的都是编码为UNICODE内码的（我觉得所有的语言中都是有相应编码的，因为在计算机内部字符串总是用内码来表示的，只不过一般计算机语言中的字符串编码时平台相关的，而Java则采用了平台无关的UNICODE）。
　　Java从一个byte流中读取一个字符串时，将把平台相关的byte转变为平台无关的Unicode字符串。在输出时Java将把Unicode字符串转变为平台相关的byte流，如果某个Unicode字符在某个平台上不存在，将会输出一个´?´。举个例子：在中文Windows中，Java读出一个"GB2312"编码的文件（可以是任何流）到内存中构造字符串对象，将会把GB2312编码的文字转变为Unicode编码的字符串，如果把这个字符串输出又将会把Unicode字符串转化为GB2312的byte流或数组："中文测试"----->"u4e2du6587u6d4bu8bd5"----->"中文测试"。
如下例程：
byte[] bytes = new byte[]{(byte)0xd6, (byte)0xd0, (byte)0xce, (byte)0xc4, (byte)0xb2, (byte)0xe2, (byte)0xca, (byte)0xd4};//GBK编码的"中文测试"
java.io.ByteArrayInputStream bin = new java.io.ByteArrayInputStream(bytes);
java.io.BufferedReader reader = new java.io.BufferedReader(new java.io. InputStreamReader (bin,"GBK"));
String msg = reader.readLine();
System.out.println(msg)
　　这段程序放到包含"中文测试"这四个字的系统（如中文系统）中，可以正确地打印出这些字。msg字符串中包含了正确的"中文测试"的Unicode编码："u4e2du6587u6d4bu8bd5"，打印时转换为操作系统的默认字符集，是否可以正确显示依赖于操作系统的字符集，只有在支持相应字符集的系统中，我们的信息才能正确的输出，否则得到的将会是垃圾。
　　话入正题，我们来看看Servlet/Jsp中的多语言问题。我们的目标是，任一国家的客户端通过Form向Server发送信息，Server把信息存入数据库中，客户端在检索时仍然能够看到自己发送的正确信息。事实上，我们要保证，最终Server中的SQL语句中保存的时包含客户端发送文字的正确Unicode编码；DBC与数据库通讯时采用的编码方式能包含客户端发送的文字信息，事实上，最好让JDBC直接使用UNICODE/UTF8与数据库通讯！这样就可以确保不会丢失信息；Server向客户端发送的信息时也要采用不丢失信息的编码方式，也可以是Unicode/Utf8。
　　如果不指定Form的Enctype属性，Form将把输入的内容依照当前页面的编码字符集urlencode之后再提交，服务器端得到是urlencoding的字符串。编码后得到的urlencoding字符串是与页面的编码相关的，如gb2312编码的页面提交"中文测试"，得到的是"%D6%D0%CE%C4%B2%E2%CA%D4"，每个"％"后跟的是16进制的字符串；而在UTF8编码时得到的却是"%E4%B8%AD%E6%96%87%E6%B5%8B%E8%AF%95"，因为GB2312编码中一个汉字是16位的，而UTF8中一个汉字却是24位的。中日韩三国的ie4以上浏览器均支持UTF8编码，这种方案肯定包涵了这三国语言，所以我们如果让Html页面使用UTF8编码那么将至少可以支持这三国语言。
　　但是，如果我们html/Jsp页面使用UTF8编码，因为应用程序服务器可能不知道这种情况，因为如果浏览器发送的信息不包含charset信息，至多Server知道读到Accept-Language请求投标，我们知道仅靠这个投标是不能获知浏览器所采用编码的，所以应用程序服务器不能正确解析提交的内容，为什么？因为Java中的所有字符串都是Unicode16位编码的，HttpServletRequest.request(String)的功能就是把客户端提交的Urlencode编码的信息转为Unicode字符串，有些Server只能认为客户端的编码和Server平台相同，简单地使用URLDecoder.decode(String)方法直接解码，如果客户端编码恰好和Server相同，那么就可以得到正确地字符串，否则，如果提交地字符串中包含了当地字符，那么将会导致垃圾信息。
　　在我提出的这个解决方案里，已经指定了采用Utf8编码，所以，可以避免这个问题，我们可以自己定制出decode方法：
public static String decode(String s,String encoding) throws Exception {
StringBuffer sb = new StringBuffer();
for(int i=0; ichar c = s.charAt(i);
switch (c) {
case ´+´:
sb.append(´ ´);
break;
case ´%´:
try {
sb.append((char)Integer.parseInt(
s.substring(i+1,i+3),16));
}
catch (NumberFormatException e) {
throw new IllegalArgumentException();
}
i += 2;
break;
default:
sb.append(c);
break;
}
}
// Undo conversion to external encoding
String result = sb.toString();
byte[] inputBytes = result.getBytes("8859_1");
return new String(inputBytes,encoding);
}
　　这个方法可以指定encoding，如果把它指定为UTF8就满足了我们的需要。比如用它解析："%E4%B8%AD%E6%96%87%E6%B5%8B%E8%AF%95"就可以得到正确的汉字"中文测试"的Unicode字符串。
现在的问题就是我们必须得到客户端提交的Urlencode的字符串。对于method为get的form提交的信息，可以用HttpServletRequest.getQueryString()方法读到，而对于post方法的form提交的信息，只能从ServletInputStream中读到，事实上标准的getParameter方法被第一次调用后，form提交的信息就被读取出来了，而ServletInputStream是不能重复读出的。所以我们应在第一次使用getParameter方法前读取并解析form提交的信息。
　　我是这么做的，建立一个Servlet基类，覆盖service方法，在调用父类的service方法前读取并解析form提交的内容，请看下面的源代码：
package com.hto.servlet;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
/**
* Insert the type´s description here.
* Creation date: (2001-2-4 15:43:46)
* @author: 钱卫春
*/
public class UTF8ParameterReader {
Hashtable pairs = new Hashtable();
/**
* UTF8ParameterReader constructor comment.
*/
public UTF8ParameterReader(HttpServletRequest request) throws java.io.IOException{
super();
parse(request.getQueryString());
parse(request.getReader().readLine());
}
/**
* UTF8ParameterReader constructor comment.
*/
public UTF8ParameterReader(HttpServletRequest request,String encoding) throws java.io.IOException{
super();
parse(request.getQueryString(),encoding);
parse(request.getReader().readLine(),encoding);
}
public static String decode(String s) throws Exception {
StringBuffer sb = new StringBuffer();
for(int i=0; ichar c = s.charAt(i);
switch (c) {
case ´+´:
sb.append(´ ´);
break;
case ´%´:
try {
sb.append((char)Integer.parseInt(
s.substring(i+1,i+3),16));
}
catch (NumberFormatException e) {
throw new IllegalArgumentException();
}
i += 2;
break;
default:
sb.append(c);
break;
}
}
// Undo conversion to external encoding
String result = sb.toString();
byte[] inputBytes = result.getBytes("8859_1");
return new String(inputBytes,"UTF8");
}
public static String decode(String s,String encoding) throws Exception {
StringBuffer sb = new StringBuffer();
for(int i=0; ichar c = s.charAt(i);
switch (c) {
case ´+´:
sb.append(´ ´);
break;
case ´%´:
try {
sb.append((char)Integer.parseInt(
s.substring(i+1,i+3),16));
}
catch (NumberFormatException e) {
throw new IllegalArgumentException();
}
i += 2;
break;
default:
sb.append(c);
break;
}
}
// Undo conversion to external encoding
String result = sb.toString();
byte[] inputBytes = result.getBytes("8859_1");
return new String(inputBytes,encoding);
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-4 17:30:59)
* @return java.lang.String
* @param name java.lang.String
*/
public String getParameter(String name) {
if (pairs == null || !pairs.containsKey(name)) return null;
return (String)(((ArrayList) pairs.get(name)).get(0));
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-4 17:28:17)
* @return java.util.Enumeration
*/
public Enumeration getParameterNames() {
if (pairs == null) return null;
return pairs.keys();
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-4 17:33:40)
* @return java.lang.String[]
* @param name java.lang.String
*/
public String[] getParameterValues(String name) {
if (pairs == null || !pairs.containsKey(name)) return null;
ArrayList al = (ArrayList) pairs.get(name);
String[] values = new String[al.size()];
for(int i=0;ireturn values;
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-4 20:34:37)
* @param urlenc java.lang.String
*/
private void parse(String urlenc) throws java.io.IOException{
if (urlenc == null) return;
StringTokenizer tok = new StringTokenizer(urlenc,"&");
try{
while (tok.hasMoreTokens()){
String aPair = tok.nextToken();
int pos = aPair.indexOf("=");
String name = null;
String value = null;
if(pos != -1){
name = decode(aPair.substring(0,pos));
value = decode(aPair.substring(pos+1));
}else{
name = aPair;
value = "";
}
if(pairs.containsKey(name)){
ArrayList values = (ArrayList)pairs.get(name);
values.add(value);
}else{
ArrayList values = new ArrayList();
values.add(value);
pairs.put(name,values);
}
}
}catch(Exception e){
throw new java.io.IOException(e.getMessage());
}
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-4 20:34:37)
* @param urlenc java.lang.String
*/
private void parse(String urlenc,String encoding) throws java.io.IOException{
if (urlenc == null) return;
StringTokenizer tok = new StringTokenizer(urlenc,"&");
try{
while (tok.hasMoreTokens()){
String aPair = tok.nextToken();
int pos = aPair.indexOf("=");
String name = null;
String value = null;
if(pos != -1){
name = decode(aPair.substring(0,pos),encoding);
value = decode(aPair.substring(pos+1),encoding);
}else{
name = aPair;
value = "";
}
if(pairs.containsKey(name)){
ArrayList values = (ArrayList)pairs.get(name);
values.add(value);
}else{
ArrayList values = new ArrayList();
values.add(value);
pairs.put(name,values);
}
}
}catch(Exception e){
throw new java.io.IOException(e.getMessage());
}
}
}
这个类的功能就是读取并保存form提交的信息，并实现常用的getParameter方法。
package com.hto.servlet;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
/**
* Insert the type´s description here.
* Creation date: (2001-2-5 8:28:20)
* @author: 钱卫春
*/
public class UtfBaseServlet extends HttpServlet {
public static final String PARAMS_ATTR_NAME = "PARAMS_ATTR_NAME";
/**
* Process incoming HTTP GET requests
*
* @param request Object that encapsulates the request to the servlet
* @param response Object that encapsulates the response from the servlet
*/
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
performTask(request, response);
}
/**
* Process incoming HTTP POST requests
*
* @param request Object that encapsulates the request to the servlet
* @param response Object that encapsulates the response from the servlet
*/
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
performTask(request, response);
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-5 8:52:43)
* @return int
* @param request javax.servlet.http.HttpServletRequest
* @param name java.lang.String
* @param required boolean
* @param defValue int
*/
public static java.sql.Date getDateParameter(HttpServletRequest request, String name, boolean required, java.sql.Date defValue) throws ServletException{
String value = getParameter(request,name,required,String.valueOf(defValue));
return java.sql.Date.valueOf(value);
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-5 8:52:43)
* @return int
* @param request javax.servlet.http.HttpServletRequest
* @param name java.lang.String
* @param required boolean
* @param defValue int
*/
public static double getDoubleParameter(HttpServletRequest request, String name, boolean required, double defValue) throws ServletException{
String value = getParameter(request,name,required,String.valueOf(defValue));
return Double.parseDouble(value);
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-5 8:52:43)
* @return int
* @param request javax.servlet.http.HttpServletRequest
* @param name java.lang.String
* @param required boolean
* @param defValue int
*/
public static float getFloatParameter(HttpServletRequest request, String name, boolean required, float defValue) throws ServletException{
String value = getParameter(request,name,required,String.valueOf(defValue));
return Float.parseFloat(value);
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-5 8:52:43)
* @return int
* @param request javax.servlet.http.HttpServletRequest
* @param name java.lang.String
* @param required boolean
* @param defValue int
*/
public static int getIntParameter(HttpServletRequest request, String name, boolean required, int defValue) throws ServletException{
String value = getParameter(request,name,required,String.valueOf(defValue));
return Integer.parseInt(value);
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-5 8:43:36)
* @return java.lang.String
* @param request javax.servlet.http.HttpServletRequest
* @param name java.lang.String
* @param required boolean
* @param defValue java.lang.String
*/
public static String getParameter(HttpServletRequest request, String name, boolean required, String defValue) throws ServletException{
if(request.getAttribute(UtfBaseServlet.PARAMS_ATTR_NAME) != null) {
UTF8ParameterReader params = (UTF8ParameterReader)request.getAttribute(UtfBaseServlet.PARAMS_ATTR_NAME);
if (params.getParameter(name) != null) return params.getParameter(name);
if (required) throw new ServletException("The Parameter "+name+" Required but not provided!");
else return defValue;
}else{
if (request.getParameter(name) != null) return request.getParameter(name);
if (required) throw new ServletException("The Parameter "+name+" Required but not provided!");
else return defValue;
}
}
/**
* Returns the servlet info string.
*/
public String getServletInfo() {
return super.getServletInfo();
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-5 8:52:43)
* @return int
* @param request javax.servlet.http.HttpServletRequest
* @param name java.lang.String
* @param required boolean
* @param defValue int
*/
public static java.sql.Timestamp getTimestampParameter(HttpServletRequest request, String name, boolean required, java.sql.Timestamp defValue) throws ServletException{
String value = getParameter(request,name,required,String.valueOf(defValue));
return java.sql.Timestamp.valueOf(value);
}
/**
* Initializes the servlet.
*/
public void init() {
// insert code to initialize the servlet here
}
/**
* Process incoming requests for information
*
* @param request Object that encapsulates the request to the servlet
* @param response Object that encapsulates the response from the servlet
*/
public void performTask(HttpServletRequest request, HttpServletResponse response) {
try
{
// Insert user code from here.
}
catch(Throwable theException)
{
// uncomment the following line when unexpected exceptions
// are occuring to aid in debugging the problem.
//theException.printStackTrace();
}
}
/**
* Insert the method´s description here.
* Creation date: (2001-2-5 8:31:54)
* @param request javax.servlet.ServletRequest
* @param response javax.servlet.ServletResponse
* @exception javax.servlet.ServletException The exception description.
* @exception java.io.IOException The exception description.
*/
public void service(ServletRequest request, ServletResponse response) throws javax.servlet.ServletException, java.io.IOException {
String content = request.getContentType();
if(content == null || content != null && content.toLowerCase().startsWith("application/x-www-form-urlencoded"))
request.setAttribute(PARAMS_ATTR_NAME,new UTF8ParameterReader((HttpServletRequest)request));
super.service(request,response);
}
}
　　这个就是Servlet基类，它覆盖了父类的service方法，在调用父类service前，创建了UTF8ParameterReader对象，其中保存了form中提交的信息。然后把这个对象作为一个Attribute保存到Request对象中。然后照样调用父类的service方法。
　　对于继承这个类的Servlet，要注意的是，"标准"getParameter在也不能读到post的数据，因为在这之前这个类中已经从ServletInputStream中读出了数据了。所以应该使用该类中提供的getParameter方法。
　　剩下的就是输出问题了，我们要把输出的信息，转为UTF8的二进制流输出。只要我们设置Content-Type时指定charset为UTF8，然后使用PrintWriter输出，那么这些转换是自动进行的，Servlet中这样设置：
　　response.setContentType("text/html;charset=UTF8");
Jsp中这样设置：
　　
　　这样就可以保证输出是UTF8流，客户端能否显示，就看客户端的了。
　　对于multipart/form-data的form提交的内容，我也提供一个类用来处理，在这个类的构造子中可以指定页面使用的charset，默认还是UTF-8，限于篇幅不贴出源码。
在Jsp程序解决向DB读取或写入时的乱码问题
在基于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");
就不会出现中文问题了。
Tomcat中Java/jsp中文问题完全解决方案
Tomcat 3.23以下的版本
对于Tomcat 3.23以下版本,Java中的中文问题网上已经谈了不少,一般遇到中文问题使用转换函数转换.toChinese()
public static String toChinese(String strvalue)
{
try{
if(strvalue==null)
return null;
else
{
strvalue = new String(strvalue.getBytes("ISO8859_1"), "GBK");
return strvalue;
}
}catch(Exception e){
return null;
}
}
凡是涉及中文字符串,如从数据库中读取中文字符串,或变量名赋值时,使用toChinese函数:
toChinese("这是中文字符串")
注:该办法在使用javamail发送中文信息时似乎有问题
Tomcat 4.0以上的版本
在4.0以后的版本,已经不需要象3.23版本中使用字符转换函数:
(1)编译javabean时 javac 命令行加上-encoding ISO8859_1
(2)在Jsp头部中加入
是不是很简单? 使用本办法基本可以对付实际应用,推荐!
但也有一个缺点是,通过form表单get参数;或在url后附带中文,这个办法就失效,我相信应该有办法解决.
该办法原理就是在java的各个环节统一编码为:ISO8859_1.
修改tomcat
该办法是一位网友在论坛贴出的,我没有试验,转载于此:
只要修改一个地方就行了，文件为:
tomcat4/src/catalina/src/share/org/apache/catalina/connector/HttpReque
stBase.java
找到protected void parseParameters()方法，把
if (encoding == null)
encoding = "ISO-8859-1";
改为
if (encoding == null)
encoding = "GBK";
编译:
解开jakarta-servletapi-4的原码包,找到servlet.jar文件设置到CLASSPATH
找到tomcat4.0.1的bin包将catalina.jar设置到CLASSPATH.
因为编译时要使用这些api.
然后javac HttpRequestBase.java生成两个class文件.
解开catalina.jar jar xvf catalina.jar(tomcat bin包中的)
覆盖调原来的两个class文件:
jar cvf catalina.jar org
即可
重启tomcat4，一切OK!，你再也不用编写烦人的编码转换了。
jsp中框架页面请求中的中文编码问题
最近有这么一个需求，一个主页面从request中拿到请求的参数（中文）,主页面里有两个Frame,每个Frame嵌着一个jsp,如何把主页面中得到的中文参数值传入Frame里去呢，后来发现应该先把中文编码成unicode,然后传给frame中的jsp，frame中的jsp再解码，程序清单如下:index.jsp
========================================================


String flowname = request.getParameter("flowname");
% >



业务相关资料



" name="topFrame" frameborder="1" scrolling="auto" noresize >



assetlist.jsp
========================================================












String cond ="flowname = '"+ request.getParameter("flowname")+"'";
// out.println(cond);
HttpSession sess = request.getSession();
int allpage = 0;//页数
String pageNo = request.getParameter("pageNo");
//pageNo为null,则赋值为1
if(pageNo==null){
pageNo="1";
sess.setAttribute("flowname",cond);
}
else{
cond = (String)sess.getAttribute("flowname");
// out.println(cond);
}
int p = Integer.parseInt(pageNo);//当前页
ArrayList al = new ArrayList();
int size=0;
try{
DAMInterfaceApp dapp = new DAMInterfaceApp();
Verify ver = new Verify(dapp);
ver.login("admin","admin");
QueryAssetExt quExt = QueryAssetExt.getInstance(dapp);
String strQueryResult = "";
try
{
strQueryResult = quExt.queryAllAssets(150,cond, "", "", 0);
}
catch(Exception qe)
{
System.err.print("错误：调用博思查询接口QueryAssetExt.queryAllAssets出错，错误信息为："+qe.getMessage());
}
//对得到的查询结果进行解析
//System.out.println("提示：查询结果为： "+strQueryResult);
al = (ArrayList)QueryAssetAdapter.getQueryAssets(strQueryResult);
allpage = PageUtil.getAllpage(al);
//out.println(allpage);
al = PageUtil.getPageItems(al,p);
size = al.size();
//out.println(size);
}
catch(Exception e){
e.printStackTrace();
}
% >
html >


业务相关资料

/css/csstop.css" rel="stylesheet" type="text/css" >
/css/link_sty.css" rel="stylesheet" type="text/css" >

var swd = null;
function selected(t)
{
if(swd!=null)
swd.className = "";
if(t==swd)
{
swd = null;
return;
}
t.className = "xz";
swd=t;
submit();
}
function submit()
{
document.frmAssets.assetid.value = swd.id;
document.frmAssets.submit();
}
#Table1 tr{ cursor:hand; }
.xz { color: #FFFFFF; background-color: #66CCCC; }
业务相关资料

标题
业务名称
处室
联系人
联系电话
版本
for(int j=0;j
"  >

















共  页
首页
int ii = 0;
if(p>1){
ii = p - 1;
}
% >
" >上一页
if(p}
else if(p==allpage){
ii = p;
}
% >
">下一页
">末页





编码解码的java程序Escape.java
========================================================
package gov.police.tech.application.appdata;
public class Escape {
private final static String[] hex = { "00", "01", "02", "03", "04", "05",
"06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F", "10",
"11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B",
"1C", "1D", "1E", "1F", "20", "21", "22", "23", "24", "25", "26",
"27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F", "30", "31",
"32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C",
"3D", "3E", "3F", "40", "41", "42", "43", "44", "45", "46", "47",
"48", "49", "4A", "4B", "4C", "4D", "4E", "4F", "50", "51", "52",
"53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D",
"5E", "5F", "60", "61", "62", "63", "64", "65", "66", "67", "68",
"69", "6A", "6B", "6C", "6D", "6E", "6F", "70", "71", "72", "73",
"74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E",
"7F", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89",
"8A", "8B", "8C", "8D", "8E", "8F", "90", "91", "92", "93", "94",
"95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F",
"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA",
"AB", "AC", "AD", "AE", "AF", "B0", "B1", "B2", "B3", "B4", "B5",
"B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF", "C0",
"C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB",
"CC", "CD", "CE", "CF", "D0", "D1", "D2", "D3", "D4", "D5", "D6",
"D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF", "E0", "E1",
"E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC",
"ED", "EE", "EF", "F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7",
"F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF" };
private final static byte[] val = { 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x00, 0x01,
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F };
/**
* 编码
*
* @param s
* @return
*/
public static String escape(String s) {
StringBuffer sbuf = new StringBuffer();
int len = s.length();
for (int i = 0; i int ch = s.charAt(i);
if ('A' sbuf.append((char) ch);
} else if ('a' sbuf.append((char) ch);
} else if ('0' sbuf.append((char) ch);
} else if (ch == '-' || ch == '_' // unreserved : as it was
|| ch == '.' || ch == '!' || ch == '~' || ch == '*'
|| ch == '\'' || ch == '(' || ch == ')') {
sbuf.append((char) ch);
} else if (ch sbuf.append('%');
sbuf.append(hex[ch]);
} else { // unicode : map to %uXXXX
sbuf.append('%');
sbuf.append('u');
sbuf.append(hex[(ch >>> 8)]);
sbuf.append(hex[(0x00FF & ch)]);
}
}
return sbuf.toString();
}
/**
* 解码 说明：本方法保证 不论参数s是否经过escape()编码，均能得到正确的“解码”结果
*
* @param s
* @return
*/
public static String unescape(String s) {
StringBuffer sbuf = new StringBuffer();
int i = 0;
int len = s.length();
while (i int ch = s.charAt(i);
if ('A' sbuf.append((char) ch);
} else if ('a' sbuf.append((char) ch);
} else if ('0' sbuf.append((char) ch);
} else if (ch == '-' || ch == '_' // unreserved : as it was
|| ch == '.' || ch == '!' || ch == '~' || ch == '*'
|| ch == '\'' || ch == '(' || ch == ')') {
sbuf.append((char) ch);
} else if (ch == '%') {
int cint = 0;
if ('u' != s.charAt(i + 1)) { // %XX : map to ascii(XX)
cint = (cint cint = (cint i += 2;
} else { // %uXXXX : map to unicode(XXXX)
cint = (cint cint = (cint cint = (cint cint = (cint i += 5;
}
sbuf.append((char) cint);
} else { // 对应的字符未经过编码
sbuf.append((char) ch);
}
i++;
}
return sbuf.toString();
}
public static void main(String[] args) {
String stest = "中文1234 abcd[](),.~\\";
System.out.println(stest);
System.out.println(escape(stest));
System.out.println(unescape(escape(stest)));
}
}

用filter来解决Struts中文乱码的问题
filter的用法，的确是比较有扩展性的一种方法...可以通过filter结合读取web.xml中的filter参数来完成一系列的动作，做法如下：
首先，实现javax.servlet.Filter接口，编写一个处理request编码的过滤器类...
package tutorial.struts.filter;
import javax.servlet.Filter;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.FilterChain;
import java.io.IOException;
public class SetCharacterEncodingFilter implements Filter {
  protected FilterConfig filterConfig;
  protected String encodingName;
  protected boolean enable;
  public SetCharacterEncodingFilter() {
    this.encodingName = "UTF-8";
    this.enable = false;
  }
  public void init(FilterConfig filterConfig) throws ServletException {
    this.filterConfig = filterConfig;
    loadConfigParams();
  }
  private void loadConfigParams() {
    //encoding
    this.encodingName = this.filterConfig.getInitParameter("encoding");
    //filter enable flag...
    String strIgnoreFlag = this.filterConfig.getInitParameter("enable");
    if (strIgnoreFlag.equalsIgnoreCase("true")) {
      this.enable = true;
    } else {
      this.enable = false;
    }
  }
  public void doFilter(ServletRequest request, ServletResponse response,
                       FilterChain chain) throws IOException, ServletException {
    if(this.enable) {
      request.setCharacterEncoding(this.encodingName);
    }
    chain.doFilter(request, response);
  }
  public void destroy() {
  }
}
然后，需要在web.xml中注册我们的过滤器类：
&lt filter &gt
    &lt filter-name &gtSet Character Encoding&lt /filter-name &gt
    &lt filter-class &gttutorial.struts.filter.SetCharacterEncodingFilter&lt /filter-class &gt
    &lt init-param &gt
      &lt param-name &gtencoding&lt /param-name &gt
      &lt param-value &gtUTF-8&lt /param-value &gt
    &lt /init-param &gt
    &lt init-param &gt
      &lt param-name &gtenable&lt /param-name &gt
      &lt param-value &gttrue&lt /param-value &gt
    &lt /init-param &gt
  &lt /filter &gt
  &lt filter-mapping &gt
    &lt filter-name &gtSet Character Encoding&lt /filter-name &gt
    &lt servlet-name &gtAction Servlet&lt /servlet-name &gt
  &lt /filter-mapping &gt
  &lt filter-mapping &gt
    &lt filter-name &gtSet Character Encoding&lt /filter-name &gt
    &lt servlet-name &gtFaces Servlet&lt /servlet-name &gt
  &lt /filter-mapping &gt
这样，任何通过Struts，或是JSF的Controller Servlet处理的request，都会在过滤器中先行处理，才把控制权交还给Struts或是JSF，而且Filter中有一个Process Chain的概念，是一个很吸引人的东东~~！
J2EE WEB-Tomcat5.5.9中文问题解决方案
1、html
　无论是独立的html，还是其他程序生成的，如Servlet等，注意在最终的html的和之间必须加入meta标签，用来指定html中输入字符的编码，如：
　
　
　测试GET && POST-Send
　
2、jsp和servlet
　首先必须解决程序输出(如response.writeln(String s))和接受从客户端传来的数据(如request.getParameter(String sname))编码问题，我们可以利用文件过滤功能，具体需要所用的jsp/servlet容器或者服务器提供的功能设置，如在Tomcat5.5.9中可以在webapps/yourAppDirectory/WEB-INF/web.xml中设置如下：

　 SetCharsetEncodingFilter
　 SetCharsetEncodingFilter
　 Set CharsetEncoding Filter
　 com.gg.comm.web.SetCharsetEncodingFilter
　  
　　 encoding
　　 gb2312
　  


　 SetCharsetEncodingFilter
　 /*

其中SetCharsetEncodingFilter Class就是用来设置request和reponse字符编码的filter类，其中设置语句如下：
　　request.setCharacterEncoding(targetEncoding);
　　response.setContentType("text/html");
　　response.setCharacterEncoding(targetEncoding);
　另外为了解决通过get(url中带有参数)方式传递参数的乱码问题，我们还需要设置一下url传递参数所需要的编码，具体在Tomcat5.5.9中可以在${Tomcat_home}\conf\server.xml中的和之间设置，如下：
　URIEncoding="GBK":Force GET method String(Chinese) can be transferd properly by http:uri
note:Tomcat only support GBK specification,so not set charset gb2312
-- >


　最后为了解决jsp的乱码问题，我们还需要作如下处理，即在左右的jsp头均加上如下指令：
　　
　　或者
　　
3、jdbc和数据库
　关于写入数据库和读取数据库数据的乱码问题，可以通过如下方式轻松解决：
对于JAVA程序的处理方法按我们指定的方法处理。
把数据库默认支持的编码格式改为GBK或GB2312的。
到此，一般来说对于WEB方式的应用来说，中文问题就可以解决了。当然以上方法是根据统一编码的原则解决的以及WEB方式的文件转换关系
（file->class->load->execute or transfered or response or request）来做的。

网友评论
定义三个类，A，B，C。在A中申明一个Button变量button1，在B再申明Button变量button2，把A中的变量button1赋给button2    在C中再申明一个Button变量button3，把给B中的变量button2赋给button3，为什么在C中button1就不等于button3


2007-03-19 15:06:29
赛迪网友

不错,比较全面,值得收藏~


2007-02-12 03:48:12
DIY

Java Programmer群号:18615413 技术联盟-软件交流！ 欢迎任何热爱JAVA的人进群切磋 ！


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u1/44781/showart_352828.html