—  void assertNoFault(Document node)：确认SOAP响应报文无错误；

—  java.util.List assertValid(java.lang.String xpath, java.lang.Object node)：确认在DOM节点特定路径下有对应的元素，路径通过XPath表达式进行定义，该方法还将匹配的元素以List对象返回，用户可以对匹配的元素进行进一步检验；

—  void assertXPathEquals(java.lang.String xpath, java.lang.String value, Document node)：确认特定路径DOM节点为某一特定值；

—  assertInvalid(java.lang.String xpath, java.lang.Object node)：确认DOM节点特定路径下未包含元素。

AbstractXFireSpringTest是AbstractXFireTest的子类，在Spring中用户只需要扩展该类并实现该类的抽象方法ApplicationContext createContext()，就可以对Spring容器中用XFire定义的Web Service进行测试了。

为了测试Web Service，我们必须准备一个SOAP请求报文，用户可以简单地手工编写一个，或通过SOAP报文截取工具（如前面我们介绍的TcpTrace、SOAPScope、Apache Axis的TCPMon等）获得一些可用的SOAP请求报文。代码清单16-6是一个访问BbtForumService 服务的请求SOAP报文：

代码清单16-6  request_soap.xml：SOAP报文层面测试

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"

    xmlns:xsd="http://www.w3.org/2001/XMLSchema"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <soap:Body>

        <getRefinedTopicCount

            xmlns="http://server.xfire.baobaotao.com">

            <in0 xmlns="http://server.xfire.baobaotao.com">20</in0>

        </getRefinedTopicCount>

    </soap:Body>

</soap:Envelope>

我们将其保存在request_soap.xml文件中，放置在类路径com/baobaotao/xfire/server下。当该SOAP请求报文发送给BbtForumService的Web Service后，我们预计它应该返回如代码清单16-7所示的正确的SOAP响应报文：

代码清单16-7  SOAP响应报文

<?xml version="1.0" encoding="UTF-8"?>

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <soap:Body>

    <getRefinedTopicCountResponse xmlns="http://www.baobaotao.com">

      <out>32</out>

    </getRefinedTopicCountResponse>

  </soap:Body>

</soap:Envelope>

下面，我们着手编写测试BbtForumService Web Service的测试类，以验证实际SOAP响应报文是否和代码清单16-7中的一样：

代码清单16-8  TestBbtForumService

使用AbstractXFireSpringTest测试Web Service首先要做的第一件事是通过实现createContext()方法构造Spring容器，如①所示。当Spring容器启动时，XFire将自动让容器中的Web Service生效（仅进行测试，不能对外提供服务）。

第二步需要向Web Service发送一个SOAP请求报文以得到一个SOAP响应报文，如②所示。接下来，通过AbstractXFireTest提供的检测DOM内容的方法对报文进行正确性验证。由于代码清单16‑7的SOAP报文体中对应的<getRefinedTopicCountResponse>元素及内部元素都位于http://www.baobaotao.com命名空间中，报文体中没有为这个命名空间定义相应的别名，为了在后续断言方法中能够使用简单的方式定义XPath表达式，我们在④处为http://www.baobaotao.com命名空间定义了一个别名。

理解以上测试代码中几个断言方法的关键在于理解XPath表达式语言，XPath语法内容很丰富，不可能在这里逐一讲解，我们只介绍一些典型的XPath语法以满足常见的测试需求：

— 以“/”为前缀的路径表示从DOM根路径开始，如“/soap:Envelope/soap:Body”；

— 以“//”为前缀的路径表示从DOM任意元素开始查询，如“//out”表示任意元素为out的元素；

— 元素的属性通过@attrName表示，如“//xsd:complexType[@name=""Book""]”表示DOM中任意元素名为complexType并且拥有一个值为Book的name属性的元素；

— 元素的值通过text()表示，如“//test:Response[text()='32']”表示DOM中任意值为32、元素名为Response，且位于test命名空间中的元素。

现在回过头来看⑤、⑥两处的断言方法，相信大家就可以很容易地理解断言规则了，⑤处的断言检测SOAP响应报文是否包含某一特定元素，而⑥处的断言则对元素内的值进行检测。我们也可以通过printNode()方法将一个节点输出到控制台上，以便于查看。

16.5.2  在JVM模式通过客户端进行测试

能够不启动Web服务器的情况下通过客户端程序测试Web Service的功能，这一崭新的测试方法对于开发人员来说一定颇具吸引力。因为，这意味着用户可以完全在IDE环境中运行测试，不需要外部环境的支持。不过享受这一测试好处的应用必须保证客户端和服务端的Web Service都位于同一JVM中，这时请求报文和响应报文直接在JVM内部通道中传输。当使用JVM内部通道传输请求和响应的SOAP报文时，我们只需要调整服务的地址就可以了：

