public class Encode {
 
 /*
  * 对应javascript的escape()函数, 加码后的串可直接使用javascript的unescape()进行解码
  */
 public static String escape(String src) {
  int i;
  char j;
  StringBuffer tmp = new StringBuffer();
  tmp.ensureCapacity(src.length() * 6);
  for (i = 0; i < src.length(); i++) {
   j = src.charAt(i);
   if (Character.isDigit(j) || Character.isLowerCase(j)
     || Character.isUpperCase(j))
    tmp.append(j);
   else if (j < 256) {
    tmp.append("%");
    if (j < 16)
     tmp.append("0");
    tmp.append(Integer.toString(j, 16));
   } else {
    tmp.append("%u");
    tmp.append(Integer.toString(j, 16));
   }
  }
  return tmp.toString();
 }

 /*
  * 对应javascript的unescape()函数, 可对javascript的escape()进行解码
  */
 public static String unescape(String src) {
  StringBuffer tmp = new StringBuffer();
  tmp.ensureCapacity(src.length());
  int lastPos = 0, pos = 0;
  char ch;
  while (lastPos < src.length()) {
   pos = src.indexOf("%", lastPos);
   if (pos == lastPos) {
    if (src.charAt(pos + 1) == 'u') {
     ch = (char) Integer.parseInt(src
       .substring(pos + 2, pos + 6), 16);
     tmp.append(ch);
     lastPos = pos + 6;
    } else {
     ch = (char) Integer.parseInt(src
       .substring(pos + 1, pos + 3), 16);
     tmp.append(ch);
     lastPos = pos + 3;
    }
   } else {
    if (pos == -1) {
     tmp.append(src.substring(lastPos));
     lastPos = src.length();
    } else {
     tmp.append(src.substring(lastPos, pos));
     lastPos = pos;
    }
   }
  }
  return tmp.toString();
 }

}

抽象类Buffer是java.nio包支持缓冲区的基础。 Buffer 的工作方式就象内存中用于读写基本数据类型的 RandomAccessFile 。象 RandomAccessFile 一样，使用 Buffer ，所执行的下一个操作（读／写）在当前某个位置发生。执行读／写操作中的任一个都会改变那个位置，所以在写操作之后进行读操作不会读到刚才所写的内容，而会读到刚才所写内容之后的数据。 Buffer 提供了四个指示方法，用于访问线性结构（从最高值到最低值）：

capacity() ：表明缓冲区的容量大小, 一旦确定了大小, 将不能再改变;
limit() ：告诉您到目前为止已经往缓冲区填了多少字节，或者让您用 :limit(int newLimit) 来改变这个限制
position() ：告诉您当前的位置，以执行下一个读／写操作
mark() ：为了稍后用 reset() 进行重新设置而记住某个位置
flip() ：交换限制指针和位置指针，然后将位置置为 0，并废弃已经做的mark标记

缓冲区的基本操作是读 get() 和写 put() ；然而，这些方法在子类中都是针对每种数据类型的特定方法。为了说明这一情况，让我们研究一个简单示例，该示例演示了从同一个缓冲区读和写一个字符。在清单 1 中， flip() 方法交换限制和位置，然后将位置置为 0，并废弃标记，让您读刚才所写的数据：

清单 1. 读／写示例
import java.nio.*;
...
CharBuffer buff = ...;
buff.put('A');
buff.flip();
char c = buff.get();
System.out.println("An A: " + c);
 

现在让我们研究一些具体的 Buffer 子类。

缓冲区类型

Merlin 具有 7 种特定的 Buffer 类型，每种类型对应着一个基本数据类型（不包括 boolean）：

ByteBuffer       //存放任何除boolean类型外的其他基本类型
CharBuffer       //存放char
DoubleBuffer     //存放double
FloatBuffer      //存放float
IntBuffer        //存放int
LongBuffer       //存放long
ShortBuffer      //存放short

在本文后面，我将讨论第 8 种类型 MappedByteBuffer ，它用于内存映射文件。如果您必须使用的类型不是这些基本类型，则可以先从 ByteBuffer 获得字节类型，然后将其转换成 Object 或其它任何类型。


创建缓冲区
一共有两种类型的缓冲区，直接缓冲区和非直接缓冲区。

