编写Annotation：

package com.eric.news.cha06;

import Java.lang.annotation.Documented;
import Java.lang.annotation.Inherited;
import Java.lang.annotation.Retention;
import Java.lang.annotation.RetentionPolicy;

@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface GroupTODO {

 public enum Severity {CRITICAL, IMPORTANT, TRIVIAL, DOCUMENTATION};
 Severity severity() default Severity.IMPORTANT;
 String item();
 String assignedTo();
}

－－－－－－－－－－－－－－－－－－－－－
运用annotation：

package com.eric.news.cha06;

@InProgress
public class TestInProgress {

 @GroupTODO(
   severity=GroupTODO.Severity.CRITICAL,
   item="Figure out the amount of interest per month",
   assignedTo="Eric Zhou"
 )
 public void calculateInterest(float amount, float rate) {
  
 }
}

－－－－－－－－－－－－－－－－－－－－－

测试：

package com.eric.news.cha06;

import Java.lang.reflect.Method;

public class TestAnnotation {

 public static void main(String[] args) throws SecurityException, NoSuchMethodException {
  Class c = TestInProgress.class;
  Method element = c.getMethod("calculateInterest", float.class, float.class);
  
  GroupTODO groupTodo = element.getAnnotation(GroupTODO.class);
  String assignedTo = groupTodo.assignedTo();
  
  System.out.println(assignedTo);
  System.out.println(groupTodo.item());

 }

}

－－－－－－－－－－－－－－－－－－－－－
结果：
Eric Zhou
Figure out the amount of interest per month

package com.eric.news;

public class Point2D {

 protected int x, y;
 
 public Point2D() {
  this.x = 0;
  this.y = 0;
 }
 public Point2D(int x, int y) {
  this.x = x;
  this.y = y;
 }
 
}

package com.eric.news;

public class Point3D extends Point2D {

 protected int z;
 
 public Point3D(int x, int y) {
  this(x, y, 0);
 }
 public Point3D(int x, int y, int z) {
  this.x = x;
  this.y = y;
  this.z = z;
 }
}

package com.eric.news;

public class Position2D {
 Point2D location;
 
 public Position2D() {
  this.location = new Point2D();
 }
 
 public Position2D(int x, int y) {
  this.location = new Point2D(x, y);
 }
 
 public Point2D getLocation() {
  return location;
 }
}

package com.eric.news;

public class Position3D extends Position2D {

 Point3D location;
 
 public Position3D(int x, int y, int z) {
  this.location = new Point3D(x, y, z);
 }
 
 public Point3D getLocation() {
  return location;
 }
}

package com.founder.common;

public class Person {
 private String firstName;
 private String lastName;
 private boolean sex;
 private int age;

 public Person(String firstName, String lastName, boolean sex, int age) {
  this.firstName = firstName;
  this.lastName = lastName;
  this.sex = sex;
  this.age = age;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getFirstName() {
  return firstName;
 }
 public void setFirstName(String firstName) {
  this.firstName = firstName;
 }
 public String getLastName() {
  return lastName;
 }
 public void setLastName(String lastName) {
  this.lastName = lastName;
 }
 public boolean getSex() {
  return sex;
 }
 public void setSex(boolean sex) {
  this.sex = sex;
 }
 
 public String toString() {
  return firstName + " " + lastName + " " + (sex ? "Male" : "Female") + " " + age;
 }
}

Comparator.java

package com.founder.common;

public class Comparator{
 public static Java.util.Comparator getComparator() {
  return new Java.util.Comparator() {
   public int compare(Object o1, Object o2) {
    if (o1 instanceof String) {
     return compare((String) o1, (String) o2);
    } else if (o1 instanceof Integer) {
     return compare((Integer) o1, (Integer) o2);
    } else if (o1 instanceof Person) {
     return compare((Person) o1, (Person) o2);
    } else {
     System.err.println("未找到适合的比较器");
     return 1;
    }
   }
   
   public int compare(String o1, String o2) {
    int len1 = o1.length();
    int len2 = o2.length();
    int n = Math.min(len1, len2);
    char v1[] = o1.toCharArray();
    char v2[] = o2.toCharArray();
    int pos = 0;
    
    while (n-- != 0) {
     char c1 = v1[pos];
     char c2 = v2[pos];
     
     if (c1 != c2) {
      return c1 - c2;
     }
     pos++;
    }
    
    return len1 - len2;
   }
   
   public int compare(Integer o1, Integer o2) {  
          int val1 = o1.intValue();  
          int val2 = o2.intValue();  
          return (val1 < val2 ? -1 : (val1 == val2 ? 0 : 1));  
      }
   
   public int compare(boolean o1, boolean o2) {
    return (o1 == o2 ? 0 : (o1 == true ? 1: -1));
   }
   
   public int compare(Person o1, Person o2) {
    String firstname1 = o1.getFirstName();  
          String firstname2 = o2.getFirstName();  
          String lastname1 = o1.getLastName();  
          String lastname2 = o2.getLastName();  
          boolean sex1 = o1.getSex();  
          boolean sex2 = o2.getSex();  
          int age1 = o1.getAge();  
          int age2 = o2.getAge();  
          return (compare(firstname1, firstname2) == 0 ?
            (compare(lastname1, lastname2) == 0 ? (compare(sex1, sex2) == 0 ? (compare(age1, age2) == 0 ? 0 :
             compare(age1, age2)) :
              compare(sex1, sex2)) :
               compare(lastname1, lastname2)) :
                compare(firstname1, firstname2));
   }
  };
 }
}

PersonTest.java

package com.founder.common;

public class PersonTest {

 public static void main(String[] args) {
  Person[] person = new Person[] {
    new Person("ouyang", "feng", true, 25),
    new Person("zhuang", "gw", false, 36),
    new Person("zhuang", "gw", true, 36),
    new Person("zhuang", "gw", true, 33),
    new Person("zhuang", "gw", false, 23),
    new Person("yang", "gw", true, 43)};
  for (int i = 0; i < person.length; i++) {
   System.out.println("before sort=" + person[i]);
  }

  java.util.Arrays.sort(person, Comparator.getComparator());

  System.out.println("*************************************");
  
  for (int i = 0; i < person.length; i++) {
   System.out.println("after sort=" + person[i]);
  }

 }

}

输出结果为：
before sort=ouyang feng Male 25
before sort=zhuang gw Female 36
before sort=zhuang gw Male 36
before sort=zhuang gw Male 33
before sort=zhuang gw Female 23
before sort=yang gw Male 43
*************************************
after sort=ouyang feng Male 25
after sort=yang gw Male 43
after sort=zhuang gw Female 23
after sort=zhuang gw Female 36
after sort=zhuang gw Male 33
after sort=zhuang gw Male 36

1. public class TestObject {  
2.     /** 
3.      * 一个用来被测试的方法，进行了一个比较耗时的循环 
4.      */  
5.     public static void testMethod(){  
6.         for(int i=0; i<100000000; i++){  
7.               
8.         }  
9.     }  
10.     /** 
11.      * 一个简单的测试方法执行时间的方法 
12.      */  
13.     public void testTime(){  
14.         long begin = System.currentTimeMillis();//测试起始时间  
15.         testMethod();//测试方法  
16.         long end = System.currentTimeMillis();//测试结束时间  
17.         System.out.println("[use time]:" + (end - begin));//打印使用时间  
18.     }  
19.       
20.     public static void main(String[] args) {  
21.         TestObject test=new TestObject();  
22.         test.testTime();  
23.     }  
24. }  

1. public interface CallBack {  
2.     //执行回调操作的方法  
3.     void execute();  
4. }  

1. public class Tools {  
2.       
3.     /** 
4.      * 测试函数使用时间，通过定义CallBack接口的execute方法 
5.      * @param callBack 
6.      */  
7.     public void testTime(CallBack callBack) {  
8.         long begin = System.currentTimeMillis();//测试起始时间  
9.         callBack.execute();///进行回调操作  
10.         long end = System.currentTimeMillis();//测试结束时间  
11.         System.out.println("[use time]:" + (end - begin));//打印使用时间  
12.     }  
13.       
14.     public static void main(String[] args) {  
15.         Tools tool = new Tools();  
16.         tool.testTime(new CallBack(){  
17.             //定义execute方法  
18.             public void execute(){  
19.                 //这里可以加放一个或多个要测试运行时间的方法  
20.                 TestObject.testMethod();  
21.             }  
22.         });  
23.     }  
24.       
25. }  

import Java.io.IOException;
import Java.io.InputStream;

import javax.xml.XMLConstants;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

import org.xml.sax.SAXException;

public class SchemaValidation {