代码清单16-9  TextBbtForumService  JVM模式测试

以上代码中，①处的服务地址采用了JVM模式的地址，和其对应的HTTP地址则是http://localhost:8080/baobaotao/service/BbtForumService，所以只需要将服务名前的部分替换为“xfire.local://”就可以了。

下面是XFire客户端调用的流程分析图，本文后续本分将围绕该图展开。

XFire客户端的调用非常灵活，可以有很多种方式，如通过配置调用、通过API编程调用或者与Spring等IoC框架集成使用。虽然调用方式灵活多样，但万变不离其中，其内部流程是一致的。

创建服务模型

服务模型是XFire中非常重要的概念之一，包含了服务的接口信息、操作信息、Binding信息等诸多服务调用过程中需要的信息。因此在进行服务调用之前首先要创建服务模型。创建服务模型的工作是由服务工厂ServiceFactory完成的，用户需要为服务工程提供服务接口、名称、命名空间等一些信息，其中服务接口是必须的，其他为可选信息。

创建Client实例

Client是XFire客户端的核心组成部分，间接的代表了一个服务。当为具体某个服务配置拦截器（Handler，有很多种译法如拦截器、处理器、过滤器等，本文统一用拦截器）时，其实是将拦截器信息应用到Client实例上。Client可以手工创建也可以由XFireProxyFactory创建，无论通过哪种方式，Client在初始化过程中最重要的一步都是在out拦截器堆栈中增加一个OutMessageSender拦截器。该拦截器负责最终将服务调用通过HTTP发送到服务提供者并返回处理结果。本文后续部分还会对OutMessageSender做更加详细的讲解。

创建服务代理对象

XFireProxy，XFire SOAP客户端代理实现，用户调用服务时（如Hello.echo(“tony”)）就是通过该对象的invoke方法来执行。实际上，XFireProxy只是将调用代理到Client实例，最终执行服务的还是Client实例。

构造调用链信息

Client实例的invoke方法在执行时，生成了一个Invocation对象，该对象构造了一次完整的调用信息，包括OutMessage、MessageContext等。同时Invocation还负责构造一个拦截器管道（HandlerPipeline），该管道包含了本次调用需要执行的所有拦截器，当然也包括OutMessageSender。这些拦截器会分不同的阶段来执行，这也是XFire一个特性。XFire默认定义了很多阶段（Phase），每个阶段都会有若干拦截器被调用。

循环调用拦截器

拦截器（Handler）是XFire中最为重要的概念，一次服务调用就是由若干拦截器组合完成的。XFire默认提供了很多预定义的拦截器，用户也可以定义自己的拦截器。基本上，通过拦截器可以影响XFire执行过程中的任何步骤，你可以为所欲为：）

拦截器有两个重要的概念，一个是阶段（Phase），一个是顺序（Order）。这两个因素共同决定了拦截器的执行顺序。可以在三个不同的地方配置拦截器：

n         XFire实例：全局拦截器，对所有通道上的所有服务起作用

n         Transport：通道特定的拦截器，只对该通道（如HTTP、JMS）起作用

n         具体服务：服务特定的拦截器，只对该服务起作用

其实，具体服务上的拦截器最终是配置到Client上。对于同一个阶段上的拦截器，执行顺序为“具体服务—>Transport—>XFire实例”。千万不要忽视这些顺序，这对你正确的使用拦截器非常有帮助。

发送远程服务请求

这是整个调用链中最后的一环，也是最关键的一步。OutMessageHandler，前文已经有所提及，是一个特殊的拦截器，在Client初始化时创建并加入调用链中。该拦截器处于拦截器调用链的Phase.SEND阶段，基本上也是最后的阶段。OutMessageHandler从当前调用的消息上下文（MessageContext）中获取请求的服务地址URI以及SOAP消息，然后通过HTTP将SOAP请求发送到远程服务器（针对HTTP通道，如果是JMS通道则发送到指定的目的地）。最终将远程服务器的响应逐级返回给调用者。

案例分析

前文很多地方都提到Handler非常重要，那么具体有那些应用场景呢？本部分通过两个案例逐步演示Handler的应用。

一、             简单安全验证

这是一个非常典型的应用场景，假设A公司对外提供了一个旅程信息查询服务，该服务通过XFire对外发布。但是A公司只希望其合作伙伴才能使用该服务，那么A公司可以为该服务配置一个Handler，该Handler从SOAP的消息头中获取认证字符串，只有通过验证的请求才被执行。下面是简单的示例代码，真实情况要比这复杂得多。

