Java几种常见的编码方式（转载）

时间：2024-02-24 14:22:20

作者：不巧，我在等你

原文：https://www.cnblogs.com/yaya-yaya/p/5768616.html

为什么要编码 


　　不知道大家有没有想过一个问题，那就是为什么要编码？我们能不能不编码？要回答这个问题必须要回到计算机是如何表示我们人类能够理解的符号的，

这些符号也就是我们人类使用的语言。由于人类的语言有太多，因而表示这些语言的符号太多，无法用计算机中一个基本的存储单元—— byte 来表示，

因而必须要经过拆分或一些翻译工作，才能让计算机能理解。我们可以把计算机能够理解的语言假定为英语，其它语言要能够在计算机中使用必须经过一次翻译，

把它翻译成英语。这个翻译的过程就是编码。所以可以想象只要不是说英语的国家要能够使用计算机就必须要经过编码。这看起来有些霸道，但是这就是现状，

这也和我们国家现在在大力推广汉语一样，希望其它国家都会说汉语，以后其它的语言都翻译成汉语，我们可以把计算机中存储信息的最小单位改成汉字，这样我们就不存在编码问题了。 


所以总的来说，编码的原因可以总结为： 

　　计算机中存储信息的最小单元是一个字节即 8 个 bit，所以能表示的字符范围是 0~255 个 人类要表示的符号太多，

无法用一个字节来完全表示 要解决这个矛盾必须需要一个新的数据结构 char，从 char 到 byte 必须编码 

如何“翻译” 

　　明白了各种语言需要交流，经过翻译是必要的，那又如何来翻译呢？计算中提拱了多种翻译方式，常见的有 ASCII、ISO-8859-1、GB2312、GBK、UTF-8、UTF-16 等。

它们都可以被看作为字典，它们规定了转化的规则，按照这个规则就可以让计算机正确的表示我们的字符。目前的编码格式很多，

例如 GB2312、GBK、UTF-8、UTF-16 这几种格式都可以表示一个汉字，那我们到底选择哪种编码格式来存储汉字呢？这就要考虑到其它因素了，是存储空间重要还是编码的效率重要。

根据这些因素来正确选择编码格式，下面简要介绍一下这几种编码格式。 


ASCII 码 

　　学过计算机的人都知道 ASCII 码，总共有 128 个，用一个字节的低 7 位表示，0~31 是控制字符如换行回车删除等；32~126 是打印字符，可以通过键盘输入并且能够显示出来。 

ISO-8859-1 

　　128 个字符显然是不够用的，于是 ISO 组织在 ASCII 码基础上又制定了一些列标准用来扩展 ASCII 编码，它们是 ISO-8859-1~ISO-8859-15，

其中 ISO-8859-1 涵盖了大多数西欧语言字符，所有应用的最广泛。ISO-8859-1 仍然是单字节编码，它总共能表示 256 个字符。 


GB2312 

　　它的全称是《信息交换用汉字编码字符集 基本集》，它是双字节编码，总的编码范围是 A1-F7，其中从 A1-A9 是符号区，总共包含 682 个符号，

从 B0-F7 是汉字区，包含 6763 个汉字。 


GBK 

　　全称叫《汉字内码扩展规范》，是国家技术监督局为 windows95 所制定的新的汉字内码规范，它的出现是为了扩展 GB2312，加入更多的汉字，

它的编码范围是 8140~FEFE（去掉 XX7F）总共有 23940 个码位，它能表示 21003 个汉字，它的编码是和 GB2312 兼容的，

也就是说用 GB2312 编码的汉字可以用 GBK 来解码，并且不会有乱码。 


GB18030 

　　全称是《信息交换用汉字编码字符集》，是我国的强制标准，它可能是单字节、双字节或者四字节编码，它的编码与 GB2312 编码兼容，

这个虽然是国家标准，但是实际应用系统中使用的并不广泛。 

 