 /**
  * @param args
  * @throws IOException
  * @throws SAXException
  * @throws ParserConfigurationException
  */
 public static void main(String[] args) throws ParserConfigurationException,
   SAXException, IOException {
  SchemaValidation sv = new SchemaValidation();
  sv.validate();
 }

 public void validate() {
  try {
   String strLang = XMLConstants.W3C_XML_SCHEMA_NS_URI;
   SchemaFactory factory = SchemaFactory.newInstance(strLang);

   InputStream isSchema = getClass().getResourceAsStream("/founder.xsd");
   StreamSource ss = new StreamSource(isSchema);
   Schema schema = factory.newSchema(ss);

   Validator validator = schema.newValidator();
   
   InputStream isXML = getClass().getResourceAsStream("/founder.xml");
   
   StreamSource source = new StreamSource(isXML);
   validator.validate(source);
   System.out.println("Result : Valid!");

  } catch (Exception e) {
   e.printStackTrace();
   System.out.println("Result : Invalid!");
  }

 }

}


founder.xsd

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
 xmlns="http://www.founder.com" elementFormDefault="qualified">
 <xs:element name="note">
  <xs:complexType>
   <xs:sequence>
    <xs:element name="to" type="xs:string" />
    <xs:element name="from" type="xs:string" />
    <xs:element name="heading" type="xs:string" />
    <xs:element name="body" type="xs:string" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>
</xs:schema>


founder.xml

<?xml version="1.0"?>
<note xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.founder.com founder.xsd">
 <to>Tove</to>
 <from>Jani</from>
 <heading>Reminder</heading>
 <body>Don't forget me this weekend!</body>
</note>

WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext()); 

由于spring是注入的对象放在ServletContext中的，所以可以直接在ServletContext取出WebApplicationContext 对象：

WebApplicationContext webApplicationContext = (WebApplicationContext) servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

事实上WebApplicationContextUtils.getWebApplicationContext方法就是使用上面的代码实现的，建议使用上面上面的静态方法 

1． 环境要求：

已安装Java平台，版本为j2sdk1.4.2，环境变量JAVA_HOME设为C:"j2sdk1.4.2；

2． 下载与运行：

从Apache网站上下载得到一个压缩的文件james-2.1-bin.zip，大小为4.44M，将此包解压到C:"James"james-2.1下。

运行分为两种方式：前台直接运行、作为后台服务运行；

1>前台直接运行：

在C:"James"james-2.1"bin下运行run.bat

这是会出现：

Using PHOENIX_HOME:   C:"James"james-2.1

Using PHOENIX_TMPDIR: C:"James"james-2.1"temp

Using JAVA_HOME:      C:"j2sdk1.4.2

Phoenix 4.0.1

James 2.1

Remote Manager Service started plain:4555

POP3 Service started plain:110

SMTP Service started plain:25

NNTP Service Disabled

Fetch POP Disabled

这是就表示James邮件服务以开启，不过Window下不能关闭控制台窗口，否者邮件服务会停止。如要克服此缺点必须使James邮件服务作为作为后台服务运行。

停止前台运行按Ctrl+C,会出现：

JVM exiting abnormally. Shutting down Phoenix.

终止批处理操作吗(Y/N)?

2>后台服务运行：

将C:"James"james-2.1"conf目录下的wrapper.conf拷贝到C:"James"james-2.1"bin即包含wrapper.exe的目录下，运行：

wrapper.exe    -i     C:"James"james-2.1"bin"wrapper.conf 

然后在控制面板中开启服务或重启即可。

卸载后台服务：

到C:"James"james-2.1"bin即包含wrapper.exe的目录下，运行：

wrapper.exe     -r    C:"James"james-2.1"bin"wrapper.conf

3．  

二、配置：

1>服务器端配置（邮件服务器的名字假设叫EmailServer，服务器管理员名Admin）

首先停止已开启的James邮件服务，然后打开文件C:"James"james-2.1"apps"james"SAR-INF"config.xml。

Ø         在config.xml文件中，找到Postmaster@localhost，把此项改为Admin@EmailServer，同时，找到位于

<!-- By default, the servername 'localhost' is specified. This can be removed, if required.   -->

- <!-- 

 -->

- <!-- Warning: If you are using fetchpop it is important to include the   -->

- <!-- fetched domains in the server name list to prevent looping.       -->

- <servernames autodetect="true" autodetectIP="true">

- <!-- CONFIRM?

  -->

 <servername> localhost </servername>

 </servernames>

的localhost，把此项改为EmailServer。这样就可以让其它机器也能访问邮件系统。

Ø         DNS配置：找到同上文件中<dnsserver>段中的如下程序段：

- <dnsserver>

- <servers>

- <!-- CONFIRM?   -->

- <!-- Enter ip address of your DNS server, one IP address per server   -->

- <!-- element. The default configuration assumes a DNS server on the localhost.   -->

 <server>127.0.0.1</server>

 </servers>

 <authoritative>false</authoritative>

 </dnsserver>

将127.0.0.1的位置填入DNS服务器的IP地址；

Ø         修改管理员密码：

找到同上文件中的<administrator_accounts>段，如下程序段

- <administrator_accounts>

- <!-- CHECKME!

 -->

- <!-- Change the default login/password.

 -->

 <account login="root" password="root" />

 </administrator_accounts>

将默认用户名root与密码root修改为需要的值

Ø         修改telnet管理程序登录端口 ：（默认为4555）

找到同上文件中的<remotemanager>段下的port如下程序段

- <remotemanager>

 <port>4555</port>

- <!--   Uncomment this if you want to bind to a specific inetaddress

 -->

-          <!--

将<port>4555</port>之间的端口号4555改为需要的端口。

2> 客户端配置：（略）

3>帐号管理

James的账号管理是通过telnet完成的，登录命令为：

telnet EmailServer 4555

其中EmailServer也可以换成IP，4555是端口号。登录时需要用户名和密码，开始默认的用户名和密码均为root。若登录成功，提示如下：

JAMES Remote Administration Tool 2.1

Please enter your login and password

Login id:

       此时输入root用户名,然后会出现：

              Password:

       输入密码root

注意：在有些操作系统如Windows2000上，用户输入均不显示。

telnet命令列表：

4>用户信息的数据库存储

James邮件用户的用户信息默认保存在apps"james"var"users目录下，通过修改配置文件apps"james"SAR-INF"config.xml，可以把用户信息保存到数据库中，配置方法如下：

假设使用的是MySQL数据库：

第一步：首先将MySQL的驱动程序（例如：mysql-connector-java-3.1.6-bin.jar）考到james的lib目录下（例如：D:"james"lib）

第二步：在MySQL中新建一个数据库mail；