对于A公司的合作伙伴，要想调用该服务，必须在其SOAP的消息头中包含上面代码中的验证字符串，否则服务将被拒绝。下面是简单的示例代码：

二、             查找真实服务

这是一个比较特殊的应用场景：假设A公司已经初步实现SOA，拥有一个服务注册中心，所有的XFire服务都在该中心注册。客户端在调用服务时需要动态的从该服务注册中心获取当前的服务地址及版本。通过其他方式肯定也可以实现该需求，但是通过Handler来实现会非常的幽雅，而且对应用不需要做任何变动。我们先来看一下Handler的代码：

正如代码所示，只需要从context中获取当前请求的服务URI地址，然后用当前请求环境信息及服务URI地址到服务注册中心查找真实的服务，并重新设置服务的地址。

结束语

本文粗略的介绍了XFire客户端的调用流程，并着重讲解了Handler的扩展机制及其应用场景，力求读者能够通过本文对XFire能有更加深入的了解和掌握。文中难免存在不足之处，欢迎任何形式的交流。

二、基础工作

1.开发环境
我使用axis做为Web Service引擎，它是Apache的一个开源web service引擎。它目前最为成熟的开源web service引擎之一。下面我主要介绍一下如何使用Axis搭建web service 服务的环境。
①安装tomcat5.0应用服务器（也可以装5.5，不过我一直在用5.0）;
②解压下载（ http://ws.apache.org/Axis）后的axis包，将包中axis目录复制到tomcat目录下的webapps目录下；　　
③将axis/WEB-INF/lib目录下类文件复制到tomcat目录下的common/lib目录下；
④重新启动tomcat,访问http://localhost:8080/axis/happyaxis.jsp,如果能访问，表示安装成功；
注意，axis有几个可选的包，如email.jar....，你可以找来放到tomcat目录下的common/lib目录下，如果不使用相关的功能也可以不用。
这样，开发环境就搭建好了。


2.如何部署Web Service
部署有三种方式：Dynamic Invocation Interface(DII)、Stubs方式、Dynamic Proxy方式；这里就介绍一下简单，也是我使用的方式：DII。
DII方式中，先写好服务的JAVA文件（假设名字为helloworld.java），然后把它（注意是源文件）拷贝到webapps/axis目录 中，后缀改成jws(此时文件名为：helloworld.jws)，然后访问连接http://localhost: 8080/Axis/helloworld.jws?wsdl，页面显示Axis自动生成的wsdl，这样一个Web Service就部署好了。怎么样，是不是很简。
我的计数器服务就是以这种方式部署的，下文中我会只说将计数器服务部署好，你可不要说：怎么部署，我不会呀。那在古代就要被打手板了。所以我想，古代只学四书五经也是件好事呀。现在要学这么多东西，半天学不会，手要被打烂了。