UTF-16 
　　说到 UTF 必须要提到 Unicode（Universal Code 统一码），ISO 试图想创建一个全新的超语言字典，世界上所有的语言都可以通过这本字典来相互翻译。

可想而知这个字典是多么的复杂，关于 Unicode 的详细规范可以参考相应文档。Unicode 是 Java 和 XML 的基础，下面详细介绍 Unicode 在计算机中的存储形式。 

UTF-16 具体定义了 Unicode 字符在计算机中存取方法。UTF-16 用两个字节来表示 Unicode 转化格式，这个是定长的表示方法，不论什么字符都可以用两个字节表示，

两个字节是 16 个 bit，所以叫 UTF-16。UTF-16 表示字符非常方便，每两个字节表示一个字符，这个在字符串操作时就大大简化了操作，这也是 Java 以 UTF-16

作为内存的字符存储格式的一个很重要的原因。

 
UTF-8 
　　UTF-16 统一采用两个字节表示一个字符，虽然在表示上非常简单方便，但是也有其缺点，有很大一部分字符用一个字节就可以表示的现在要两个字节表示，

存储空间放大了一倍，在现在的网络带宽还非常有限的今天，这样会增大网络传输的流量，而且也没必要。而 UTF-8 采用了一种变长技术，每个编码区域有不同的字码长度。

不同类型的字符可以是由 1~6 个字节组成。 
　　

　　UTF-8 有以下编码规则： 
　　　　如果一个字节，最高位（第 8 位）为 0，表示这是一个 ASCII 字符（00 - 7F）。可见，所有 ASCII 编码已经是 UTF-8 了。 
　　　　如果一个字节，以 11 开头，连续的 1 的个数暗示这个字符的字节数，例如：110xxxxx 代表它是双字节 UTF-8 字符的首字节。 
　　　　如果一个字节，以 10 开始，表示它不是首字节，需要向前查找才能得到当前字符的首字节 

 

Java 中需要编码的场景 


　　前面描述了常见的几种编码格式，下面将介绍 Java 中如何处理对编码的支持，什么场合中需要编码。 

　　I/O 操作中存在的编码 

　　　　我们知道涉及到编码的地方一般都在字符到字节或者字节到字符的转换上，而需要这种转换的场景主要是在 I/O 的时候，这个 I/O 包括磁盘 I/O 和网络 I/O，

　　　　关于网络 I/O 部分在后面将主要以 Web 应用为例介绍。下图是 Java 中处理 I/O 问题的接口： 


                      
　　　　

　　　　Reader 类是 Java 的 I/O 中读字符的父类，而 InputStream 类是读字节的父类，InputStreamReader 类就是关联字节到字符的桥梁，它负责在 I/O 过程中处理读取字节到字符的转换，

　　　　而具体字节到字符的解码实现它由 StreamDecoder 去实现，在 StreamDecoder 解码过程中必须由用户指定 Charset 编码格式。值得注意的是如果你没有指定 Charset，

　　　　将使用本地环境中的默认字符集，例如在中文环境中将使用 GBK 编码。 


　　　　写的情况也是类似，字符的父类是 Writer，字节的父类是 OutputStream，通过 OutputStreamWriter 转换字符到字节。如下图所示： 


                    

　　　　同样 StreamEncoder 类负责将字符编码成字节，编码格式和默认编码规则与解码是一致的。 

　　　　如下面一段代码，实现了文件的读写功能： 