第三步：打开config.xml，找到<users-store>这一项，此面默认的内容为：

需要修改为：

其实如不修改也行，因为文件下面也有实例，不过是用<!-- 和 --> 注释掉的，打开即可；记住把

<repository name="LocalUsers" class="org.apache.james.userrepository.UsersFileRepository">
         <destination URL="file://var/users/"/>
</repository>

用<!-- 和 --> 注释掉；

通过修改，我们就把用户信息的存储介质从file改成了db，<sqlFile>是指明了在db中的数据表结构及相关数据库信息。

第四步：仍然是config.xml，找到<data-sources>项，默认内容为空，把此项内容修改为：

或打开文件下面实例的<!-- 和 --> 注释

<driver>是指MySQL的JDBC驱动，注意这个默认的<driver>是有问题的，要改成MySQL的驱动程序中Driver.class的路径，即：

                   <driver>com.mysql.jdbc.Driver</driver>

<dburl>指数据库的访问路径，IP后的mail即MySQL中新建数据库名，接下来是用户名、密码及最大连接数。

再次启动时，james将在mail数据库中自动创建有关用户的表格。

至此，数据库配置完成，启动James，若正常无误，请通过telnet添加一个新用户，比如adduser holen 123456，然后检查MySQL中的mail数据库，下面将有一个表users，这是James根据file://conf/sqlResources.xml的内容创建的。

通过以上配置，James的用户信息就可以保存在数据库中了。

注：修改以前的账户会丢失！

一、FAQ

1、在启动james时，提示POP3或SMTP不能使用？

请检查一下，看“管理工具—>服务”里面，是不是启动了别的邮件服务器，已将110或25端口占用了。

       实例：

james前台直接运行时出错：

ERROR   2005-08-25 08:58:38.642 [Phoenix.] (): Component named "smtpserver" failed to pass through the Initialization stage. (Reason: Java.net.BindException: Address already in use: JVM_Bind).

ERROR   2005-08-25 08:58:38.652 [Phoenix.] (): There was an error running phase "startup" for Block named "smtpserver". (Reason: Component named "smtpserver" failed to pass through the Initialization stage. (Reason: Java.net.BindException: Address already in use: JVM_Bind).).

org.apache.excalibur.containerkit.lifecycle.LifecycleException: Component named "smtpserver" failed to pass through the Initialization stage. (Reason: Java.net.BindException: Address already in use: JVM_Bind).

原因：

 james默认设置不允许在同一台机器上跑两个邮件服务器进程。必须关掉另一个！

检测方法：

console界面下：

 d:> telnet 主机名 25（或110）

如果可以登录，出现

 220 主机名 Microsoft ESMTP MAIL Service, Version: 6.0.2600.1106 ready at Thu,

 25 Aug 2005 14:14:36 +0800

则说明此机器上已有一台邮件服务器在运行。

解决：

检查Windows上运行服务：

跨网传输电子邮件的服务Simple Mail Transfer Protocol (SMTP)，是否启动

如启动关闭之！

2、 JAVA_HOME找不到？

请在run.bat中指定JAVA_HOME，若还不行，请在“我的电脑—>系统—>高级—>环境变量”中添加一项JAVA_HOME。

3、服务器启动正常，但客户端不能收发邮件？

请检查客户端配置是否正常，参照前面所讲，另外，请检查james下的config.xml，是否把localhost改成了机器名。

4、修改为数据库储存后，james启动出错：

一般是数据库驱动有错。检查一下

<data-source name="maildb" class="org.apache.james.util.mordred.JdbcDataSource">
                           <driver>org.gjt.mm.mysql.Driver</driver>
                            <dburl>jdbc:mysql://127.0.0.1/mail</dburl>
                            <user>root</user>
                            <password></password>
                            <max>20</max>
</data-source>

的<driver>org.gjt.mm.mysql.Driver</driver>是否对

• Struts 2
• Tomcat 5.5
• Eclipse
• Eclipse WTP
• Hibernate Core
• Hibernate Annotations
• Hibernate Entity Manager
• MySql Server
• Mysql JDBC Driver
• Spring 2.0

如果你用win
/tomcat/bin/catalina.bat 加上下面的命令:
set JAVA_OPTS=-Xms32m -Xmx256m

如果你用unix/linux
/tomcat/bin/catalina.sh 加上下面的命令:
JAVA_OPTS="-Xms32m -Xmx256m" 

public interface ResultSetMetaData

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象。以下代码片段创建 ResultSet 对象 rs，创建 ResultSetMetaData 对象 rsmd，并使用 rsmd 查找 rs 有多少列，以及 rs 中的第一列是否可以在 WHERE 子句中使用。

     ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2");
     ResultSetMetaData rsmd = rs.getMetaData();
     int numberOfColumns = rsmd.getColumnCount();
     boolean b = rsmd.isSearchable(1);

 

　　这里使用的是jdk1.4.2。

　　下载地址:http://dlc.sun.com/jdk/j2sdk-1_4_2_07-windows-i586-p.exe;

　　2、tomcat

　　这里的tomcat的版本是5.0的，安装版或是解压版都是可以的。

　　下载地址:http://apache.linuxforum.net/dis ... a-tomcat-5.0.28.exe

　　3、数据库

　　推荐使用mysql，but暂时找不到下载地址，由于此次偶们班有课程设计要用sqlserver的，所以下面实践会使用sqlserver(找张安装盘安装

)

　　注:连接sqlserver需要三个jar文件(文件名ms开头)，可从这里下载:

　　http://www.softhouse.com.cn/html ... 11250300001646.html

　　上面包括完整的配置方法

　　二、软件安装:

　　1.双击安装jdk。装完后在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量:

　　(假设你的JDK安装在c:/jdk)

　　JDK_HOME=C:\jdk

　　classpath=.;%JDK_HOME%\lib\dt.jar;%JDK_HOME%\lib\tools.jar

　　在PATH(原来就已存在)中添加:%JDK_HOME%\bin

　　这样jdk环境配置成功。

　　2.双击安装你的Tomcat。(建议安装在D:/tomcat)

　　注:tomcat5.0.x版本不需配置环境变量就可以使用，但如果需要编译Servlet则必须将tomcat的两个jar文件也放到环境变量中，具体方法

如下:

　　在我的电脑->属性->高级->环境变量->系统变量中添加:

　　TOMCAT_HOME=D:\tomcat 5.0
    CATALINA_HOME=D:\Tomcat 5.0

　　修改classpath变成:.;%JDK_HOME%\lib\dt.jar;%JDK_HOME%\lib\tools.jar;%TOMCAT_HOME%\common\lib\servlet-api.jar;%TOMCAT_HOME%

\common\lib\jsp-api.jar;

　　这样已经完整安装完Tomcat了。

　　建议:在PATH中再添加:%JDK_HOME%\jre\bin;%JDK_HOME%\bin;%TOMCAT_HOME%\bin;

　　这样做的目的是在虚拟dos中可以使用tomcat的工具

　　最后顺便把第一步下载回来的三个jar文件放到tomcat目录下的common/lib目录中

　　3.测试:

　　打开开始菜单中的tomcat(小猫图案)的monitor工具，点击start

server，显示绿色三角形即为启动，打开浏览器在地址栏输入:http://localhost:8080/可以看到小猫图案说明已经配置成功。

　　4.安装数据库(sqlserver)

　　windows xp下必须安装个人版或开发版(个人推荐个人版)。

　　一直next就可以(微软的东西就是方便)，这里注意到域帐户那里选择本机帐户，到验证那里选择混合验证(这点很重要，若选择系统认证以

后在程序中就连接不上数据库)，为你的sa用户输入一个密码(如果练习用就不用考虑安全性啦，选择“空密码”就可以)