三、计数器服务的编写
计数器大家都知道了，比较简单。我的计数器也同样简单，有以下功能及特点：提供四种计数器（总数器、月计数器、周计数器及日计数器）；考虑到Web Service要服务于多种应用，这个计数器还支持多个用户；使用XML文件来记录数据。
记录文件名为：d:"counter.xml。注意，此文件在服务里是硬编码，如果修改名字，请在服务程序中也进行相应的修改。文件内容格式如下：
<?xml version="1.0" encoding="UTF-8"?>
<counter>
<item>
<name>wallimn</name>
<password>123</password>
<dc>59</dc>
<wc>59</wc>
<mc>59</mc>
<tc>59</tc>
<rt>2007-4-16 16:01:29</rt>
</item>
<counter>
说是计数器服务，其实跟编写普通的JAVA应用没有什么两样。我的计数器代码比较简单，我就不做过多的介绍了，把它贴在下面，源码中有少量注释，相信大家不看注释也看得懂。服务有只有一个接口：Counter(String name, String password),以后在客户端拿来用就可以了。还多说一句，我和程序使用到了dom4j解析xml包，要调试的请自行准备好jar包。部署方法请参照上文。
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
/**
*功能：提供计数器服务的WebService，可以为多用户提供服务。<br/>
* @version : V1.0
* @author : 王力猛(Email: wallimn@sohu.com QQ: 54871876)
* @date : 2007-4-16 下午04:32:45
*/
public class WsCounterByWallimn {
//计数器文档，注意名字名路径。
private final String FileN = "d:/counter.xml";
private final static DateFormat DATEFORMATER = DateFormat.getDateTimeInstance();
//出错的情况下返回的值
private final static String ERRORINFO="-1;-1;-1;-1";
public WsCounterByWallimn(){ }


/**
*功能：打开计数器文档<br/>
*编码：王力猛 时间：2007-4-16 下午04:44:29<br/>
*/
private Document openDocument(){
Document doc=null;
SAXReader reader = new SAXReader();
try {
File xmlfile = new File(FileN);
doc = reader.read(xmlfile);
xmlfile=null;
}
catch (DocumentException e) {
e.printStackTrace();
}
return doc;
}


/**
*功能：取指定名称计数器的详细信息，并设置计数器加1。<br/>
*编码：王力猛 时间：2007-4-16 下午04:49:57<br/>
*/
private synchronized String countertick( String name, String password){
Document doc = openDocument();
Date currdt = new java.util.Date();
//mc:month counter(月计数器); dc: day counter(日计数器);
//tc: total counter(总计数器); wc: week counter(周计数器);
//rt: registe time登记时间
String mc="-1",dc="-1",tc="-1",wc="-1",rt="-1";
Element root = doc.getRootElement();
Element selitem=null,item=null;
for(Iterator it = root.elementIterator("item"); it.hasNext();){
item = (Element)it.next();
if(name.equals(item.element("name").getText())){
selitem=item;
String pwd = item.elementText("password");
if(!password.equals(pwd)){
return ERRORINFO;//密码不对，直接返回
}
mc=item.element("mc").getText();
dc=item.element("dc").getText();
tc=item.element("tc").getText();
wc=item.element("wc").getText();
rt=item.element("rt").getText();
break;
}
}

//如果selitem为空，说明没有个名字的计数器。则添加一个。
if(selitem==null){
//System.out.println("没有找到这个名字的计数器："+name);
rt=DATEFORMATER.format(currdt);
selitem = doc.getRootElement().addElement("item");
selitem.addElement("name").setText(name);
selitem.addElement("tc").setText("0");
selitem.addElement("mc").setText("0");
selitem.addElement("wc").setText("0");
selitem.addElement("dc").setText("0");
selitem.addElement("rt").setText(rt);
selitem.addElement("password").setText(password);
mc="0";
wc="0";
dc="0";
tc="0";
}

//处理计数器加一操作。
Calendar currcr=Calendar.getInstance();
//总数器总是加1。
tc =String.valueOf(Integer.parseInt(tc)+1);
selitem.element("tc").setText(tc);
Date lastdt = null;
try {
lastdt = DATEFORMATER.parse(rt);
}
catch (ParseException e) {
lastdt = new java.util.Date();
}
Calendar lastcr = Calendar.getInstance();
lastcr.setTime(lastdt);
currcr.setTime(currdt);
//System.out.println("上次登记时间："+DATEFORMATER.format(lastdt));
//System.out.println("本次登记时间："+DATEFORMATER.format(currdt));
if(lastcr.get(Calendar.YEAR)==currcr.get(Calendar.YEAR)){
//月相同，月计数加1
if(lastcr.get(Calendar.MONTH)==currcr.get(Calendar.MONTH)){
mc = String.valueOf(Integer.parseInt(mc)+1);
}
else{
mc="1";
}
//日相同，日计数加1
if(lastcr.get(Calendar.DAY_OF_YEAR)==currcr.get(Calendar.DAY_OF_YEAR))
dc = String.valueOf(Integer.parseInt(dc)+1);
else
dc = "1";

if(lastcr.get(Calendar.WEEK_OF_YEAR)==currcr.get(Calendar.WEEK_OF_YEAR))
wc = String.valueOf(Integer.parseInt(wc)+1);
else
wc = "1";
}
else{//年不一样，则月计数器、周计数器日计数器肯定也不一样。
mc="1"; dc="1"; wc="1";
}
selitem.element("mc").setText(mc);
selitem.element("wc").setText(wc);
selitem.element("dc").setText(dc);
//登记记录时间
selitem.element("rt").setText(DATEFORMATER.format(currdt));

try {
XMLWriter xw = new XMLWriter(new FileWriter(FileN));
xw.write(doc);
xw.close();
}
catch (IOException e) {
e.printStackTrace();
}
return tc+";"+mc+";"+wc+";"+dc;
}
/**
*功能：服务暴露的接口，也就是指定名称、密码，返回指定的计数，并将计数器加1。<br/>
*编码：王力猛 时间：2007-4-17 上午10:05:22<br/>
*/
public String Counter(String name, String password){
if(password==null || name==null)return ERRORINFO;
return countertick(name, password);
}
}