在创建缓冲区时，可以要求创建直接缓冲区，创建直接缓冲区的成本要比创建间接缓冲区高，但这可以使运行时环境直接在该缓冲区上进行较快的本机 I/O 操作。因为创建直接缓冲区所增加的成本，所以直接缓冲区只用于长生存期的缓冲区，而不用于短生存期、一次性且用完就丢弃的缓冲区。而且，只能在 ByteBuffer 这个级别上创建直接缓冲区，如果希望使用其它类型，则必须将 Buffer 转换成更具体的类型。

判断一个缓冲区是否是直接缓冲区，可以调用isDirect()方法。

有三种方式来获取一个缓冲区的对象：
a. 调用allocate()或者allocateDirect()方法直接分配，其中allocateDirect()返回的是直接缓冲区。
b. 包装一个数组，如：
      byte[] b = new byte[1024];
      ByteBuffer bb = ByteBuffer.wrap(b);
c. 内存映射，即调用FileChannel的map()方法。

缓冲区基本属性
这几个属性是每个缓冲区都有的并且是常用的操作。
a. 容量(capacity),缓冲区大小
b. 限制(limit),第一个不应被读取或写入的字节的索引，总是小于容量。
c. 位置(position)，下一个被读取或写入的字节的索引，总是小于限制。
d. clear()方法：设置limit为capacity，position为0。
e. filp()方法：设置limit为当前position，然后设置position为0。
f. rewind()方法：保持limit不变，设置position为0。

缓冲区数据操作
操作包括了读取和写入数据两种。
读取数据使用get()及其系列方法，除boolean外，每一种类型包括了对应的get()方法，如getInt(),getChar()等，get()方法用来读取字节，支持相对和绝对索引两种方式。
写入数据使用put()及其系列方法，和get()方法是对应的。

package nio;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class BufferDemo ...{

    
    public static void main(String[] args) throws Exception...{
        //分配一个非直接缓冲区
        ByteBuffer bb = ByteBuffer.allocate(100);
        //向缓冲区写入0到100的字节制
        for(int i = 0; i <100; i++)...{
            byte b = (byte) (Math.random() * 100);
            bb.put(b);
        }
        
        System.out.println("写入文件前的缓冲区数据");
        bb.flip();
        while(bb.hasRemaining())
            System.out.print(bb.get() + " ");
        System.out.println();
        
        //获取一个关联到文件buffer.txt的信道
        FileChannel fc = new FileOutputStream("buffer.txt").getChannel();
        //将缓冲区数据写到文件中
        bb.flip();
        fc.write(bb);
        //防止缓存
        fc.force(true);
        //关闭信道
        fc.close();
        bb = null;
        fc = null;
        
        //下面从文件中读取数据
        fc = new FileInputStream("buffer.txt").getChannel();
        ByteBuffer bb2 = ByteBuffer.allocate((int) fc.size());
        fc.read(bb2);
        System.out.println("从文件读取的缓冲区数据");
        bb2.flip();
        while(bb2.hasRemaining())
            System.out.print(bb2.get() + " ");
        System.out.println();
        fc.close();
        bb2 = null;
        fc = null;
        

    }

}

内存映射文件

第 8 种 Buffer 类型 MappedByteBuffer 只是一种特殊的 ByteBuffer 。 MappedByteBuffer 将文件所在区域直接映射到内存。通常，该区域包含整个文件，但也可以只映射部分文件。所以，必须指定要映射文件的哪部分。而且，与其它 Buffer 对象一样，这里没有构造函数；必须让 java.nio.channels.FileChannel 的 map() 方法来获取 MappedByteBuffer 。此外，无需过多涉及通道就可以用 getChannel() 方法从 FileInputStream 或 FileOutputStream 获取 FileChannel 。通过从命令行传入文件名来读取文本文件的内容，清单 4 显示了 MappedByteBuffer ：

清单 4. 读取内存映射文本文件
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
public class ReadFileBuff {
  public static void main(String args[]) throws IOException {
     if (args.length != 0) {
      String filename = args[0];
      FileInputStream fis = new FileInputStream(filename);
      FileChannel channel = fis.getChannel();
      int length = (int)channel.size();
      MappedByteBuffer byteBuffer =
        channel.map(FileChannel.MapMode.READ_ONLY, 0, length);
      Charset charset = Charset.forName("ISO-8859-1");
      CharsetDecoder decoder = charset.newDecoder();
      CharBuffer charBuffer = decoder.decode(byteBuffer);
      for (int i=0, n=charBuffer.length(); i<n; i++) {
        System.out.print(charBuffer.get());
      }
    }
  }
}