　　三、正式编程:

　　1.建立数据库

　　打开开始菜单找到sqlserver的快捷方式组里面的企业管理器，点开左边的树一般有个localhost连接，如果有个绿色三角形符号证明数据

库连接成功。点击邮件新建数据库，在你新建的数据库中再新建个数据表(例如叫test)，数据表建立若干字段。

　　补充:提供另一种建表方法是使用sql脚本建表。首先创建如下文件:

static {
if (spellMap == null) {
spellMap = new LinkedHashMap(400);
}
initialize();
//System.out.println("Chinese transfer Spell Done.");
}

private CnToSpell() {
}

private static void spellPut(String spell, int ascii) {
spellMap.put(spell, new Integer(ascii));
}

private static void initialize() {
spellPut("A", -20319);
spellPut("Ai", -20317);
spellPut("An", -20304);
spellPut("Ang", -20295);
spellPut("Ao", -20292);
spellPut("Ba", -20283);
spellPut("Bai", -20265);
spellPut("Ban", -20257);
spellPut("Bang", -20242);
spellPut("Bao", -20230);
spellPut("Bei", -20051);
spellPut("Ben", -20036);
spellPut("Beng", -20032);
spellPut("Bi", -20026);
spellPut("Bian", -20002);
spellPut("Biao", -19990);
spellPut("Bie", -19986);
spellPut("Bin", -19982);
spellPut("Bing", -19976);
spellPut("Bo", -19805);
spellPut("Bu", -19784);
spellPut("Ca", -19775);
spellPut("Cai", -19774);
spellPut("Can", -19763);
spellPut("Cang", -19756);
spellPut("Cao", -19751);
spellPut("Ce", -19746);
spellPut("Ceng", -19741);
spellPut("Cha", -19739);
spellPut("Chai", -19728);
spellPut("Chan", -19725);
spellPut("Chang", -19715);
spellPut("Chao", -19540);
spellPut("Che", -19531);
spellPut("Chen", -19525);
spellPut("Cheng", -19515);
spellPut("Chi", -19500);
spellPut("Chong", -19484);
spellPut("Chou", -19479);
spellPut("Chu", -19467);
spellPut("Chuai", -19289);
spellPut("Chuan", -19288);
spellPut("Chuang", -19281);
spellPut("Chui", -19275);
spellPut("Chun", -19270);
spellPut("Chuo", -19263);
spellPut("Ci", -19261);
spellPut("Cong", -19249);
spellPut("Cou", -19243);
spellPut("Cu", -19242);
spellPut("Cuan", -19238);
spellPut("Cui", -19235);
spellPut("Cun", -19227);
spellPut("Cuo", -19224);
spellPut("Da", -19218);
spellPut("Dai", -19212);
spellPut("Dan", -19038);
spellPut("Dang", -19023);
spellPut("Dao", -19018);
spellPut("De", -19006);
spellPut("Deng", -19003);
spellPut("Di", -18996);
spellPut("Dian", -18977);
spellPut("Diao", -18961);
spellPut("Die", -18952);
spellPut("Ding", -18783);
spellPut("Diu", -18774);
spellPut("Dong", -18773);
spellPut("Dou", -18763);
spellPut("Du", -18756);
spellPut("Duan", -18741);
spellPut("Dui", -18735);
spellPut("Dun", -18731);
spellPut("Duo", -18722);
spellPut("E", -18710);
spellPut("En", -18697);
spellPut("Er", -18696);
spellPut("Fa", -18526);
spellPut("Fan", -18518);
spellPut("Fang", -18501);
spellPut("Fei", -18490);
spellPut("Fen", -18478);
spellPut("Feng", -18463);
spellPut("Fo", -18448);
spellPut("Fou", -18447);
spellPut("Fu", -18446);
spellPut("Ga", -18239);
spellPut("Gai", -18237);
spellPut("Gan", -18231);
spellPut("Gang", -18220);
spellPut("Gao", -18211);
spellPut("Ge", -18201);
spellPut("Gei", -18184);
spellPut("Gen", -18183);
spellPut("Geng", -18181);
spellPut("Gong", -18012);
spellPut("Gou", -17997);
spellPut("Gu", -17988);
spellPut("Gua", -17970);
spellPut("Guai", -17964);
spellPut("Guan", -17961);
spellPut("Guang", -17950);
spellPut("Gui", -17947);
spellPut("Gun", -17931);
spellPut("Guo", -17928);
spellPut("Ha", -17922);
spellPut("Hai", -17759);
spellPut("Han", -17752);
spellPut("Hang", -17733);
spellPut("Hao", -17730);
spellPut("He", -17721);
spellPut("Hei", -17703);
spellPut("Hen", -17701);
spellPut("Heng", -17697);
spellPut("Hong", -17692);
spellPut("Hou", -17683);
spellPut("Hu", -17676);
spellPut("Hua", -17496);
spellPut("Huai", -17487);
spellPut("Huan", -17482);
spellPut("Huang", -17468);
spellPut("Hui", -17454);
spellPut("Hun", -17433);
spellPut("Huo", -17427);
spellPut("Ji", -17417);
spellPut("Jia", -17202);
spellPut("Jian", -17185);
spellPut("Jiang", -16983);
spellPut("Jiao", -16970);
spellPut("Jie", -16942);
spellPut("Jin", -16915);
spellPut("Jing", -16733);
spellPut("Jiong", -16708);
spellPut("Jiu", -16706);
spellPut("Ju", -16689);
spellPut("Juan", -16664);
spellPut("Jue", -16657);
spellPut("Jun", -16647);
spellPut("Ka", -16474);
spellPut("Kai", -16470);
spellPut("Kan", -16465);
spellPut("Kang", -16459);
spellPut("Kao", -16452);
spellPut("Ke", -16448);
spellPut("Ken", -16433);
spellPut("Keng", -16429);
spellPut("Kong", -16427);
spellPut("Kou", -16423);
spellPut("Ku", -16419);
spellPut("Kua", -16412);
spellPut("Kuai", -16407);
spellPut("Kuan", -16403);
spellPut("Kuang", -16401);
spellPut("Kui", -16393);
spellPut("Kun", -16220);
spellPut("Kuo", -16216);
spellPut("La", -16212);
spellPut("Lai", -16205);
spellPut("Lan", -16202);
spellPut("Lang", -16187);
spellPut("Lao", -16180);
spellPut("Le", -16171);
spellPut("Lei", -16169);
spellPut("Leng", -16158);
spellPut("Li", -16155);
spellPut("Lia", -15959);
spellPut("Lian", -15958);
spellPut("Liang", -15944);
spellPut("Liao", -15933);
spellPut("Lie", -15920);
spellPut("Lin", -15915);
spellPut("Ling", -15903);
spellPut("Liu", -15889);
spellPut("Long", -15878);
spellPut("Lou", -15707);
spellPut("Lu", -15701);
spellPut("Lv", -15681);
spellPut("Luan", -15667);
spellPut("Lue", -15661);
spellPut("Lun", -15659);
spellPut("Luo", -15652);
spellPut("Ma", -15640);
spellPut("Mai", -15631);
spellPut("Man", -15625);
spellPut("Mang", -15454);
spellPut("Mao", -15448);
spellPut("Me", -15436);
spellPut("Mei", -15435);
spellPut("Men", -15419);
spellPut("Meng", -15416);
spellPut("Mi", -15408);
spellPut("Mian", -15394);
spellPut("Miao", -15385);
spellPut("Mie", -15377);
spellPut("Min", -15375);
spellPut("Ming", -15369);
spellPut("Miu", -15363);
spellPut("Mo", -15362);
spellPut("Mou", -15183);
spellPut("Mu", -15180);
spellPut("Na", -15165);
spellPut("Nai", -15158);
spellPut("Nan", -15153);
spellPut("Nang", -15150);
spellPut("Nao", -15149);
spellPut("Ne", -15144);
spellPut("Nei", -15143);
spellPut("Nen", -15141);
spellPut("Neng", -15140);
spellPut("Ni", -15139);
spellPut("Nian", -15128);
spellPut("Niang", -15121);
spellPut("Niao", -15119);
spellPut("Nie", -15117);
spellPut("Nin", -15110);
spellPut("Ning", -15109);
spellPut("Niu", -14941);
spellPut("Nong", -14937);
spellPut("Nu", -14933);
spellPut("Nv", -14930);
spellPut("Nuan", -14929);
spellPut("Nue", -14928);
spellPut("Nuo", -14926);
spellPut("N", -14922);
spellPut("Ou", -14921);
spellPut("Pa", -14914);
spellPut("Pai", -14908);
spellPut("Pan", -14902);
spellPut("Pang", -14894);
spellPut("Pao", -14889);
spellPut("Pei", -14882);
spellPut("Pen", -14873);
spellPut("Peng", -14871);
spellPut("Pi", -14857);
spellPut("Pian", -14678);
spellPut("Piao", -14674);
spellPut("Pie", -14670);
spellPut("Pin", -14668);
spellPut("Ping", -14663);
spellPut("Po", -14654);
spellPut("Pu", -14645);
spellPut("Qi", -14630);
spellPut("Qia", -14594);
spellPut("Qian", -14429);
spellPut("Qiang", -14407);
spellPut("Qiao", -14399);
spellPut("Qie", -14384);
spellPut("Qin", -14379);
spellPut("Qing", -14368);
spellPut("Qiong", -14355);
spellPut("Qiu", -14353);
spellPut("Qu", -14345);
spellPut("Quan", -14170);
spellPut("Que", -14159);
spellPut("Qun", -14151);
spellPut("Ran", -14149);
spellPut("Rang", -14145);
spellPut("Rao", -14140);
spellPut("Re", -14137);
spellPut("Ren", -14135);
spellPut("Reng", -14125);
spellPut("Ri", -14123);
spellPut("Rong", -14122);
spellPut("Rou", -14112);
spellPut("Ru", -14109);
spellPut("Ruan", -14099);
spellPut("Rui", -14097);
spellPut("Run", -14094);
spellPut("Ruo", -14092);
spellPut("Sa", -14090);
spellPut("Sai", -14087);
spellPut("San", -14083);
spellPut("Sang", -13917);
spellPut("Sao", -13914);
spellPut("Se", -13910);
spellPut("Sen", -13907);
spellPut("Seng", -13906);
spellPut("Sha", -13905);
spellPut("Shai", -13896);
spellPut("Shan", -13894);
spellPut("Shang", -13878);
spellPut("Shao", -13870);
spellPut("She", -13859);
spellPut("Shen", -13847);
spellPut("Sheng", -13831);
spellPut("Shi", -13658);
spellPut("Shou", -13611);
spellPut("Shu", -13601);
spellPut("Shua", -13406);
spellPut("Shuai", -13404);
spellPut("Shuan", -13400);
spellPut("Shuang", -13398);
spellPut("Shui", -13395);
spellPut("Shun", -13391);
spellPut("Shuo", -13387);
spellPut("Si", -13383);
spellPut("Song", -13367);
spellPut("Sou", -13359);
spellPut("Su", -13356);
spellPut("Suan", -13343);
spellPut("Sui", -13340);
spellPut("Sun", -13329);
spellPut("Suo", -13326);
spellPut("Ta", -13318);
spellPut("Tai", -13147);
spellPut("Tan", -13138);
spellPut("Tang", -13120);
spellPut("Tao", -13107);
spellPut("Te", -13096);
spellPut("Teng", -13095);
spellPut("Ti", -13091);
spellPut("Tian", -13076);
spellPut("Tiao", -13068);
spellPut("Tie", -13063);
spellPut("Ting", -13060);
spellPut("Tong", -12888);
spellPut("Tou", -12875);
spellPut("Tu", -12871);
spellPut("Tuan", -12860);
spellPut("Tui", -12858);
spellPut("Tun", -12852);
spellPut("Tuo", -12849);
spellPut("Wa", -12838);
spellPut("Wai", -12831);
spellPut("Wan", -12829);
spellPut("Wang", -12812);
spellPut("Wei", -12802);
spellPut("Wen", -12607);
spellPut("Weng", -12597);
spellPut("Wo", -12594);
spellPut("Wu", -12585);
spellPut("Xi", -12556);
spellPut("Xia", -12359);
spellPut("Xian", -12346);
spellPut("Xiang", -12320);
spellPut("Xiao", -12300);
spellPut("Xie", -12120);
spellPut("Xin", -12099);
spellPut("Xing", -12089);
spellPut("Xiong", -12074);
spellPut("Xiu", -12067);
spellPut("Xu", -12058);
spellPut("Xuan", -12039);
spellPut("Xue", -11867);
spellPut("Xun", -11861);
spellPut("Ya", -11847);
spellPut("Yan", -11831);
spellPut("Yang", -11798);
spellPut("Yao", -11781);
spellPut("Ye", -11604);
spellPut("Yi", -11589);
spellPut("Yin", -11536);
spellPut("Ying", -11358);
spellPut("Yo", -11340);
spellPut("Yong", -11339);
spellPut("You", -11324);
spellPut("Yu", -11303);
spellPut("Yuan", -11097);
spellPut("Yue", -11077);
spellPut("Yun", -11067);
spellPut("Za", -11055);
spellPut("Zai", -11052);
spellPut("Zan", -11045);
spellPut("Zang", -11041);
spellPut("Zao", -11038);
spellPut("Ze", -11024);
spellPut("Zei", -11020);
spellPut("Zen", -11019);
spellPut("Zeng", -11018);
spellPut("Zha", -11014);
spellPut("Zhai", -10838);
spellPut("Zhan", -10832);
spellPut("Zhang", -10815);
spellPut("Zhao", -10800);
spellPut("Zhe", -10790);
spellPut("Zhen", -10780);
spellPut("Zheng", -10764);
spellPut("Zhi", -10587);
spellPut("Zhong", -10544);
spellPut("Zhou", -10533);
spellPut("Zhu", -10519);
spellPut("Zhua", -10331);
spellPut("Zhuai", -10329);
spellPut("Zhuan", -10328);
spellPut("Zhuang", -10322);
spellPut("Zhui", -10315);
spellPut("Zhun", -10309);
spellPut("Zhuo", -10307);
spellPut("Zi", -10296);
spellPut("Zong", -10281);
spellPut("Zou", -10274);
spellPut("Zu", -10270);
spellPut("Zuan", -10262);
spellPut("Zui", -10260);
spellPut("Zun", -10256);
spellPut("Zuo", -10254);
}