　　　　Java代码 
  1. String file = "c:/stream.txt";    
  2. String charset = "UTF-8";    
  3. // 写字符换转成字节流   
  4. FileOutputStream outputStream = new FileOutputStream(file);    
  5. OutputStreamWriter writer = new OutputStreamWriter(    
  6. outputStream, charset);    
  7. try {    
  8.    writer.write("这是要保存的中文字符");    
  9. } finally {    
  10.    writer.close();    
  11. }    
  12. // 读取字节转换成字符   
  13. FileInputStream inputStream = new FileInputStream(file);    
  14. InputStreamReader reader = new InputStreamReader(    
  15. inputStream, charset);    
  16. StringBuffer buffer = new StringBuffer();    
  17. char[] buf = new char[64];    
  18. int count = 0;    
  19. try {    
  20.    while ((count = reader.read(buf)) != -1) {    
  21.        buffer.append(buffer, 0, count);    
  22.    }    
  23. } finally {    
  24.    reader.close();    
  25. }   


　　　　在我们的应用程序中涉及到 I/O 操作时只要注意指定统一的编解码 Charset 字符集，一般不会出现乱码问题，有些应用程序如果不注意指定字符编码，

　　　　中文环境中取操作系统默认编码，如果编解码都在中文环境中，通常也没问题，但是还是强烈的不建议使用操作系统的默认编码，因为这样，

　　　　你的应用程序的编码格式就和运行环境绑定起来了，在跨环境下很可能出现乱码问题。 

　　

　　内存中操作中的编码 

　　　　在 Java 开发中除了 I/O 涉及到编码外，最常用的应该就是在内存中进行字符到字节的数据类型的转换，Java 中用 String 表示字符串，

　　所以 String 类就提供转换到字节的方法，也支持将字节转换为字符串的构造函数。如下代码示例： 

　　Java代码 
  1. String s = "这是一段中文字符串";    
  2.  byte[] b = s.getBytes("UTF-8");    
  3.  String n = new String(b,"UTF-8");   


　　另外一个是已经被被废弃的 ByteToCharConverter 和 CharToByteConverter 类，它们分别提供了 convertAll 方法可以实现 byte[] 和 char[] 的互转。如下代码所示： 

　　Java代码 
  1. ByteToCharConverter charConverter = ByteToCharConverter.getConverter("UTF-8");    
  2. char c[] = charConverter.convertAll(byteArray);    
  3. CharToByteConverter byteConverter = CharToByteConverter.getConverter("UTF-8");    
  4. byte[] b = byteConverter.convertAll(c);   


　　这两个类已经被 Charset 类取代，Charset 提供 encode 与 decode 分别对应 char[] 到 byte[] 的编码和 byte[] 到 char[] 的解码。如下代码所示： 

　　Java代码 
  1. Charset charset = Charset.forName("UTF-8");    
  2.  ByteBuffer byteBuffer = charset.encode(string);    
  3.  CharBuffer charBuffer = charset.decode(byteBuffer);   


　　　　编码与解码都在一个类中完成，通过 forName 设置编解码字符集，这样更容易统一编码格式，比 ByteToCharConverter 和 CharToByteConverter 类更方便。 　

　　Java 中还有一个 ByteBuffer 类，它提供一种 char 和 byte 之间的软转换，它们之间转换不需要编码与解码，只是把一个 16bit 的 char 格式，拆分成为 2 个 8bit 的 byte 表示，

　　它们的实际值并没有被修改，仅仅是数据的类型做了转换。如下代码所以： 

　　Java代码 
  1. ByteBuffer heapByteBuffer = ByteBuffer.allocate(1024);    
  2.  ByteBuffer byteBuffer = heapByteBuffer.putChar(c);   


　　以上这些提供字符和字节之间的相互转换只要我们设置编解码格式统一一般都不会出现问题。 
　　

　　Java 中如何编解码 

　　　　前面介绍了几种常见的编码格式，这里将以实际例子介绍 Java 中如何实现编码及解码，下面我们以“I am 君山”这个字符串为例介绍 Java 中如何把它以 ISO-8859-1、

　　GB2312、GBK、UTF-16、UTF-8 编码格式进行编码的。 