四、客户端编写
客户端是个页面，为了条理清晰，我先写个调用Web Service的类，其内容如下：
package com.wallimn.WebService;//调试请注意包名

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class CounterServiceClient {
private String counterarr[];

public boolean getCounter(String CounterName, String password) {
boolean res = false;
try {
String endpoint = "http://localhost:8080/axis/WsCounterByWallimn.jws";//此处注意，请与你的开发环境匹配
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress(new java.net.URL(endpoint));
call.setOperationName("Counter");
// 填写你要调用的方法名称
String counter = (String) call.invoke(new Object[] { CounterName, password });
counterarr = counter.split(";");
res = (counterarr != null && counterarr.length == 4);
}
catch (Exception e) {
}
return res;
}

public String getDc() {
return counterarr[3];
}

public String getMc() {
return counterarr[1];
}

public String getTc() {
return counterarr[0];
}

public String getWc() {
return counterarr[2];
}
}

　　到页面(test.jsp)上就简单了，我也把它贴在下面：
<%@ page language="java" import="com.wallimn.WebService.CounterServiceClient" pageEncoding="GB18030"%>
<%
CounterServiceClient client = new CounterServiceClient();
client.getCounter("hello","123");
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>计数器测试页面</title>

<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="wallimn,计数器,WebService">
<meta http-equiv="description" content="计数器使用示例">
</head>

<body>
<h2 align="center">计数器详情</h2>
<hr/>
总访问量:<%=client.getTc()%> <br/>
今天访问量:<%=client.getDc()%> <br/>
本周访问量:<%=client.getWc()%> <br/>
本月访问量:<%=client.getMc()%> <br/>
<hr/>
<p>欢迎交流<br/>博客：http://blog.csdn.net/wallimn<br/>电邮：wallimn@sohu.com</p>
</body>
</html>

五、结束语

基于发布在JavaEye的敬畏心情，本文又修改了一遍，与前两天发在blogjava和csdn的版本稍有不同。

1. 概述

   XFire 是全球众多牛人在与axis系列对比后一致投票的选择。我比较欣赏的特性有：

1. 与Spring整合，无须生成一堆文件，无须打包独立war，直接将应用中的Pojo导出为Web服务。
2. Aegis--超简约的默认Java XML 绑定机制，且可以Plugin其他绑定机制。
3. JSR181--annotatiton驱动的POJO WebService配置。
4. 基于Stax的高性能框架。
5. 脱离Web服务器的单元测试能力。

   网上的文档与例子总是不新，请大家抛开所有的文档，所有的Axis习惯，单看这份代表XFire1.2.2最简约做法的指南。

2. 生火指南