1. 左移操作: x << n
   x可以是byte, short, char, int, long基本类型, n(位移量)只能是int型
   
   编译器的执行步骤:
   1) 如果x是byte, short, char类型, 则将x提升为int;
   2) 如果x是byte, short, char, int类型, 则n被重新赋值(过程是:取n的补码的低5位再转成十进制的int值,相当对n取32模: n=n%32);
      如果x是long型, 则n被重新赋值(过程是:取n的补码的低6位再转成十进制的int值,相当对n取64模: n=n%64);
      (因为int类型为4个字节,即32位,移动32位将没有任何意义.对于long则是模64)
   3) 对x左移n个位数, 整个表达式产生一个新值(x的值不变);
2. <<是左移符号,列x<<1,就是x的内容左移一位(x的内容并不改变)
3. >>是带符号位的右移符号,x>>1就是x的内容右移一位,如果开头是1则补1,是0责补0,(x的内容并不改变).
4. >>>是不带符号位的右移,x>>>1就是x的内容右移一位,开头补0(x的内容并不改变)

  //再运行getXmlXPP3()
  bt = System.currentTimeMillis();
  String s1 =getXmlXPP3("xml/test.xml");
  if(log.isDebugEnabled()){
   log.debug("\ngetXmlXPP3() use time: " + (System.currentTimeMillis() - bt) + " millis\n");
  }
  
  
 }
 
 public static String getXmlSAX(String xmlFile){
  String result = "";
  try {
   SAXReader reader = new SAXReader();
   Document document = reader.read(new File(xmlFile));
   result = document.asXML();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }
 
 public static String getXmlXPP3(String xmlFile){
  String result = "";
  try {
   XPP3Reader reader = new XPP3Reader();
   Document document = reader.read(new File(xmlFile));
   result = document.asXML();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }

 
}

有没有这一句"Document doc = DocumentHelper.createDocument()",对性能的影响很大,特别是对大xml文件(尽管并没有使用doc)

另外， getXmlXSAX()和getXmlXPP3()运行的先后次序对性能的影响也很大！

测试：
    在我的机器上，对一个100k左右的XML文件进行多次测试后的均值结果为：

    getXmlXPP3() use time: 265 millis
    ...
    getXmlXSAX() use time: 359 millis
    ...

结论：
    通过比较，在读取XML文件上，XPP3略为优于SAX！


注意：

要运行例子，classpath需包含：
dom4j-1.6.1.jar
jaxen-1.1-beta-10.jar
log4j-1.2.9.jar
pull-parser-2.1.10.jar
xpp3-1.1.4c.jar


参考：
dom4j :  http://www.dom4j.org/
XPP   :  http://www.extreme.indiana.edu/xgws/xsoap/xpp/

正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。模式描述在搜索文本时要匹配的一个或多个字符串。

正则表达式示例
 
表达式  匹配 
/^\s*$/
 匹配空行。
 
/\d{2}-\d{5}/
 验证由两位数字、一个连字符再加 5 位数字组成的 ID 号。
 
/<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*\/\1\s*>/
 匹配 HTML 标记。
 

下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为：

 
字符  说明 
\
 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，“n”匹配字符“n”。“\n”匹配换行符。序列“\\”匹配“\”，“\(”匹配“(”。
 
^
 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与“\n”或“\r”之后的位置匹配。
 
$
 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与“\n”或“\r”之前的位置匹配。
 
*
 零次或多次匹配前面的字符或子表达式。例如，zo* 匹配“z”和“zoo”。* 等效于 {0,}。
 
+
 一次或多次匹配前面的字符或子表达式。例如，“zo+”与“zo”和“zoo”匹配，但与“z”不匹配。+ 等效于 {1,}。
 
?
 零次或一次匹配前面的字符或子表达式。例如，“do(es)?”匹配“do”或“does”中的“do”。? 等效于 {0,1}。
 
{n}
 n 是非负整数。正好匹配 n 次。例如，“o{2}”与“Bob”中的“o”不匹配，但与“food”中的两个“o”匹配。
 
{n,}
 n 是非负整数。至少匹配 n 次。例如，“o{2,}”不匹配“Bob”中的“o”，而匹配“foooood”中的所有 o。“o{1,}”等效于“o+”。“o{0,}”等效于“o*”。
 
{n,m}
 M 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，“o{1,3}”匹配“fooooood”中的头三个 o。'o{0,1}' 等效于 'o?'。注意：您不能将空格插入逗号和数字之间。
 
?
 当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是“非贪心的”。“非贪心的”模式匹配搜索到的、尽可能短的字符串，而默认的“贪心的”模式匹配搜索到的、尽可能长的字符串。例如，在字符串“oooo”中，“o+?”只匹配单个“o”，而“o+”匹配所有“o”。
 
.
 匹配除“\n”之外的任何单个字符。若要匹配包括“\n”在内的任意字符，请使用诸如“[\s\S]”之类的模式。
 
(pattern)
 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果“匹配”集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用“\(”或者“\)”。
 
(?:pattern)
 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用“or”字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。
 
(?=pattern)
 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配“Windows 2000”中的“Windows”，但不匹配“Windows 3.1”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
 
(?!pattern)
 执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配“Windows 3.1”中的 “Windows”，但不匹配“Windows 2000”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
 
x|y
 匹配 x 或 y。例如，'z|food' 匹配“z”或“food”。'(z|f)ood' 匹配“zood”或“food”。
 
[xyz]
 字符集。匹配包含的任一字符。例如，“[abc]”匹配“plain”中的“a”。
 
[^xyz]
 反向字符集。匹配未包含的任何字符。例如，“[^abc]”匹配“plain”中的“p”。
 
[a-z]
 字符范围。匹配指定范围内的任何字符。例如，“[a-z]”匹配“a”到“z”范围内的任何小写字母。
 
[^a-z]
 反向范围字符。匹配不在指定的范围内的任何字符。例如，“[^a-z]”匹配任何不在“a”到“z”范围内的任何字符。
 
\b
 匹配一个字边界，即字与空格间的位置。例如，“er\b”匹配“never”中的“er”，但不匹配“verb”中的“er”。
 
\B
 非字边界匹配。“er\B”匹配“verb”中的“er”，但不匹配“never”中的“er”。
 
\cx
 匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是“c”字符本身。
 
\d
 数字字符匹配。等效于 [0-9]。
 
\D
 非数字字符匹配。等效于 [^0-9]。
 
\f
 换页符匹配。等效于 \x0c 和 \cL。
 
\n
 换行符匹配。等效于 \x0a 和 \cJ。
 
\r
 匹配一个回车符。等效于 \x0d 和 \cM。
 
\s
 匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
 
\S
 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
 
\t
 制表符匹配。与 \x09 和 \cI 等效。
 
\v
 垂直制表符匹配。与 \x0b 和 \cK 等效。
 
\w
 匹配任何字类字符，包括下划线。与“[A-Za-z0-9_]”等效。
 
\W
 与任何非单词字符匹配。与“[^A-Za-z0-9_]”等效。
 
\xn
 匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，“\x41”匹配“A”。“\x041”与“\x04”&“1”等效。允许在正则表达式中使用 ASCII 代码。
 
\num
 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，“(.)\1”匹配两个连续的相同字符。
 
\n
 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
 
\nm
 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
 
\nml
 当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
 
\un
 匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (?)。
 

import java.io.File;
import java.io.StringReader;
import java.io.StringWriter;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;

import com.sun.org.apache.xml.internal.serialize.OutputFormat;
import com.sun.org.apache.xml.internal.serialize.XMLSerializer;

public class TestDom {
 
 //将xml串转换为document
 public static Document xml2Document(String xml) {
  Document doc = null;
  try {
   DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
   doc = builder.parse(new InputSource(new StringReader(xml)));
  } catch (Exception e) {
   e.printStackTrace();
  }
  return doc;
 }
 
 //将xml文件串转换为document
 public static Document xmlFile2Document(String xmlFile) {
  Document doc = null;
  try {
   DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
   doc = builder.parse(new File(xmlFile));
  } catch (Exception e) {
   e.printStackTrace();
  }
  return doc;
 }
 
 //删除命名空间: xmlns="..."
 public static String delNamespace(String xml) {
  String result = xml;
  try {
   Document doc = xml2Document(xml);
   Element root = doc.getDocumentElement();
   root.removeAttribute("xmlns");
   result = asXml(doc);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }
 
 //将doc转换为xml串
 public static String asXml(Document doc) {
  String strxml = "";
  try {
   OutputFormat format = new OutputFormat(doc);
   // format.setEncoding("UTF-8");
   StringWriter stringOut = new StringWriter();
   XMLSerializer serial = new XMLSerializer(stringOut, format);
   serial.asDOMSerializer();
   serial.serialize(doc.getDocumentElement());
   strxml = stringOut.toString();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return strxml;
 }
 
 //将node转换为xml串
 public static String asXml(Node node, Document doc) {
  String strxml = "";
  try {
   OutputFormat format = new OutputFormat(doc);
   // format.setEncoding("UTF-8");
   StringWriter stringOut = new StringWriter();
   XMLSerializer serial = new XMLSerializer(stringOut, format);
   serial.asDOMSerializer();
   serial.serialize((Element)node);
   strxml = stringOut.toString();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return strxml;
 }
}

1、使用JdbcTemplate的execute()方法执行SQL语句

JdbcTemplate将我们使用的JDBC的流程封装起来，包括了异常的捕捉、SQL的执行、查询结果的转换等等。spring大量使用Template Method模式来封装固定流程的动作，XXXTemplate等类别都是基于这种方式的实现。
除了大量使用Template Method来封装一些底层的操作细节，spring也大量使用callback方式类回调相关类别的方法以提供JDBC相关类别的功能，使传统的JDBC的使用者也能清楚了解spring所提供的相关封装类别方法的使用。

JDBC的PreparedStatement

在getUser(id)里面使用UserRowMapper

网上收集
org.springframework.jdbc.core.PreparedStatementCreator 返回预编译SQL 不能于Object[]一起用

问题描述
看下述 XML:
<catalog>
  <cd>
    <artist>Sufjan Stevens</artist>
    <title>Illinois</title>
    <src>http://www.sufjan.com/</src>
  </cd>
  <cd>
    <artist>Stoat</artist>
    <title>Future come and get me</title>
    <src>http://www.stoatmusic.com/</src>
  </cd>
  <cd>
    <artist>The White Stripes</artist>
    <title>Get behind me satan</title>
    <src>http://www.whitestripes.com/</src>
  </cd>
</catalog>

    你可以使用“//cd”来得到没有在任何命名空间中定义的“cd”节点。 

    现在让我们来改造这个 XML，让它的所有元素都属于 'http://www.edankert.com/examples/' 命名空间中。
 
    为了避免在每个不同的元素前都要加个前缀，我们在根元素上定义通常所说的缺省命名空间。改造后的 XML 如下：
 
<catalog xmlns=" http://www.edankert.com/examples/ ">
  <cd>
    <artist>Sufjan Stevens</artist>
    <title>Illinois</title>
    <src>http://www.sufjan.com/</src>
  </cd>
  <cd>
    <artist>Stoat</artist>
    <title>Future come and get me</title>
    <src>http://www.stoatmusic.com/</src>
  </cd>
  <cd>
    <artist>The White Stripes</artist>
    <title>Get behind me satan</title>
    <src>http://www.whitestripes.com/</src>
  </cd>
</catalog>

    当我们使用与上文相同的 XPath “//cd”，将得不到任何元素。这是因为指定的 XPath 返回的是所有不属于任何命名空间的“cd”节点，而本例中，所有的“cd”元素都属于缺省的命名空间“http://www.edankert.com/examples/”。

“前缀－命名空间”映射
    为了取出命名空间“http://www.edankert.com/examples/”中的所有“cd”元素，我们需要对 XPath 表达式做一些额外的工作。
 
    为了解决这个问题，XPath 规范允许我们使用 QName 来指定元素或者属性。QName 可以是元素的直接名称（形如“element”），或者包含一个前缀（形如“pre:element”）。这个前缀需要映射到一个命名空间的 URI 上。例如，如果把“pre”前缀映射到“http://www.edankert.com/test”上，则通过“pre:element”可以查找出属于命名空间“http://www.edankert.com/test”的所有 “element”元素。
 
    在本例中，我们把“edx”映射到“'http://www.edankert.com/examples/”命名空间上。通过 XPath“//edx:cd”就可以查找出属于“'http://www.edankert.com/examples/”命名空间的所有“cd”元素。 
 
    XPath 处理器允许设置“前缀－命名空间”的映射，但是，如何去映射，却要依赖于具体的实现。下文举例说明 Jaxen (JDOM/dom4j/XOM)、JAXP 以及 XSLT 中是如何进行“前缀－命名空间”的映射的。

Jaxen 和 Dom4J
    下述代码从文件系统读入一个 XML 文件到 org.dom4j.Document 对象中，并且在 Document 中查找属于“http://www.edankert.com/examples/”命名空间的所有“cd”元素。
 
try {
  SAXReader reader = new SAXReader();
  Document document = reader.read( "file:catalog.xml");
 
  HashMap map = new HashMap();
  map.put( "edx", " http://www.edankert.com/examples/ ");
 
  XPath xpath = new Dom4jXPath( "//edx:cd");
  xpath.setNamespaceContext( new SimpleNamespaceContext( map));
 
  List nodes = xpath.selectNodes( document);
 
  ...
 
} catch ( JaxenException e) { // An error occurred parsing or executing the XPath ... } catch ( DocumentException e) {
  // the document is not well-formed.
  ...
}
    第一步，创建一个 SAXReader，用来从文件系统中读取“catalog.xml”并创建一个特定于 Dom4j 的 Document 对象。

    第二步，对于所有 Jaxen 实现都一样，就是创建一个 HashMap 对象，用于保存“前缀－命名空间的 URI”的映射。
 
    为了能通过 Dom4j 使用 Jaxen 的 XPath 功能，需要创建一个与 Dom4j 相关的 XPath 对象：Dom4jXPath。创建方法是把 XPath 的表达式（即“//edx:cd”）传给 Dom4jXPath 的构造方法。
 
    现在，我们已经创建了 XPath 对象，接下来可以把“前缀－命名空间”的映射表传递给 XPath 引擎：把这个 HashMap 映射表用 SimpleNamespaceContext 包装起来。SimpleNamespaceContext 是 Jaxen 的 NamespaceContext 接口的默认实现类。
 
    最后一步就是调用 XPath 对象的 selectNodes() 方法进行查找。并把完整的 Dom4j  Document 对象作为参数传递进去。实际上，Document 中的任何结点都可以作为参数。

Jaxen 和 XOM
    XOM 是基于简单的 Java DOM APIs 之上的最新工具，它的设计初衷是提供简单和易学易用的接口。
 
try {
  Builder builder = new Builder();
  Document document = builder.build( "file:catalog.xml");
 
  HashMap map = new HashMap();
  map.put( "edx", " http://www.edankert.com/examples/ ");
 
  XPath xpath = new XOMXPath( "//edx:cd");
  xpath.setNamespaceContext( new SimpleNamespaceContext( map));
 
  List nodes = xpath.selectNodes( document);
 
  ...
 
} catch ( JaxenException e) { // An error occurred parsing or executing the XPath ... } catch ( IOException e) {
  // An error occurred opening the document
  ...
} catch ( ParsingException e) {
  // An error occurred parsing the document
  ...
}

 
    我们需要创建一个 Builder 对象，从文件系统中读取“catalog.xml”文件，并创建出与 XOM 相关的 Document 对象。
 
    下一步创建出包含了“前缀－命名空间”映射关系的 HashMap 对象。
 
    我们需要创建一个特定于 XOM 的 XPath 对象：XOMXPath。创建方法是把 XPath 表达式传递给构造方法，然后就可以通过 XOM 使用 Jaxen 的 XPath 功能了。
 
    创建完 XPath 对象后，同样，我们把“前缀－命名空间”的映射表用 SimpleNamespaceContext 对象封装后，传递给 XPath 引擎。
 
    最后调用 XPath 对象的“selectNodes()”方法进行查找，把 XOM Document 对象作为本方法的参数。
Jaxen 和 JDOM
    JDOM 是第一个提供简单的 XML 访问 API 的工具。
 
try {
  SAXBuilder builder = new SAXBuilder();
  Document document = builder.build( "file:catalog.xml");
 
  HashMap map = new HashMap();
  map.put( "edx", " http://www.edankert.com/examples/ ");
 
  XPath xpath = new JDOMXPath( "//edx:cd");
  xpath.setNamespaceContext( new SimpleNamespaceContext( map));
 
  List nodes = xpath.selectNodes( document);
 
  ...
 
} catch ( JaxenException e) { // An error occurred parsing or executing the XPath ... } catch ( IOException e) {
  // An error occurred opening the document
  ...
} catch ( JDOMException e) {
  // An error occurred parsing the document
  ...
}

 
    首先，通过 SAXBuilder 创建了一个特定于 JDom 的 Document 对象。
 
    接着创建一个特定于 JDOM 的 XPath 对象：JDOMXPath。
 
    然后，把“前缀－命名空间”的映射表（HashMap）用 SimpleNamespaceContext 对象封装起来，传递给 XPath 引擎。
 
    最后调用 XPath 对象的“selectNodes()”方法来进行查找，并把 JDOM 的 Document 对象作为本方法的输入参数。
JAXP XPathFactory
    从 1.3 版起， JAXP 还提供了一种在 XML Object Models 上进行查询的通用机制。
 
try {
 DocumentBuilderFactory domFactory =DocumentBuilderFactory.newInstance();
  domFactory.setNamespaceAware( true);
 
 DocumentBuilder builder = domFactory.newDocumentBuilder();Document document = builder.parse( new InputSource( "file:catalog.xml"));
 
 XPathFactory factory =XPathFactory.newInstance();
 XPath xpath = factory.newXPath();
  xpath.setNamespaceContext( new NamespaceContext() {
    public String getNamespaceURI(String prefix) {
      if ( prefix.equals( "edx")) {
        return " http://www.edankert.com/examples/ ";
      } else if ...
        ...
      }
     
      return XPathConstants.NULL_NS_URI;
    }
 
    public String getPrefix(String namespaceURI) {
      if ( namespaceURI.equals( " http://www.edankert.com/examples/ ")) {
        return "edx";
      } else if ...
        ...
      } 
   
      return null;
    }
 
    public Iterator getPrefixes(String namespaceURI) {
     ArrayList list = new ArrayList();
   
      if ( namespaceURI.equals( " http://www.edankert.com/examples/ ")) {
        list.add( "edx");
      } else if ...
        ...
      }
   
      return list.iterator();
    }
  });
 
 Object nodes = xpath.evaluate( "//edx:cd", document.getDocumentElement(),
                                XPathConstants.NODESET);
 
  ...
 
} catch (ParserConfigurationException e) {
  ...
} catch (XPathExpressionException e) {
  ...
} catch (SAXException e) {
  ...
} catch (IOException e) {
  ...
}

    首先用 JAXP 的 DocumentBuilderFactory 创建一个org.w3c.dom.Document 对象，确保启用了 namespace 处理功能。
 
    现在可以通过 XPathFactory 来创建 XPath 对象，并通过 XPath 对象对文档进行查询。
 
    为了创建“前缀－命名空间”映射并传递给 XPath 引擎，我们需要实现 NamespaceContext 接口，该接口目前还没有默认实现类。这就意味着要实现 getNamespaceURI、getPrefix 和getPrefixes 方法，并确保这些方法能返回正确的值，包括“xmlns”和“xml”前缀所对应的命名空间的 URI 值。
 
    把我们自己实现的 NamespaceContext 对象传递给 XPath 引擎后，就可以通过 evaluate 方法来查询 XPath 表达式所对应的元素：使用上文中提到的 XPath 表达式，并使用 Document 的根节点作为输入入参数，并接收一个 NodeList 对象作为返回结果。
XSLT
    XPath 设计的初衷是用于 XSLT。这也许能解释“为什么在 XSLT 中定义命名空间的前缀是一件很平常的事”（也许因为 XSLT 也是一个 XML 名词的缘故吧）。
 
<xsl:stylesheet version="1.1" xmlns:xsl=" http://www.w3.org/1999/XSL/Transform ">
  <xsl:template match="//edx:cd" xmlns:edx=" http://www.edankert.com/examples/ ">
    <xsl:apply-templates/>
  </xsl:template>
</xsl:stylesheet>
 
    只需要使用 XML 本身的机制，简单地为 edx 前缀赋予一个命名空间的 URI 值。
 
    通过与我们的 XPath 表达式“//edx:cd”相匹配的 xsl:template，能得到与上文其他例子相同的输出结果。

结束语
    为了在（缺省）命名空间上使用 XPath 表达式，我们需要指定一个“前缀－命名空间”映射。正如我们所看到的，具体使用什么样的前缀名称，是无关紧要的。
 
    同样的方法，也可以用于查询那些用其他前缀修饰的元素。这意味着上面的例子对下述 XML 也有效。下述 XML 没有使用缺省命名空间，而是使用了 examples 作命名空间的前缀：
 
<examples:catalog xmlns:examples=" http://www.edankert.com/examples/ ">
  <examples:cd>
    <examples:artist>Sufjan Stevens</examples:artist>
    <examples:title>Illinois</examples:title>
    <examples:src>http://www.sufjan.com/</examples:src>
  </examples:cd>
  <examples:cd>
    <examples:artist>Stoat</examples:artist>
    <examples:title>Future come and get me</examples:title>
    <examples:src>http://www.stoatmusic.com/</examples:src>
  </examples:cd>
  <examples:cd>
    <examples:artist>The White Stripes</examples:artist>
    <examples:title>Get behind me satan</examples:title>
    <examples:src>http://www.whitestripes.com/</examples:src>
  </examples:cd>
</examples:catalog>

 
    使用“//edx:cd”作为 XPath 表达式，使用与前文例子相同的“前缀－命名空间”映射，在这个 XML 上同样能查询出属于“http://www.edankert.com/examples/”命名空间的所有“cd”元素。
资源
Extensible Markup Language (XML) 1.0 (Third Edition)
http://www.w3.org/TR/REC-xml/
Namespaces in XML
http://www.w3.org/TR/REC-xml-names/
XML Path Language (XPath) Version 1.0
http://www.w3.org/TR/xpath
XSL Transformations (XSLT) Version 1.0
http://www.w3.org/TR/xslt
dom4j
http://www.dom4j.org/
XOM
http://www.xom.nu/
JDOM
http://www.jdom.org/
Jaxen
http://www.jaxen.org/
Java 5.0
http://java.sun.com/j2se/1.5.0/

  <!-- data base -->  
  <property file="${dir.web}/WEB-INF/config/jdbc.properties"/>  
  <property name="database.driver"   value="${jdbc.driverClassName}"/>
  <property name="database.url"      value="${jdbc.url}"/>
  <property name="database.username" value="${jdbc.username}"/>
  <property name="database.password" value="${jdbc.password}"/>

  <!-- the classpth of ant -->
  <path id="classpath">
    <fileset dir="${dir.lib}" includes="**/*.jar" />
    <pathelement path="${dir.classes}"/>
  </path>

  <!-- compile the src and test source code -->
  <target name="compile" description="Compile main source and test tree java files">
   <delete dir="${dir.classes}"/>   
   <mkdir dir="${dir.classes}"/>
    <javac srcdir="${dir.src}" destdir="${dir.classes}" debug="on">
      <classpath refid="classpath"/>
    </javac>
    <copy todir="${dir.classes}">
      <fileset dir="${dir.src}" includes="**/*.xml,**/*.properties">
          <!--exclude name="**/*.hbm.xml" /-->
      </fileset>
      <fileset dir="${dir.etc}" includes="**/*.properties"/>
    </copy>
  <native2ascii dest="${dir.classes}" src="${dir.etc}" encoding="UTF-8" includes="**/*.src" ext=".properties" />
  </target>

 
  <!-- setup the database and initialize the data -->
  <target name="setup-db">
    <echo message="=========================================================="/>
    <echo message="database driver:${database.driver}"/>
    <echo message="database url:${database.url}"/ >
    <echo message="database username:${database.username}"/>
    <echo message="database password:${database.password}"/>
    <echo message="=========================================================="/>  
   
    <antcall target="runSql" inheritAll="false">
      <param name="script.sql" value="${dir.meta}/database-setup.sql"/>
      <param name="database.driver" value="${database.driver}"/>
      <param name="database.url" value="${database.url}"/>
      <param name="database.username" value="${database.username}"/>
      <param name="database.password" value="${database.password}"/>
    </antcall>
    <echo message="initialize Sample data..."/>
    <antcall target="runSql" inheritAll="false">
      <param name="script.sql" value="${dir.meta}/database-init.sql"/>
      <param name="database.driver" value="${database.driver}"/>
      <param name="database.url" value="${database.url}"/>
      <param name="database.username" value="${database.username}"/>
      <param name="database.password" value="${database.password}"/>
    </antcall>
  </target>
  
 
  <!-- run the sql to setup database -->
  <target name="runSql">
    <sql src="${script.sql}"
         driver="${database.driver}"
         url="${database.url}"
         userid="${database.username}"
         password="${database.password}"
         classpathref="classpath"
         onerror="continue"/>
  </target>

  <target name="clean" description="Clean output directories">
    <delete dir="${dir.classes}"/>
  </target>
 
   
  <target name="deploy" description="deploy......" depends="clean,compile" >
  </target>
</project>