　　Java代码 
  1. public static void encode() {    
  2.         String name = "I am 君山";    
  3.         toHex(name.toCharArray());    
  4.         try {    
  5.             byte[] iso8859 = name.getBytes("ISO-8859-1");    
  6.             toHex(iso8859);    
  7.             byte[] gb2312 = name.getBytes("GB2312");    
  8.             toHex(gb2312);    
  9.             byte[] gbk = name.getBytes("GBK");    
  10.             toHex(gbk);    
  11.             byte[] utf16 = name.getBytes("UTF-16");    
  12.             toHex(utf16);    
  13.             byte[] utf8 = name.getBytes("UTF-8");    
  14.             toHex(utf8);    
  15.         } catch (UnsupportedEncodingException e) {    
  16.             e.printStackTrace();    
  17.         }    
  18.  }   


　　　　我们把 name 字符串按照前面说的几种编码格式进行编码转化成 byte 数组，然后以 16 进制输出，我们先看一下 Java 是如何进行编码的。 
　　下面是 Java 中编码需要用到的类图 

　　图 1. Java 编码类图 


       
　　　　

　　　　

 

　　　　        首先根据指定的 charsetName 通过 Charset.forName(charsetName) 设置 Charset 类，然后根据 Charset 创建 CharsetEncoder 对象，

　　　　再调用 CharsetEncoder.encode 对字符串进行编码，不同的编码类型都会对应到一个类中，实际的编码过程是在这些类中完成的。下面是 String. getBytes(charsetName) 编码过程的时序图 

　　　　图 2.Java 编码时序图 
         

　　　　 


　　　　从上图可以看出根据 charsetName 找到 Charset 类，然后根据这个字符集编码生成 CharsetEncoder，这个类是所有字符编码的父类，

　　针对不同的字符编码集在其子类中定义了如何实现编码，有了 CharsetEncoder 对象后就可以调用 encode 方法去实现编码了。

　　这个是 String.getBytes 编码方法，其它的如 StreamEncoder 中也是类似的方式。下面看看不同的字符集是如何将前面的字符串编码成 byte 数组的？ 

　　如字符串“I am 君山”的 char 数组为 49 20 61 6d 20 541b 5c71，下面把它按照不同的编码格式转化成相应的字节。 

　　按照 ISO-8859-1 编码 
　　字符串“I am 君山”用 ISO-8859-1 编码，下面是编码结果： 


         

 

　　　　从上图看出 7 个 char 字符经过 ISO-8859-1 编码转变成 7 个 byte 数组，ISO-8859-1 是单字节编码，中文“君山”被转化成值是 3f 的 byte。3f 也就是“？”字符，

　　所以经常会出现中文变成“？”很可能就是错误的使用了 ISO-8859-1 这个编码导致的。中文字符经过 ISO-8859-1 编码会丢失信息，通常我们称之为“黑洞”，它会把不认识的字符吸收掉。

　　由于现在大部分基础的 Java 框架或系统默认的字符集编码都是 ISO-8859-1，所以很容易出现乱码问题，后面将会分析不同的乱码形式是怎么出现的。 

　　按照 GB2312 编码 

　　　　字符串“I am 君山”用 GB2312 编码，下面是编码结果： 


          

　　GB2312 对应的 Charset 是 sun.nio.cs.ext. EUC_CN 而对应的 CharsetDecoder 编码类是 sun.nio.cs.ext. DoubleByte，GB2312 字符集有一个 char 到 byte 的码表，

　　不同的字符编码就是查这个码表找到与每个字符的对应的字节，然后拼装成 byte 数组。查表的规则如下： 

　　Java代码 
  1. c2b[c2bIndex[char >> 8] + (char & 0xff)]   


　　如果查到的码位值大于 oxff 则是双字节，否则是单字节。双字节高 8 位作为第一个字节，低 8 位作为第二个字节，如下代码所示： 