/**
* 获得单个汉字的Ascii.
* @param cn char
* 汉字字符
* @return int
* 错误返回 0,否则返回ascii
*/
public static int getCnAscii(char cn) {
byte[] bytes = null;
try {
bytes = (String.valueOf(cn)).getBytes("GBK");

//System.out.println("bytes ="+ new String(bytes, "GBK"));
}
catch (UnsupportedEncodingException ex) {
}
if (bytes == null || bytes.length > 2 || bytes.length <= 0) { //错误
return 0;
}
if (bytes.length == 1) { //英文字符
return bytes[0];
}
if (bytes.length == 2) { //中文字符
int hightByte = 256 + bytes[0];
int lowByte = 256 + bytes[1];

int ascii = (256 * hightByte + lowByte) - 256 * 256;

//System.out.println("256 * hightByte=" + 256 * hightByte);
//System.out.println("lowByte=" + lowByte);
//System.out.println("256 * hightByte + lowByte=" + (256 * hightByte + lowByte));
//System.out.println("256 * 256=" + 256 * 256);
//System.out.println("ASCII=" + ascii);
//System.out.println("ASCII=" + ascii);

return ascii;
}

return 0; //错误
}

/**
* 根据ASCII码到SpellMap中查找对应的拼音
* @param ascii int
* 字符对应的ASCII
* @return String
* 拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符,
*
否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.
*/
public static String getSpellByAscii(int ascii) {
if (ascii > 0 && ascii < 160) { //单字符
return String.valueOf( (char) ascii);
}

if (ascii < -20319 || ascii > -10247) { //不知道的字符
return null;
}

Set keySet = spellMap.keySet();
Iterator it = keySet.iterator();

String spell0 = null; ;
String spell = null;

int asciiRang0 = -20319;
int asciiRang;
while (it.hasNext()) {

spell = (String) it.next();
Object valObj = spellMap.get(spell);
if (valObj instanceof Integer) {
asciiRang = ( (Integer) valObj).intValue();

if (ascii >= asciiRang0 && ascii < asciiRang) { //区间找到
return (spell0 == null) ? spell : spell0;
}
else {
spell0 = spell;
asciiRang0 = asciiRang;
}
}
}

return null;

}