2.1 修改web.xml，在Web应用中增加XFire的入口

   注意XFire有了自己的Servlet，不再依赖Spring MVC的DispatchServlet，也就远离了大家不熟悉的Spring MVC URL Mapping，与Spring达致完美的整合。

   这里指定了路径为/service/* ，即WebService的URL会被默认生成为http://www.xxx.com/yyy/service/BookServiceservice/ServiceName，其中ServiceName默认为下文中的接口名。

xml 代码


    
<servlet>  
    
     <servlet-name>xfireservlet-name>  
    
     <servlet-class>org.codehaus.xfire.spring.XFireSpringServletservlet-class>  
    
 servlet>  
    
 <servlet-mapping>  
    
     <servlet-name>xfireservlet-name>  
    
     <url-pattern>/service/*url-pattern>  
    
    servlet-mapping>     

   如果应用使用了Hibernate，使用了OpenSessionInView Filter，注意配置OSIV Filter Filter覆盖xfire servlet的路径，即本例中的/service/*.

2.2 编写窄接口，抽取POJO中要导出的服务

   从已有的BookManager.java中，抽取出一个窄接口，仅暴露需要导出为Web Service的方法。而BookManger.java是POJO，不需要任何WebService相关代码。

  窄接口一方面满足了安全要求，不用整个BookManager所有方法导出为Web Service；另一方面，XFire暂时也只支持基于接口的Proxy。

public interface BookService {

List findBooksByCategory(String cateoryId);

}

 2.3 配置Java-XML Binding

   XFire默认的Aegis Binding语法非常简单，在SpringSide的例子里几乎一行配置都不用写，是我见过最简单的binding定义，大大优于其他以设计复杂为终极目标的方案。

   对象的属性、函数的参数和返回值如果为int、String、Date等普通类型以及由普通类型组成的复杂对象都无需定义。我见到只有两种情况需要定义：

• 无法使用泛型定义Collection中元素的类型时--如List findBooks()。如果能写成List findBooks()就也不需要了。
• 需要为属性定义不同的名字，或者定义复杂对象里的某些属性不要输出。

     如果实在需要aegis配置， XFire以约定俗成代替配置(CoC)，所有Service和Entity Bean的binding文件要求命名为xxx.aegis.xml，而且要和原来的类sit together在同一目录里。

   其他语法详见Aegis 参考。

2.4 配置Spring导出

    为了节约配置代码，先配置一个基类。注意导出Web服务的Bean不能lazy-init：

  
<import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/>  
  
<bean id="baseWebService" class="org.codehaus.xfire.spring.remoting.XFireExporter" lazy-init="false" abstract="true">  
  <property name="serviceFactory" ref="xfire.serviceFactory"/>  
  <property name="xfire" ref="xfire"/>  
 bean>  

 每个Web服务的定义：parent为前面定义的基类，serviceClass 为Web Service的接口，serviceBean为Web Service的接口实现类。

Web服务导出完毕，用户可在http://localhost/service/BookService?WSDL查看自动生成的WSDL。 

上半章完，关于JSR181,Client API与测试部分请看XFire 生火指南(下)

作者：江南白衣

本文来自SpringSide WIki，请留意Wiki上的最新版本。(wiki于11.27更新)。

请先阅读：XFire生火指南(上)

1. JSR181

     JSR181式通过annotated POJO ，零配置文件的导出Web服务，是BEA倡导的，JavaEE5里的正规方式， XFire作了良好的支持。

     但是，XFire关于JSR181方式的文档还不够清晰，请完整阅读本节以避免其中的数个陷阱。

1.1 参考文章

• Spring, Hibernate and XFire
• Webservices with Spring, XFire and jsr181
• Basic Spring Web services with XFire and JSR 181
• XFire JSR181参考文档

1.2 ApplicationContext.xml

    因为配置都写在annotation，applicationContext.xml文件的内容比较固定。需要注意JSR181WebAnnotations与HandlerMapping不能lazy init.

<beans default-autowire="byName"  default-lazy-init="true">
  <!--引入XFire的预配置文件-->
 <import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/> 

 <!-- 获得applicationContext中所有bean的JSR181 annotation -->
 <bean id="webAnnotations" class="org.codehaus.xfire.annotations.jsr181.Jsr181WebAnnotations"  lazy-init="false"/>


 <!-- 定义handler mapping,将所有JSR181定义的bean导出为web service -->
 <bean id="jsr181HandlerMapping" class="org.codehaus.xfire.spring.remoting.Jsr181HandlerMapping"  lazy-init="false">
  <property name="xfire" ref="xfire"/>
  <property name="webAnnotations" ref="webAnnotations"/>
 </bean>
</beans>

1.3 Interface+Impl模式

   不同于XFire传统模式，窄接口不是必须的，只是考虑到client如果也使用XFire时，有个接口好生成Client而已。

   如果采用Interface，Interface将担任主要的配置工作。

   首先定义@WebService，可定义自己的NameSpace，如果不定义将采用NameSpace的默认生成算法。

   接口中的函数将默认全部导出，不需要再用@WebMethod注释，可以如下例般进行更进一步配置：

       Manager不是纯粹的POJO，需要带上@WebService注释，指明InterFace。

      陷阱一：XFire JSR181参考文档 中在Interface中以@WebService(name="BookService")来定义ServiceName，这个做法看起来也比较合理，但实际上需要在Manager中以@WebService(serviceName ="BookService") 来定义，比较古怪。

1.4 纯POJO模式

    参考文档中的例子，需要配置@WebMethod 指定需要导出的服务

1.5 Client注意事项

    陷阱二：和传统模式的client有一点最大的区别，第3个参数需要是实际的Manager类，而不是接口类：

Service serviceModel = new AnnotationServiceFactory().create(BookManager.class);

2. Client

XFire的Client并不算强项，一共有三种模式：

2.1 Client开发者拥有Web服务端的class

  Client与Server是同一个开发团队也好，Server端团队以jar形式提供开发包也好，反正如果能拿到服务端的接口Class和Entity类及aegis 配置文件的话。

  传统模式：

Service serviceModel = new ObjectServiceFactory().create(BookService.class);
BookService service = (BookService) new XFireProxyFactory().create(serviceModel, serviceURL);
service.findBooksByCategory(cateoryId);

  JSR181模式，注意这里Server端开发组需要向Client提供BookService的实现类BookManager，而不止于接口类，有点危险： 

Service serviceModel = new AnnotationServiceFactory().create(BookManager.class);
BookService = (BookService) new XFireProxyFactory().create(serviceModel, serviceURL);
service.findBooksByCategory(cateoryId);

  SpringSide 用泛型封装了一个XFireClientFactory，调用代码如下：

BookService service = XFireClientFactory.getClient(serviceURL, BookService.class);
BookService service = XFireClientFactory.getJSR181Client(serviceURL, BookService.class, BookManager.class);

2.2 动态模式

    动态模式不需要服务端的class，不过性能和复杂对象映射等估计做得不会太好。

Client client = new Client(new URL("http://www.webservicex.net/CurrencyConvertor.asmx?WSDL"));



Object[] results = client.invoke("ConversionRate", new Object[] {"BRL", "UGX"});

2.3 根据WSDL生成Client Stub

    这才是Web Service Client的王道，可以访问任意编写下的Web Service，将在下一个版本中演示。

3. 测试

XFiire很重要的一个特性是提供了无须启动Web容器也能进行单元测试的能力。

原理就是利用XFire的JVM模式，以xfire.local://BookService channel而不是http://localhost/service/BookService来访问服务。

测试的方式分两种：

一种是纯服务器角度，不编写客户端代码，以SOAP XML形式发送请求，返回的也是SOAP XML字串，直接对XML进行测试。

一种是编写2.1 中Client代码来进行测试。

前一种的测试的隔离度较高，而后一种比较简便。

3.1 测试基类 

无论那种方式，都使用Xfire的AbstractXFireSpringTest基类，实现createContext()回调函数。

protected ApplicationContext createContext() {

      return ClassPathXmlApplicationContext(new String[]{"classpath*:applicationContext*.xml"});

 }

另外测试基类还要完成一个很重要的工作就是要解决Hibernate的LazyLoad问题，做到OpenSession In Test。因此，SpringSide专门封装了一个XFireTestCase的基类。

3.2 用Client代码直接测试

     下文直接用client代码调用findBooksByCategory方法，得到返回值后进行各种Assert判断。

     注意和普通client code的两处区别：servericeURL换成local，factory须加入getXFire()作参数。

3.3 纯服务端测试

   编写一段SOAP XML，以任意命名保存，下文以"Java"作参数，调用findBooksByName方法。

   测试代码调用前面的XML，返回XML Document对象，再用基类提供的一些Assert方法检查结果：

  Document doc = invokeService("BookService","/org/springside/xfire/BookService.FindBooksByName.xml");
  assertNoFault(doc);
  addNamespace("ss", "http://domain.commons.bookstore.springside.org");
  assertValid("//ss:Book/ss:category/ss:descn= "Java Book"", doc);

　　Web Services使我们能够在网络上建立分布式系统，应用程序组件可以通过任何平台、任何语言和任何方式访问。无论应用程序如何开发，使用了什么语言，以 及运行在什么操作系统平台上，只要它作为Web Service，并且为协同解决问题而设计，那么你的应用程序，以任何语言开发或在任何平台上，都可以利用它的服务。这是Web Service的主要概念。

　　为了实现Web Services的平台无关性和实现访问独立性，软件行业需要遵循一些作为标准的技术。其中一些包括:

　　---XML:在Web Services环境中各层之间进行传递的默认数据格式。

　　---SOAP:封装和交换信息的默认协议。第一次被提出时，它是只取Simple Object Access Protocol(简单对象访问协议)的首字母。但是现在SOAP更多被认为是一个特定的名词，以它自己而命名，同样很多人认为这是用词不当:SOAP实 际上不是用来访问对象的。另外，它也不再简单。

　　---WSDL(Web Services Description Language，Web Services描述语言):描述Web Services的语言。尽管基于XML并且可以被人理解，WSDL主要是由机器处理，由客户端程序读取和理解。

　　下面的高级层次图表，基于WWW协会发布的“Web Services Architecture”(Web Services架构)文档，显示了这些技术在实际的工作环境中是如何发挥作用:

　　这个流程图显示了Web Services中的核心技术是如何工作的。

　　这里，Provider是提供服务的应用程序组件，Requester是使用服务的客户端程序。很多其他技术也会参与到交互中，但是这个图只显示了在Web Services环境中必需的核心技术组件。

　　XFire是一个免费的开源SOAP框架，它不仅可以极大方便地实现这样一个环境，并且可以提供许多Web Services规范中高级特征，这些特征在多数的商业或者开源工具都没有提供。你要恰当的理解这些单词:great ease and simplicity(非常轻松和简单)。你将会看到使用XFire创建Web Services是多么的简单。

　　一个简单的Java类

　　我们的例子是一个银行业应用程序，服务器是运行在J2SE1.4.2_07下的Apache Tomcat5.5.7。假定你已经了解如何使用Java编写Web应用程序，并知道应该如何把它部署到Apache Tomcat服务器上。我们的Web应用程序非常简单;它只做一件事——将资金从一个账户转到另外一个账户上。一个普通的Java类 BankingService包含了一个叫做transferFunds()的方法来为我们完成这项工作。它需要四个输入参数:

• 　　1、 String fromAccount
• 　　2、 String toAccount
• 　　3、 double amount
• 　　4、 String currency

　　代码如下:

package com.mybank.xfire.example; import java.text.NumberFormat; import java.text.DecimalFormat; /** XFire WebServices sample implementation class. */ public class BankingService implements IBankingService {         //Default constructor.     public BankingService(){        }         /** Transfers fund from one account to another.     */     public String transferFunds(         String fromAccount, String toAccount, double amount, String currency){                 String statusMessage = "";                               //Call business objects and other components to get the job done.         //Then create a status message and return.         try {             NumberFormat formatter = new DecimalFormat("###,###,###,###.00");                   statusMessage = "COMPLETED: " + currency + " " + formatter.format(amount)+             " was successfully transferred from A/C# " + fromAccount + " to A/C# " + toAccount;         } catch (Exception e){             statusMessage = "BankingService.transferFunds(): EXCEPTION: " + e.toString();         }         return statusMessage;     }     }

15.4.1 XFire的标注服务开发

       XFire支持JRS181方式的标注服务开发，这样开发的时候只需要编写一个普通的Java类，然后加上标注信息后，加入services.xml中即可。我们仍然在第2节所开发的HelloWorldService项目中进行修改。下面是创建的Web服务类echo.Jsr181EchoService：

这个代码中有很多标注，绝大部分都可以在最后生成的WSDL文档中找到对应值。

@WebService这个标注放置在 Java 类之前，注明这个类的部分方法可以被发布为 Web 服务（还记得上一章提到的标注嘛？这个标注最终被XFire读取后进行分析后会进一步处理成Web服务）。它的属性用于设置 Web 服务被发布时的配置信息，常用的属性包括：

name（可选）：Web 服务的名字，WSDL中 wsdl:portType元素的 name属性和它保持一致，默认是 Java类或者接口的名字，也可以进行自定义，例如本例中的EchoService。 

serviceName（可选）：Web 服务的服务名，WSDL 中 wsdl:service元素的 name属性和它保持一致，默认是Java类的名字（Jsr181EchoService），不过如果设置了name属性，则名字改为name属性的取值。

targetNamespace（可选）： WSDL文件所使用的 namespace，该 Web 服务中所产生的其他 XML文档同样采用这个作为namespace，一般取值为Web服务所在网站的名字，不过看起来任意取值并无出错之处。

@WebMethod（可选） 标注放在需要发布成 Web 服务的方法之前，有一些属性可以设置。例如openrationName指明了SOAP调用时所看到的方法名为echoString，而不是类中的方法名echo，action则定义了操作的类型。一个类里面可以定义多个@WebMethod。

@WebResult（可选）标注定义了返回值（SOAP Response Envolope）中的name(名字)为echoResult。

@WebParam（可选）则定义了哪些参数可以作为Web服务中的远程可见的参数被调用，name设置了其属性。

乍看之下，这个Web服务中所用的标注有点多，实际上，这些标注可以不加任何属性，例如只写下@WebService，@WebMethod即可，甚至于整个类只需要一个@WebService标注即可，此时代码如下所示：

。此时最后所生成的Web服务中，所有的操作名，方法名和参数名都和此通Java类中的名称一致。在这种情况下，该Web服务的访问地址应为：

http://localhost:8080/HelloWorldService/services/Jsr181EchoService?wsdl 。

       最后一步，乃是在XFire中配置并发布此服务了，在services.xml中加入的Web服务配置格式如下：

，此配置相当的简单，需要注意的是serviceClass就是我们写有Web服务标注的Java类，而serviceFactory则必须是AnnotationServiceFactory（标注服务工厂），否则此Web服务将无法正常发布。

好了，现在按照15.2.4一节的内容发布项目并运行后，即可在浏览器中键入下面地址进行测试了：

http://localhost:8080/HelloWorldService/services/EchoServiceTest?wsdl 。

EchoServiceTest的名字是因为在类中标注了@WebService的serviceName属性。之后就可以在Web Service Explorer中对它进行测试，或者是生成客户端代码。

从这里看到这种开发方式相对也简单的多，而且您将在下一节看到如果是Java EE 5的容器，开发过程将更加的简单，而且不需要XFire类库及其配置文件。