　　Java代码 
  1. if (bb > 0xff) {    // DoubleByte    
  2.             if (dl - dp < 2)    
  3.                 return CoderResult.OVERFLOW;    
  4.             da[dp++] = (byte) (bb >> 8);    
  5.             da[dp++] = (byte) bb;    
  6.  } else {                      // SingleByte    
  7.             if (dl - dp < 1)    
  8.                 return CoderResult.OVERFLOW;    
  9.             da[dp++] = (byte) bb;    
  10.  }   


　　　　从上图可以看出前 5 个字符经过编码后仍然是 5 个字节，而汉字被编码成双字节，在第一节中介绍到 GB2312 只支持 6763 个汉字，所以并不是所有汉字都能够用 GB2312 编码。 
　　

　　按照 GBK 编码 

　　　　字符串“I am 君山”用 GBK 编码，下面是编码结果： 
              
　　　　你可能已经发现上图与 GB2312 编码的结果是一样的，没错 GBK 与 GB2312 编码结果是一样的，由此可以得出 GBK 编码是兼容 GB2312 编码的，

　　它们的编码算法也是一样的。不同的是它们的码表长度不一样，GBK 包含的汉字字符更多。所以只要是经过 GB2312 编码的汉字都可以用 GBK 进行解码，反过来则不然。 

　　

　　按照 UTF-16 编码 

　　　　字符串“I am 君山”用 UTF-16 编码，下面是编码结果： 
             
　　　　用 UTF-16 编码将 char 数组放大了一倍，单字节范围内的字符，在高位补 0 变成两个字节，中文字符也变成两个字节。从 UTF-16 编码规则来看，

　　仅仅将字符的高位和地位进行拆分变成两个字节。特点是编码效率非常高，规则很简单，由于不同处理器对 2 字节处理方式不同，Big-endian（高位字节在前，低位字节在后）

　　或 Little-endian（低位字节在前，高位字节在后）编码，所以在对一串字符串进行编码是需要指明到底是 Big-endian 还是 Little-endian，所以前面有两个字节用来保存

　　 BYTE_ORDER_MARK 值，UTF-16 是用定长 16 位（2 字节）来表示的 UCS-2 或 Unicode 转换格式，通过代理对来访问 BMP 之外的字符编码。 

　　

　　按照 UTF-8 编码 

　　　　字符串“I am 君山”用 UTF-8 编码，下面是编码结果： 
           

　　UTF-16 虽然编码效率很高，但是对单字节范围内字符也放大了一倍，这无形也浪费了存储空间，另外 UTF-16 采用顺序编码，不能对单个字符的编码值进行校验，

　　如果中间的一个字符码值损坏，后面的所有码值都将受影响。而 UTF-8 这些问题都不存在，UTF-8 对单字节范围内字符仍然用一个字节表示，对汉字采用三个字节表示。它的编码规则如下： 