/**
* 判断是否是字母
* @param ascii int
* @return boolean
*/
private static boolean isAlphabet(int ascii) {
if (ascii > 0 && ascii < 160) {
return true;
}
else {
return false;
}
}

/**
* 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换
* @param cnStr String
* 字符串
* @return String
* 转换成全拼后的字符串
*/
public static String getFullSpell(String cnStr) {
if (null == cnStr || "".equals(cnStr.trim())) {
return cnStr;
}

boolean isChinese = false;

char[] chars = cnStr.toCharArray();
StringBuffer retuBuf = new StringBuffer();
StringBuffer resultBuf = new StringBuffer();

for (int i = 0, Len = chars.length; i < Len; i++) {
int ascii = getCnAscii(chars[i]);
if (ascii == 0) { //取ascii时出错
retuBuf.append(chars[i]);
}
else {
String spell = getSpellByAscii(ascii);
if (spell == null) {
retuBuf.append(chars[i]);
}
else {
//System.out.println("spell:"+spell);
retuBuf.append(spell);

} // end of if spell == null
if (!isAlphabet(ascii)) {
isChinese = true;
retuBuf.append("");
}
} // end of if ascii <= -20400

} // end of for
if (isChinese) {
//resultBuf.append(cnStr);//中文字加入
resultBuf.append("");
resultBuf.append(retuBuf.toString());
}else{
resultBuf.append(retuBuf.toString());
}
return resultBuf.toString();

}

public static String getFirstSpell(String cnStr) {
return null;
}

public static void main(String[] args) {
String str = null;

try {
str = new String("中国".getBytes(), "GBK");
}
catch (Exception ex) {
}
System.out.println("Spell=" + CnToSpell.getFullSpell(str));
}
}

如果要告诉别人买一加仑牛奶，您会怎么说？“请去买一加仑牛奶回来” 还是 “从前门出去，向左转，走三个街区向右转，再走半个街区向右转进入商店。走向四号通道，沿通道走五米向左，拿一瓶一加仑装的牛奶然后到收银台付款。再沿原路回家。” 简直太可笑了。只要在 “请去买一加仑牛奶回来” 的基础上稍加指示，多数成人都能自己买回牛奶来。

查询语言和计算机搜索与此类似。直接说 “找一个 Cryptonomicon 的副本” 要比编写搜索某个数据库的详细逻辑容易得多。由于搜索操作的逻辑非常相似，可以发明一种通用语言让您使用 “找到 Neal Stephenson 的所有著作” 这样的命令，然后编写对特定数据存储执行此类查询的引擎。

XPath

在众多查询语言之中，结构化查询语言（SQL）是一种针对查询特定类型的关系库而设计和优化的语言。其他不那么常见的查询语言还有对象查询语言（OQL）和 XQuery。但本文的主题是 XPath，一种为查询 XML 文档而设计的查询语言。比如，下面这个简单的 XPath 查询可以在文档中找到作者为 Neal Stephenson 的所有图书的标题：

//book[author="Neal Stephenson"]/title

作为对照，查询同样信息的纯 DOM 搜索代码如 清单 1 所示：

        ArrayList result = new ArrayList();
        NodeList books = doc.getElementsByTagName("book");
        for (int i = 0; i < books.getLength(); i++) {
            Element book = (Element) books.item(i);
            NodeList authors = book.getElementsByTagName("author");
            boolean stephenson = false;
            for (int j = 0; j < authors.getLength(); j++) {
                Element author = (Element) authors.item(j);
                NodeList children = author.getChildNodes();
                StringBuffer sb = new StringBuffer();
                for (int k = 0; k < children.getLength(); k++) {
                    Node child = children.item(k);
                    // really should to do this recursively
                    if (child.getNodeType() == Node.TEXT_NODE) {
                        sb.append(child.getNodeValue());
                    }
                }
                if (sb.toString().equals("Neal Stephenson")) {
                    stephenson = true;
                    break;
                }

            }

            if (stephenson) {
                NodeList titles = book.getElementsByTagName("title");
                for (int j = 0; j < titles.getLength(); j++) {
                    result.add(titles.item(j));
                }
            }

        }

不论您是否相信，清单 1 中的 DOM 显然不如简单的 XPath 表达式通用或者健壮。您愿意编写、调试和维护哪一个？我想答案很明显。

但是虽然有很强的表达能力，XPath 并不是 Java 语言，事实上 XPath 不是一种完整的编程语言。有很多东西用 XPath 表达不出来，甚至有些查询也无法表达。比方说，XPath 不能查找国际标准图书编码（ISBN）检验码不匹配的所有图书，或者找出境外帐户数据库显示欠帐的所有作者。幸运的是，可以把 XPath 结合到 Java 程序中，这样就能发挥两者的优势了：Java 做 Java 所擅长的，XPath 做 XPath 所擅长的。

直到最近，Java 程序执行 XPath 查询所需要的应用程序编程接口（API）还因形形色色的 XPath 引擎而各不相同。Xalan 有一种 API，Saxon 使用另一种，其他引擎则使用其他的 API。这意味着代码往往把您限制到一种产品上。理想情况下，最好能够试验具有不同性能特点的各种引擎，而不会带来不适当的麻烦或者重新编写代码。

于是，Java 5 推出了 javax.xml.xpath 包，提供一个引擎和对象模型独立的 XPath 库。这个包也可用于 Java 1.3 及以后的版本，但需要单独安装 Java API for XML Processing (JAXP) 1.3。Xalan 2.7 和 Saxon 8 以及其他产品包含了这个库的实现。

回页首

一个简单的例子

我将举例说明如何使用它。然后再讨论一些细节问题。假设要查询一个图书列表，寻找 Neal Stephenson 的著作。具体来说，这个图书列表的形式如 清单 2 所示：

<inventory>
    <book year="2000">
        <title>Snow Crash</title>
        <author>Neal Stephenson</author>
        <publisher>Spectra</publisher>
        <isbn>0553380958</isbn>
        <price>14.95</price>
    </book>
 
    <book year="2005">
        <title>Burning Tower</title>
        <author>Larry Niven</author>
        <author>Jerry Pournelle</author>
        <publisher>Pocket</publisher>
        <isbn>0743416910</isbn>
        <price>5.99</price>
    <book>
 
    <book year="1995">
        <title>Zodiac</title>
        <author>Neal Stephenson<author>
        <publisher>Spectra</publisher>
        <isbn>0553573862</isbn>
        <price>7.50</price>
    <book>

    <!-- more books... -->
 
</inventory>

抽象工厂 XPathFactory 是一个抽象工厂。抽象工厂设计模式使得这一种 API 能够支持不同的对象模型，如 DOM、JDOM 和 XOM。为了选择不同的模型，需要向 XPathFactory.newInstance() 方法传递标识对象模型的统一资源标识符（URI）。比如 http://xom.nu/ 可以选择 XOM。但实际上，到目前为止 DOM 是该 API 支持的惟一对象模型。

查找所有图书的 XPath 查询非常简单：//book[author="Neal Stephenson"]。为了找出这些图书的标题，只要增加一步，表达式就变成了 //book[author="Neal Stephenson"]/title。最后，真正需要的是 title 元素的文本节点孩子。这就要求再增加一步，完整的表达式就是 //book[author="Neal Stephenson"]/title/text()。

现在我提供一个简单的程序，它从 Java 语言中执行这个查询，然后把找到的所有图书的标题打印出来。首先，需要将文档加载到一个 DOM Document 对象中。为了简化起见，假设该文档在当前工作目录的 books.xml 文件中。下面的简单代码片段解析文档并建立对应的 Document 对象：

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true); // never forget this!
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse("books.xml");

到目前为止，这仅仅是标准的 JAXP 和 DOM，没有什么新鲜的。

接下来创建 XPathFactory：

XPathFactory factory = XPathFactory.newInstance();

然后使用这个工厂创建 XPath 对象：

XPath xpath = factory.newXPath();

XPath 对象编译 XPath 表达式：

PathExpression expr = xpath.compile("//book[author='Neal Stephenson']/title/text()");

直接求值 如果 XPath 表达式只使用一次，可以跳过编译步骤直接对 XPath 对象调用 evaluate() 方法。但是，如果同一个表达式要重复使用多次，编译可能更快一些。

最后，计算 XPath 表达式得到结果。表达式是针对特定的上下文节点计算的，在这个例子中是整个文档。还必须指定返回类型。这里要求返回一个节点集：

Object result = expr.evaluate(doc, XPathConstants.NODESET);

可以将结果强制转化成 DOM NodeList，然后遍历列表得到所有的标题：

        NodeList nodes = (NodeList) result;
        for (int i = 0; i < nodes.getLength(); i++) {
            System.out.println(nodes.item(i).getNodeValue()); 
        }

清单 4 把上述片段组合到了一个程序中。还要注意，这些方法可能抛出一些检查异常，这些异常必须在 throws 子句中声明，但是我在上面把它们掩盖起来了：

import java.io.IOException;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import javax.xml.parsers.*;
import javax.xml.xpath.*;

public class XPathExample {

  public static void main(String[] args) 
   throws ParserConfigurationException, SAXException, 
          IOException, XPathExpressionException {

    DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
    domFactory.setNamespaceAware(true); // never forget this!
    DocumentBuilder builder = domFactory.newDocumentBuilder();
    Document doc = builder.parse("books.xml");

    XPathFactory factory = XPathFactory.newInstance();
    XPath xpath = factory.newXPath();
    XPathExpression expr 
     = xpath.compile("//book[author='Neal Stephenson']/title/text()");

    Object result = expr.evaluate(doc, XPathConstants.NODESET);
    NodeList nodes = (NodeList) result;
    for (int i = 0; i < nodes.getLength(); i++) {
        System.out.println(nodes.item(i).getNodeValue()); 
    }

  }

}

XPath 数据模型

每当混合使用诸如 XPath 和 Java 这样两种不同的语言时，必定会有某些将两者粘合在一起的明显接缝。并非一切都很合拍。XPath 和 Java 语言没有同样的类型系统。XPath 1.0 只有四种基本数据类型：

• node-set
• number
• boolean
• string

当然，Java 语言有更多的数据类型，包括用户定义的对象类型。