Java代码 
  1. private CoderResult encodeArrayLoop(CharBuffer src,    
  2.  ByteBuffer dst){    
  3.             char[] sa = src.array();    
  4.             int sp = src.arrayOffset() + src.position();    
  5.             int sl = src.arrayOffset() + src.limit();    
  6.             byte[] da = dst.array();    
  7.             int dp = dst.arrayOffset() + dst.position();    
  8.             int dl = dst.arrayOffset() + dst.limit();    
  9.             int dlASCII = dp + Math.min(sl - sp, dl - dp);    
  10.             // ASCII only loop    
  11.             while (dp < dlASCII && sa[sp] < \'\u0080\')    
  12.                 da[dp++] = (byte) sa[sp++];    
  13.             while (sp < sl) {    
  14.                 char c = sa[sp];    
  15.                 if (c < 0x80) {    
  16.                     // Have at most seven bits    
  17.                     if (dp >= dl)    
  18.                         return overflow(src, sp, dst, dp);    
  19.                     da[dp++] = (byte)c;    
  20.                 } else if (c < 0x800) {    
  21.                     // 2 bytes, 11 bits    
  22.                     if (dl - dp < 2)    
  23.                         return overflow(src, sp, dst, dp);    
  24.                     da[dp++] = (byte)(0xc0 | (c >> 6));    
  25.                     da[dp++] = (byte)(0x80 | (c & 0x3f));    
  26.                 } else if (Character.isSurrogate(c)) {    
  27.                     // Have a surrogate pair    
  28.                     if (sgp == null)    
  29.                         sgp = new Surrogate.Parser();    
  30.                     int uc = sgp.parse(c, sa, sp, sl);    
  31.                     if (uc < 0) {    
  32.                         updatePositions(src, sp, dst, dp);    
  33.                         return sgp.error();    
  34.                     }    
  35.                     if (dl - dp < 4)    
  36.                         return overflow(src, sp, dst, dp);    
  37.                     da[dp++] = (byte)(0xf0 | ((uc >> 18)));    
  38.                     da[dp++] = (byte)(0x80 | ((uc >> 12) & 0x3f));    
  39.                     da[dp++] = (byte)(0x80 | ((uc >>  6) & 0x3f));    
  40.                     da[dp++] = (byte)(0x80 | (uc & 0x3f));    
  41.                     sp++;  // 2 chars    
  42.                 } else {    
  43.                     // 3 bytes, 16 bits    
  44.                     if (dl - dp < 3)    
  45.                         return overflow(src, sp, dst, dp);    
  46.                     da[dp++] = (byte)(0xe0 | ((c >> 12)));    
  47.                     da[dp++] = (byte)(0x80 | ((c >>  6) & 0x3f));    
  48.                     da[dp++] = (byte)(0x80 | (c & 0x3f));    
  49.                 }    
  50.                 sp++;    
  51.             }    
  52.             updatePositions(src, sp, dst, dp);    
  53.             return CoderResult.UNDERFLOW;    
  54.  }   


　　　　UTF-8 编码与 GBK 和 GB2312 不同，不用查码表，所以在编码效率上 UTF-8 的效率会更好，所以在存储中文字符时 UTF-8 编码比较理想。 

几种编码格式的比较 

　　对中文字符后面四种编码格式都能处理，GB2312 与 GBK 编码规则类似，但是 GBK 范围更大，它能处理所有汉字字符，所以 GB2312 与 GBK 比较应该选择 GBK。

UTF-16 与 UTF-8 都是处理 Unicode 编码，它们的编码规则不太相同，相对来说 UTF-16 编码效率最高，字符到字节相互转换更简单，进行字符串操作也更好。

它适合在本地磁盘和内存之间使用，可以进行字符和字节之间快速切换，如 Java 的内存编码就是采用 UTF-16 编码。但是它不适合在网络之间传输，因为网络传输容易损坏字节流，

一旦字节流损坏将很难恢复，相比较而言 UTF-8 更适合网络传输，对 ASCII 字符采用单字节存储，另外单个字符损坏也不会影响后面其它字符，在编码效率上介于 GBK 和 UTF-16 之间，

所以 UTF-8 在编码效率上和编码安全性上做了平衡，是理想的中文编码方式。 


Java Web 涉及到的编码 

　　对于使用中文来说，有 I/O 的地方就会涉及到编码，前面已经提到了 I/O 操作会引起编码，而大部分 I/O 引起的乱码都是网络 I/O，因为现在几乎所有的应用程序都涉及到网络操作，

而数据经过网络传输都是以字节为单位的，所以所有的数据都必须能够被序列化为字节。在 Java 中数据被序列化必须继承 Serializable 接口。 

　　这里有一个问题，你是否认真考虑过一段文本它的实际大小应该怎么计算，我曾经碰到过一个问题：就是要想办法压缩 Cookie 大小，减少网络传输量，当时有选择不同的压缩算法，

发现压缩后字符数是减少了，但是并没有减少字节数。所谓的压缩只是将多个单字节字符通过编码转变成一个多字节字符。减少的是 String.length()，而并没有减少最终的字节数。

例如将“ab”两个字符通过某种编码转变成一个奇怪的字符，虽然字符数从两个变成一个，但是如果采用 UTF-8 编码这个奇怪的字符最后经过编码可能又会变成三个或更多的字节。

同样的道理比如整型数字 1234567 如果当成字符来存储，采用 UTF-8 来编码占用 7 个 byte，采用 UTF-16 编码将会占用 14 个 byte，但是把它当成 int 型数字来存储只需要 4 个 byte 来存储。

所以看一段文本的大小，看字符本身的长度是没有意义的，即使是一样的字符采用不同的编码最终存储的大小也会不同，所以从字符到字节一定要看编码类型。 

　　另外一个问题，你是否考虑过，当我们在电脑中某个文本编辑器里输入某个汉字时，它到底是怎么表示的？我们知道，计算机里所有的信息都是以 01 表示的，那么一个汉字，

它到底是多少个 0 和 1 呢？我们能够看到的汉字都是以字符形式出现的，例如在 Java 中“淘宝”两个字符，它在计算机中的数值 10 进制是 28120 和 23453，16 进制是 6bd8 和 5d9d，

也就是这两个字符是由这两个数字唯一表示的。Java 中一个 char 是 16 个 bit 相当于两个字节，所以两个汉字用 char 表示在内存中占用相当于四个字节的空间。 


这两个问题搞清楚后，我们看一下 Java Web 中那些地方可能会存在编码转换？ 

　　用户从浏览器端发起一个 HTTP 请求，需要存在编码的地方是 URL、Cookie、Parameter。服务器端接受到 HTTP 请求后要解析 HTTP 协议，其中 URI、Cookie 和 POST 表单参数需要解码，

服务器端可能还需要读取数据库中的数据，本地或网络中其它地方的文本文件，这些数据都可能存在编码问题，当 Servlet 处理完所有请求的数据后，需要将这些数据再编码通过 Socket 发送到用

户请求的浏览器里，再经过浏览器解码成为文本。这些过程如下图所示： 
 

　　 
　　

　　如上图所示一次 HTTP 请求设计到很多地方需要编解码，它们编解码的规则是什么？下面将会重点阐述一下： 

URL 的编解码 

　　用户提交一个 URL，这个 URL 中可能存在中文，因此需要编码，如何对这个 URL 进行编码？根据什么规则来编码？有如何来解码？如下图一个 URL： 

　　图 4.URL 的几个组成部分 
             

　　上图中以 Tomcat 作为 Servlet Engine 为例，它们分别对应到下面这些配置文件中： 

Port 对应在 Tomcat 的 <Connector port="8080"/> 中配置，而 Context Path 在 <Context path="/examples"/> 中配置，Servlet Path 在 Web 应用的 web.xml 中的 
　　<servlet-mapping> 
       　　<servlet-name>junshanExample</servlet-name> 
        　　<url-pattern>/servlets/servlet/*</url-pattern> 
　　</servlet-mapping> 

　　<url-pattern> 中配置，PathInfo 是我们请求的具体的 Servlet，QueryString 是要传递的参数，注意这里是在浏览器里直接输入 URL 所以是通过 Get 方法请求的，

如果是 POST 方法请求的话，QueryString 将通过表单方式提交到服务器端，这个将在后面再介绍。 


上图中 PathInfo 和 QueryString 出现了中文，当我们在浏览器中直接输入这个 URL 时，在浏览器端和服务端会如何编码和解析这个 URL 呢？为了验证浏览器是怎么编码 URL

的我们选择 FireFox 浏览器并通过 HTTPFox 插件观察我们请求的 URL 的实际的内容，以下是 URL：HTTP://localhost:8080/examples/servlets/servlet/ 君山 ?author= 君山在中文 FireFox3.6.12 的测试结果 


 

相关文章