多数 XPath 表达式，特别是位置路径，都返回节点集。但是还有其他可能。比如，XPath 表达式 count(//book) 返回文档中的图书数量。XPath 表达式 count(//book[@author="Neal Stephenson"]) > 10 返回一个布尔值：如果文档中 Neal Stephenson 的著作超过 10 本则返回 true，否则返回 false。

evaluate() 方法被声明为返回 Object。实际返回什么依赖于 XPath 表达式的结果以及要求的类型。一般来说，XPath 的

• number 映射为 java.lang.Double
• string 映射为 java.lang.String
• boolean 映射为 java.lang.Boolean
• node-set 映射为 org.w3c.dom.NodeList

XPath 2 前面一直假设您使用的是 XPath 1.0。XPath 2 大大扩展和修改了类型系统。Java XPath API 支持 XPath 2 所需的主要修改是为返回 XPath 2 新数据类型增加常量。

在 Java 中计算 XPath 表达式时，第二个参数指定需要的返回类型。有五种可能，都在 javax.xml.xpath.XPathConstants 类中命名了常量：

• XPathConstants.NODESET
• XPathConstants.BOOLEAN
• XPathConstants.NUMBER
• XPathConstants.STRING
• XPathConstants.NODE

最后一个 XPathConstants.NODE 实际上没有匹配的 XPath 类型。只有知道 XPath 表达式只返回一个节点或者只需要一个节点时才使用它。如果 XPath 表达式返回了多个节点并且指定了 XPathConstants.NODE，则 evaluate() 按照文档顺序返回第一个节点。如果 XPath 表达式选择了一个空集并指定了 XPathConstants.NODE，则 evaluate() 返回 null。

如果不能完成要求的转换，evaluate() 将抛出 XPathException。

名称空间上下文

若 XML 文档中的元素在名称空间中，查询该文档的 XPath 表达式必须使用相同的名称空间。XPath 表达式不一定要使用相同的前缀，只需要名称空间 URI 相同即可。事实上，如果 XML 文档使用默认名称空间，那么尽管目标文档没有使用前缀，XPath 表达式也必须使用前缀。

但是，Java 程序不是 XML 文档，因此不能用一般的名称空间解析。必须提供一个对象将前缀映射到名称空间 URI。该对象是 javax.xml.namespace.NamespaceContext 接口的实例。比如，假设图书文档放在 http://www.example.com/books 名称空间中，如 清单 5 所示：

<inventory xmlns="http://www.example.com/books">
    <book year="2000">
        <title>Snow Crash</title>
        <author>Neal Stephenson</author>
        <publisher>Spectra</publisher>
        <isbn>0553380958</isbn>
        <price>14.95<price>
    </book>

    <!-- more books... -->

<inventory>

查找 Neal Stephenson 全部著作标题的 XPath 表达式就要改为 //pre:book[pre:author="Neal Stephenson"]/pre:title/text()。但是，必须将前缀 pre 映射到 URI http://www.example.com/books。NamespaceContext 接口在 Java 软件开发工具箱（JDK）或 JAXP 中没有默认实现似乎有点笨，但确实如此。不过，自己实现也不难。清单 6 对一个名称空间给出了简单的实现。还需要映射 xml 前缀。

import java.util.Iterator;
import javax.xml.*;
import javax.xml.namespace.NamespaceContext;

public class PersonalNamespaceContext implements NamespaceContext {

    public String getNamespaceURI(String prefix) {
        if (prefix == null) throw new NullPointerException("Null prefix");
        else if ("pre".equals(prefix)) return "http://www.example.org/books";
        else if ("xml".equals(prefix)) return XMLConstants.XML_NS_URI;
        return XMLConstants.NULL_NS_URI;
    }

    // This method isn't necessary for XPath processing.
    public String getPrefix(String uri) {
        throw new UnsupportedOperationException();
    }

    // This method isn't necessary for XPath processing either.
    public Iterator getPrefixes(String uri) {
        throw new UnsupportedOperationException();
    }

}

使用映射存储绑定和增加 setter 方法实现名称空间上下文的重用也不难。

创建 NamespaceContext 对象后，在编译表达式之前将其安装到 XPath 对象上。以后就可以像以前一样是用这些前缀查询了。比如：

  XPathFactory factory = XPathFactory.newInstance();
  XPath xpath = factory.newXPath();
  xpath.setNamespaceContext(new PersonalNamespaceContext());
  XPathExpression expr 
    = xpath.compile("//pre:book[pre:author='Neal Stephenson']/pre:title/text()");

  Object result = expr.evaluate(doc, XPathConstants.NODESET);
  NodeList nodes = (NodeList) result;
  for (int i = 0; i < nodes.getLength(); i++) {
      System.out.println(nodes.item(i).getNodeValue()); 
  }

函数求解器

有时候，在 Java 语言中定义用于 XPath 表达式的扩展函数很有用。这些函数可以执行用纯 XPath 很难或者无法执行的任务。不过必须是真正的函数，而不是随意的方法。就是说不能有副作用。（XPath 函数可以按照任意的顺序求值任意多次。）

通过 Java XPath API 访问的扩展函数必须实现 javax.xml.xpath.XPathFunction 接口。这个接口只声明了一个方法 evaluate：

public Object evaluate(List args) throws XPathFunctionException

该方法必须返回 Java 语言能够转换到 XPath 的五种类型之一：

• String
• Double
• Boolean
• Nodelist
• Node

比如，清单 8 显示了一个扩展函数，它检查 ISBN 的校验和并返回 Boolean。这个校验和的基本规则是前九位数的每一位乘上它的位置（即第一位数乘上 1，第二位数乘上 2，依次类推）。将这些数加起来然后取除以 11 的余数。如果余数是 10，那么最后一位数就是 X。

import java.util.List;
import javax.xml.xpath.*;
import org.w3c.dom.*;

public class ISBNValidator implements XPathFunction {

  // This class could easily be implemented as a Singleton.
    
  public Object evaluate(List args) throws XPathFunctionException {

    if (args.size() != 1) {
      throw new XPathFunctionException("Wrong number of arguments to valid-isbn()");
    }

    String isbn;
    Object o = args.get(0);

    // perform conversions
    if (o instanceof String) isbn = (String) args.get(0);
    else if (o instanceof Boolean) isbn = o.toString();
    else if (o instanceof Double) isbn = o.toString();
    else if (o instanceof NodeList) {
        NodeList list = (NodeList) o;
        Node node = list.item(0);
        // getTextContent is available in Java 5 and DOM 3.
        // In Java 1.4 and DOM 2, you'd need to recursively 
        // accumulate the content.
        isbn= node.getTextContent();
    }
    else {
        throw new XPathFunctionException("Could not convert argument type");
    }

    char[] data = isbn.toCharArray();
    if (data.length != 10) return Boolean.FALSE;
    int checksum = 0;
    for (int i = 0; i < 9; i++) {
        checksum += (i+1) * (data[i]-'0');
    }
    int checkdigit = checksum % 11;

    if (checkdigit + '0' == data[9] || (data[9] == 'X' && checkdigit == 10)) {
        return Boolean.TRUE;
    }
    return Boolean.FALSE;

  }

}

下一步让这个扩展函数能够在 Java 程序中使用。为此，需要在编译表达式之前向 XPath 对象安装 javax.xml.xpath.XPathFunctionResolver。函数求解器将函数的 XPath 名称和名称空间 URI 映射到实现该函数的 Java 类。清单 9 是一个简单的函数求解器，将扩展函数 valid-isbn 和名称空间 http://www.example.org/books 映射到 清单 8 中的类。比如，XPath 表达式 //book[not(pre:valid-isbn(isbn))] 可以找到 ISBN 校验和不匹配的所有图书。

iimport javax.xml.namespace.QName;
import javax.xml.xpath.*;

public class ISBNFunctionContext implements XPathFunctionResolver {

  private static final QName name 
   = new QName("http://www.example.org/books", "valid-isbn");

  public XPathFunction resolveFunction(QName name, int arity) {
      if (name.equals(ISBNFunctionContext.name) && arity == 1) {
          return new ISBNValidator();
      }
      return null;
  }

}

由于扩展函数必须有名称空间，所以计算包含扩展函数的表达式时必须使用 NamespaceResolver，即便查询的文档没有使用任何名称空间。由于 XPathFunctionResolver、XPathFunction 和 NamespaceResolver 都是接口，如果方便的话可以将它们放在所有的类中。

结束语

用 SQL 和 XPath 这样的声明性语言编写查询，要比使用 Java 和 C 这样的命令式语言容易得多。但是，用 Java 和 C 这样的图灵完整语言编写复杂的逻辑，又比 SQL 和 XPath 这样的声明性语言容易得多。所幸的是，通过使用 Java Database Connectivity (JDBC) 和 javax.xml.xpath 之类的 API 可以将两者结合起来。随着世界上越来越多的数据转向 XML，javax.xml.xpath 将与 java.sql 一样变得越来越重要。

  2、安装：

    很简单，把p6spy-1.x.jar和sqlprofiler.jar拷贝到自己的应用的WEB-INF/lib下即可。

  3、配置：

    1）修改你 原有 JDBC Driver为：com.p6spy.engine.spy.P6SpyDriver，如果你用了连接池，一回事，把driver换掉；
    2）修改 spy.properties 中的 realdriver 值为 原有 的JDBC Driver，比如我的是：realdriver=com.ibm.db2.jcc.DB2Driver
    3) 还有，注意把appender设置正确：
#The following are for log4j logging only
#log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
#log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
#log4j.appender.STDOUT.layout.ConversionPattern=p6spy - %m%n

log4j.appender.SQLPROFILER_CLIENT=org.apache.log4j.net.SocketAppender
log4j.appender.SQLPROFILER_CLIENT.RemoteHost=localhost
log4j.appender.SQLPROFILER_CLIENT.Port=4445
log4j.appender.SQLPROFILER_CLIENT.LocationInfo=true

#log4j.logger.p6spy=INFO,STDOUT
log4j.logger.p6spy=DEBUG, SQLPROFILER_CLIENT

  4、一般使用：

    1）在DOS命令行切换到刚才的WEB-INF/lib目录下，运行：java -jar sqlprofiler.jar，即可启动SQL Profiler的GUI界面(如果报告OutOfMemory错误，则以命令行“java -Xmx256m -jar sqlprofiler.jar”启动)；
    2）正常启动服务，允许web server，即可在SQL Profiler的GUI界面看到所有的JDBC操作。

  5、高级应用SQL Profiler：

    1）可以生成SQL执行情况报表：点击“pause”按钮，即可产生profiler result；
    2）很cool的是，点击最左边的按钮，可以根据整个运行情况生成数据库索引的创建脚本，我们可以根据这些脚本生成自己的数据库索引，数据库tuning的工作是不是变得越来越简单or傻瓜了呢？呵呵。
    3）其他的包括图形分析报表，自己挖掘吧；
    4）如果用loadRunner、web stress tool等压力测试工具run一把，那么这个报表和索引创建建议就更加逼真和有效了。