BlogJava-SIMONE-随笔分类-AXIS

java通过axis访问.net webService 简单例子

SIMONE — Tue, 11 May 2010 03:41:00 GMT

原文地址：http://www.javaeye.com/topic/151541
在原文基础上加了点注释呵呵。

所需jar包：
saaj.jar
wsdl4j-1.5.1.jar
commons-discovery-0.2.jar
commons-logging-1.0.4.jar
jaxrpc.jar
axis.jar

这些jar包都在axis项目下，
axis下载地址：http://ws.apache.org/axis/

java代码：
// 需导入的类
import javax.xml.namespace.QName;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.encoding.XMLType;

//              .net webService 地址
       String url="http://localhost:1246/WebSite3/Service.asmx";
//              .net webService 命名空间
       String namespace = "http://tempuri.org/";
//              .net webService 需调用的方法
       String methodName = "HelloWorld";
       String soapActionURI = "http://tempuri.org/HelloWorld";
       Service service = new Service();

       Call call = (Call) service.createCall();

       call.setTargetEndpointAddress(new java.net.URL(url));
       call.setUseSOAPAction(true);
//       这个地方没设对就会出现Server was unable to read request的错误
       call.setSOAPActionURI(soapActionURI);
//              设置要调用的.net webService方法
       call.setOperationName(new QName(namespace, methodName));
//              设置该方法的参数，temp为.net webService中的参数名称
       call.addParameter( new QName(namespace,"temp"),
                org.apache.axis.encoding.XMLType.XSD_STRING,
                javax.xml.rpc.ParameterMode.IN);
//              设置该方法的返回值
       call.setReturnType(XMLType.XSD_STRING);
//              call.invoke(new Object[] { "kusix" }); 中"kusix"为传入参数值
       String ret = (String) call.invoke(new Object[] { "kusix" });
       System.out.println("返回结果---> " + ret);

.net 代码
using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
    public Service () {

        //如果使用设计的组件，请取消注释以下行
        //InitializeComponent();
    }

    [WebMethod]
    public string HelloWorld(String temp) {
        return temp+" add by .net";
    }

}

using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
public Service () {
//如果使用设计的组件，请取消注释以下行
//InitializeComponent();
}
[WebMethod]
public string HelloWorld(String temp) {
return temp+" add by .net";
}
}

SIMONE 2010-05-11 11:41 发表评论

用 Apache Geronimo 和 Axis2 实现在线银行，第 1 部分: 服务：布设框架（3）

SIMONE — Fri, 29 Dec 2006 11:45:00 GMT

结束语

您已从头至尾地完成了 WSDL，从原始的 SOAP 结构到 WSDL 绑定。还成功地使用 Axis2 的 WSDLJava 工具将其编译成了 Java 代码，并在 Geronimo 上进行了测试与部署。

请继续阅读第 2 部分，开发 Axis2 生成的 Java 代码，创建一个功能齐全的在线银行 Web 服务。稍后在第 3 部分中，我们将创建一个基于 Web 的客户机，与 Axis2 Web 服务进行通信，请继续关注本系列教程。

下载

描述	名字	大小	下载方法
Part 1 source code	os-ag-onbank1.zip	9KB	HTTP


	关于下载方法的信息			Get Adobe® Reader®

参考资料

学习

您可以参阅本文在 developerWorks 全球站点上的英文原文。
阅读关于 developing Web services using Axis2 的文章（developerWorks，2005 年 11 月）。
访问 Apache Ant 手册和 Apache Axis2 0.94 文档。
获得 Apache Axis 文档。
访问 Apache Geronimo 主页。
加入 Apache Geronimo 邮件列表，获得 Apache Geronimo 的信息。
加入 Axis2 邮件列表。
查看 developer.com 推荐的新 Axis2 部署架构相关内容。
访问 Axis2 Wiki。
查看 developerWorks 的 SOA 和 Web 服务专区，其中提供了关于 Web 服务和 Web 服务标准的文章与教程。
阅读教程 “Understand Web Services Distributed Management (WSDM)” （developerWorks，2005 年 7 月），了解 WSDM 的理论及安装。
访问 developerWorks 开放源码专区，获得广泛的 how-to 信息、工具和项目更新，帮助您使用开放源码技术进行开发并将其与 IBM 产品共同使用。
查看 developerWorks 的 Apache Geronimo 项目专区，获得文章、教程和其他资源，帮助您立即开始使用 Geronimo 进行开发。
查看 IBM 对 Apache Geronimo 的支持产品，这使您能在 IBM 的世界级支持下开发 Geronimo 应用程序。
访问 developerWorks 中的立即开始使用 Apache Geronimo 部分，获得面向新手和经验丰富的用户的有用资源。
访问 developerWorks 的开放源码专区，浏览所有 Apache 文章与免费 Apache 教程。
访问 Safari 书店，浏览关于上述主题及其他技术的图书。

获得产品和技术

下载 Apache Axis2，它提供了一个用于构建基于 Web 服务的应用程序的 SOAP 平台。
使用 IBM 试用软件革新您的下一个开放源码开发项目，这些软件可通过下载获得，也可在 DVD 上获得。
下载 Apache Geronimo 1.0。
下载免费的 IBM WebSphere® Application Server Community Edition V1.0 —— 轻量级 J2EE 应用服务器，构建于专为帮助您加速开发和部署工作而设计的 Apache Geronimo 开放源码技术之上。

讨论

参与论坛讨论。
访问 Apache Geronimo blog，了解 Geronimo 开发的最新信息。

回页首

关于作者


		Nicholas Chase 参与过多家公司的网站开发，包括 Lucent Technologies、Sun Microsystems、Oracle 和 Tampa Bay Buccaneers。Nick 曾是一名高中物理教师、放射性废弃品设施低级管理员、在线科幻杂志编辑、多媒体工程师、Oracle 讲师、一家交互式通信公司的首席技术官。他撰写了许多图书，其中包括 XML Primer Plus。

SIMONE 2006-12-29 19:45 发表评论

用 Apache Geronimo 和 Axis2 实现在线银行，第 1 部分: 服务：布设框架（2）

SIMONE — Fri, 29 Dec 2006 11:40:00 GMT

摘要: 公开 Web 服务：WSDL 在线银行服务由几种操作构成，在实现这些操作之前，我们将首先介绍一下各操作。您将了解到各操作的细节、消息、端口类型和 WSDL 绑定。操作之前已经看到了在线银行 Web 服务的概述。现在将了解构建此 ... 阅读全文

SIMONE 2006-12-29 19:40 发表评论

用 Apache Geronimo 和 Axis2 实现在线银行，第 1 部分: 服务：布设框架（1）

SIMONE — Fri, 29 Dec 2006 11:38:00 GMT

级别: 中级

Nicholas Chase (ibmquestions@nicholaschase.com), 自由作者, Backstop Media, LLC

2006 年 5 月 25 日

使用 Apache Geronimo 和 Axis2 构建复杂 Web 服务应用程序是一项错综复杂的任务，本系列将深入研究相关内容。本系列教程由 3 个部分构成，引领您构建一个示例在线银行 Web 服务，文中介绍了整个流程的每个步骤，因此新用户可快速掌握概念并构建一个完整的 Web 服务和可与 Web 服务连接并通信的 Web 界面客户机。在第一期中，将为您介绍示例 Web 服务和使用 WSDL 的 Web 服务，构建并编译 WSDL 文件，然后在 Geronimo 上测试及部署它。

开始之前

本系列教程分 3 部分，面向对使用 Apache Geronimo 和 Apache Axis2 开发大型 Web 服务有兴趣的读者。了解如何构建 WSDL 文件及与在线银行系统相关的一些操作。然后使用 Axis2 将 WSDL 文件编译为 Web 服务，并在 Geronimo 上进行部署和测试。

关于本系列

本系列中将创建一个在线银行 Web 服务示例。使用 WSDL 和 Axis2 创建的 Web 服务将包含一个 Apache Derby 数据库，用于保存交易数据、账户数据和账单支付数据。您会将 Axis2 作为 Apache Geronimo 上的 Web 应用程序部署，新 Web 服务将是在 Axis2 中部署的 Axis 归档。您在示例中可能会用到在线银行中的多个命令，包括查看账户、搜索交易、划拨资金和支付账单。您还会创建一个客户机 Web 应用程序来连接到 Web 服务，以查询信息及执行交易 —— 主要是为了调用在 Web 服务中实现的操作。

在本系列的第 1 部分中，将在 WSDL 中构建在线银行 Web 服务的基础设施。在第 2 部分中，将通过在 Apache Derby 数据库中存储账户和交易信息来构建 Web 服务的功能。在最后的第 3 部分中，将为 Web 服务创建功能完整、基于 Web 的客户机用户界面（UI），用户可在其中登录、进行在线银行活动及注销。

回页首

关于本教程

本教程首先介绍示例 Web 服务，并展示使用 WSDL 的多种 Web 服务。您将使用 Axis2 将 WSDL 文件转换为 Java™ 代码，其中将实现一些简单的功能，以测试客户机与 Web 服务之间的通信。测试环境包括作为 Geronimo 上的模块部署的 Axis2、作为 Axis2 内的归档部署的 Web 服务，以及与 Web 服务通信的一个简单 Java 客户机。

回页首

前提条件

要学习本教程，需要具备以下工具：

Apache Geronimo —— 下载 Apache Geronimo V1.0，您将在 Geronimo 上部署 Axis2 Web 服务。
Apache Axis2 —— 下载 V0.94 Axis2 WAR 及二进制发行版，用于从 WSDL 构建 Web 服务。
Apache Ant —— 下载 Apache Ant，由于 Axis2 的 WSDL2Java 工具为构建 Web 服务创建了一个便捷的 Ant build.xml 文件，因此您需要用到此工具，这将使 Web 服务源代码的构建更容易。
Java 代码 —— 下载最新版的 Java 1.4，Java 1.4.10，Geronimo、Axis2 和 Ant 都需要用到它。

本教程假设您具备 Java 语法和编写代码的基本知识，但不必了解 Axis2 或特定 Geronimo 的相关知识。

回页首

在线银行 Web 服务概述

下面简要介绍本系列教程的最终成果 —— 在线银行 Web 服务示例。该 Web 服务涵盖了在线银行体验的几种特性，包括查看账户和交易、划拨资金、申请贷款和在线支付账单。

账户

登录到 Web 服务之后，您会看到您所拥有的账户及其余额。出于安全性方面的考虑，登录过程包括发送用户名和密码，以及接收保证安全性的二进制令牌。因此，在您登录之后，仅需发送该令牌即可使 Web 服务识别您的身份。之后您就可以单击查看账户中的交易，见下节。

交易

您在银行中做的每一件事都涉及交易，各交易的历史 —— 可在各账户中查看其历史 —— 记录在您的账户中。Web 服务还使您根据支票编号、金额或日期搜索交易。这使您可在纳税时更轻松地回溯和查找账户中的交易。您可将资金从一个账户划拨到另外一个账户中，这也作为账户的一项交易记入日志。

申请贷款

本特性允许您通过在线银行 Web 服务申请贷款。您可输入贷款类型、欲贷金额、偿还时间。成功提交贷款申请表后，您可查看每笔贷款的状态。

支付账单

在线账单支付服务现已非常普及。这种服务使您能够通过银行账户支付账单。但在支付账单之前，必须首先添加作为支付对象的人或公司，我们称之为收款方（payee）。Web 服务允许您查看、添加和编辑账户中的收款方。在账户中设置好收款方后，您就可以向其偿还债务或划拨资金了。所支持的支付类型有两种：一次性支付 和 定期支付。您可通过 Web 服务执行各类支付。每次支付都有一个与其相关的日期，在支付发生之前（待定支付），允许您编辑其内容。

在下一节中，我们将开始构建在线银行 Web 服务的 WSDL。

回页首

数据结构

您在 Web 服务中支持的消息及操作需要一些数据结构用于来回传递数据，在 WSDL 中也称为复型。这些数据结构是通过简单对象访问协议（SOAP）传送的，并且是使用 WSDL 定义的。Web 服务的操作需要 6 个数据结构，我们将从最常用的一种开始，即交易。

交易

在您的在线银行 Web 服务上下文中，两个账户（或一个账户和银行）是所涉两方。就我们的在线银行应用程序而言，一个交易可能有 5 项属性。下面看看这些属性，参见清单 1。现在创建一个 WSDL 文件 —— OnlineBanking.wsdl，将 Transaction complexType 放置在其中。

Transaction complexType 中的 5 个元素在清单 1 中显示为黑体。所有必需元素均以 minOccurs="1" maxOccurs="1" 表示。这表示该元素号应至少出现一次，且最多出现一次，也就是恰好一次。注意 checknumber 非必需，因为 minOccurs="0"，这表示在一个 Transaction 中，该元素可被忽略，也可以恰好出现一次。另外，查看数据类型。注意，号码定义为 int、checknumber 和 int、date 和 date、header 和 string，以及 amount 和 float。

清单 1. 交易


												      
        
          1" maxOccurs="1"
                       name="number" type="xsd: int" />
          0" maxOccurs="1"
                       name="checknumber" type="xsd: int" />
          1" maxOccurs="1"
                       name="date" type="xsd: date" />
          1" maxOccurs="1"
                       name="header" type="xsd: string" />
          1" maxOccurs="1"
                       name="amount" type="xsd: float" />

接下来将介绍收款方复型。

回页首

收款方

收款方接受您通过在线银行支付的账单。因此，需要几个字段来获得地址和账单金额信息。为您的 WSDL 文件添加收款方复型，参见清单 2。

清单 2. 收款方


												      
        
          name" type="xsd:string" />
          address1" type="xsd:string" />
          address2" type="xsd:string" />
          address3" type="xsd:string" />
          city" type="xsd:string" />
          state" type="xsd:string" />
          zip" type="xsd:string" />
          phoneAreaCode" type="xsd:int" />
          phonePrefix" type="xsd:int" />
          phoneSuffix" type="xsd:int" />
          accountToPay" type="xsd:string" />
          nameOnBill" type="xsd:string" />
          alias" type="xsd:string" />

对于邮汇，您可以想到，需要的所有必需数据，在清单 2 中以黑体显示。注意 address2 和 address3，补充的额外地址行非必需。接下来定义贷款申请表复型。

回页首

贷款申请表

如果银行不发放贷款，我们要如何生存？这里定义的数据结构包括贷款申请表信息和贷款状态信息。我们首先定义贷款申请表复型，参见清单 3。

清单 3. 贷款申请表


												      
        
          loanType" type="xsd:string" />
          amount" type="xsd:float" />
          termMonths" type="xsd:int" />
          joint" type="xsd:boolean" />
          percentFinanced" type="xsd:int" />

各字段都包括贷款申请表中的典型数据。接下来将贷款状态添加到您的 WSDL 中，如清单 4 所示。

清单 4. 贷款申请表状态


												      
        
          loanNumber" type="xsd:string" />
          approved" type="xsd:boolean" />
          denied" type="xsd:boolean" />

每笔贷款都获得一个号码以及一个与其相关的批准或拒绝状态。如果它既未得到批准，也未被拒绝，则该贷款尚未处理。接下来介绍与账单支付相关的结构。

回页首

账单支付

支付账单要求您输入信息，如支付金额、支付对象，以及是否为定期支付等。接下来的两个清单展示了两种结构，供您参考。向您的 WSDL 文件中添加账单支付复型，参见清单 5。

清单 5. 账单支付


												      
        
          payeeName" type="xsd:string" />
          account" type="xsd:int" />
          amount" type="xsd:float" />
          date" type="xsd:date" />
          notes" type="xsd:string" />
          recurring" type="xsd:boolean" />
          minOccurs="0" maxOccurs="1"
                       name="recurringData"
                       type="xsd1:RecurringBillPayment" />

这里显示的金额即为您所支付的金额。如果是定期支付，则此金额为您每次支付的金额，所以日期将为起始日期。另外，注意这里 recurring 指定支付是否为定期支付，如果是，则定义 recurringData（注意其 minOccurs 定义为 0）。recurringData 元素引用 RecurringBillPayment 复型，如清单 6 所示。将其添加到您的 WSDL 中。

清单 6. 追加定期账单支付数据


												      
        
          finalPayment" type="xsd:float" />
          frequency" type="xsd:string" />
          totalNumberOfPayments" type="xsd:int" />
          recurringType" type="xsd:string" />

清单 6 中的数据直接填充清单 5 所示复型。在这里，您的最后支付为 finalPayment 字段的值，frequency 则为支付账单的周期。recurringType 字段表示账单金额是否为固定数量，也就是说表示您是否可在下一次提交之前更改金额。接下来为您介绍需要通过 WSDL 公开的几种不同操作。

回页首

SIMONE 2006-12-29 19:38 发表评论

了解 Web 服务规范: 第 3 部分：统一描述、发现和集成 (UDDI)（4）

SIMONE — Fri, 29 Dec 2006 11:36:00 GMT

结束语

分布式环境要求使用集成存储库，以便用户和开发人员了解哪些功能可用以及能在何处找到这些功能，Web 服务也不例外。本教程说明了统一描述、发现和集成 (UDDI) 的使用，UDDI 提供了保存有关可用企业和服务的信息的注册中心。

在本教程中，您了解了以下内容：

什么是 UDDI 以及它为何重要
如何设计 UDDI 数据的结构
如何区分 SOAP 接口和实现
如何在 UDDI 注册中心中查找数据
如何使用 Java 与 UDDI 注册中心交互

本系列的后续部分将介绍如何应对不断增加的安全需求，并对 WS-Security 和 WS-Policy 进行探讨。

回页首

下载

描述	名字	大小	下载方法
Source code	uddicode.zip	6KB	HTTP


	关于下载方法的信息			Get Adobe® Reader®

参考资料

学习

您可以参阅本文在 developerWorks 全球站点上的英文原文。
阅读本系列的其他教程。
请访问 UDDI 网站。
您可以找到所有三个版本的规范，包括 XML 模式文档。
请参见 Tom Bellwood 所撰写的使用 UDDI V3 加速前进，以了解 UDDI 3.0 版中的更改。
有关将 WSDL 与 UDDI 注册中心一起使用的各种不同方法的系列教程（由三部分组成），请参见 developerWorks 系列教程“Understanding WSDL in a UDDI registry”。
- WSDL : 描述你的Web服务（2001 年 8 月）
- Part 2: Usage scenarios in publishing and finding WSDL service descriptions（2001 年 9 月）
- Part 3: How to publish and find WSDL service descriptions（2001 年 11 月）
阅读 developerWorks 系列文章“The role of private UDDI nodes in Web services”。
- Part 1: Six species of UDDI （2001 年 5 月）
- Part 2: Private nodes and operator nodes（2001 年 5 月）
阅读由五个部分组成的系列文章“使用 UDDI 和 WSDL 的一种新方法”。
- 第 1 部分：介绍新的OASIS UDDI WSDL TechnicalNote（2003 年 8 月）
- 第 2 部分：新的OASIS UDDI WSDL TechnicalNote支持的查询（2003 年 9 月）
- 第 3 部分：正在发挥作用的新 OASIS UDDI WSDL Technical Note 的一个示例（2003 年 10 月）
- 第 4 部分：使用新的 OASIS UDDI WSDL Technical Note 来从 Java 应用程序发布 WSDL（2004 年 3 月）
- Part 5: Query from a Java application using the new OASIS UDDI WSDL Technical Note（2004 年 11 月）
阅读有关 UDDI4J 的更多信息：UDDI4J: 安排 Web 服务 -- 与 UDDI 服务器交互。
请参见：UDDI4J v2 编程（developerWorks，2002 年 7 月），这篇文章讨论了下一代 UDDI 客户机 API——UDDI4J v2。

获得产品和技术

下载 Apache Geronimo。
要创建自己的 UDDI 注册中心，请下载 Apache jUDDI。
下载 UDDI4J。
下载 Apache Axis 1.3。
下载 Java 1.4.2。Geronimo 将无法与 Java 1.5 一起正常使用。
UDDI4Py 是一个 Python 包，允许将请求发送到 UDDI V2 API 并允许处理来自后者的响应。

讨论

参与论坛讨论。

回页首

关于作者


		Nicholas Chase 曾经参与过许多公司网站的开发，包括 Lucent Technologies、Sun Microsystems、Oracle 及 Tampa Bay Buccaneers。他当过中学物理教师、低级放射性废弃设备管理员、在线科幻杂志编辑、多媒体工程师、Oracle 讲师以及一家交互式通信公司的首席技术官。他写过几本书，其中包括XML Primer Plus (Sams)。

SIMONE 2006-12-29 19:36 发表评论

了解 Web 服务规范: 第 3 部分：统一描述、发现和集成 (UDDI) （3）

SIMONE — Fri, 29 Dec 2006 11:33:00 GMT

摘要: 查找和使用信息现在已经有了所有信息（至少从理论上是这样），Gene 需要再次对查找的过程进行处理。 UDDI 搜索的工作方式：查找公司在 UDDI 中进行搜索将涉及到两个步骤。首先，查找所需对象的键，然后获取有关该对象的信息。因此，为了查找公... 阅读全文

SIMONE 2006-12-29 19:33 发表评论

了解 Web 服务规范: 第 3 部分：统一描述、发现和集成 (UDDI) （2）

SIMONE — Fri, 29 Dec 2006 11:32:00 GMT

UDDI 数据结构

为了开始将公司添加到 UDDI 注册中心，Francis 定义了要输入注册中心的信息。

businessEntity

第一步是将报社本身的信息输入注册中心。为此，Francis 创建了一个 businessEntity 对象。此对象包含有关企业的信息，既用于对企业进行标识，也用于提供与其有关的信息。例如，businessEntity 对象可以包含多个名称（从而能够为公司所使用的每种语言创建一个 name 元素），联系信息（Francis 被告知将 Pat Mooney 添加为主要联系人）、与实体相关的服务（Gene 将稍后添加）和用于对公司进行标识与分类的信息。

尽管大部分人都不会采用这种方式与 UDDI 注册中心交互，但要注意的一个事实是，UDDI 实际上就是 SOAP 应用程序；执行的所有操作都作为往返传递 SOAP 消息的结果发生。这意味着，Francis 所创建的 businessEntity 最终将表示为 XML 元素。请参见清单 2。

清单 2. businessEntity 元素

												
														
												 operator="(optional)" 
authorizedName="(optional)">




The Daily Moon
La Lune Quotidienne




Pat Mooney

patm@daily-moon.com







         ...




         ...



      ...


      ...

businessEntity 记录并不一定要很复杂。事实上，按照 businessKey 的要求，单个名称和一个唯一标识符就足够了。不过，出于完整性考虑，我包含了完整的结构，但去掉了一些稍后将另行讨论的部分。在生产环境中，应将空白元素删除。

让我们看一看此处的一些信息。

从代码的起始处开始，businessKey 当然是唯一标识符。operator 和 authorizedName 属性由注册中心内部进行处理；您不必考虑这部分内容，它们仅仅分别表示运行注册中心的实体和添加此记录的人员或帐户。

discoveryURLs 会在每次将 businessEntity 保存到注册中心时添加到注册中心。这些 URL 旨在用作供用户访问有关 businessEntity 的更多信息的地址。

请注意，Francis 添加了一个额外的名称，用于以法语表示其名称（报社打算在法国宣传其业务）。这些实体中的每一个都具有 lang 属性，用于指定相关语言的代码。您可以提供常见缩写的可替换名称，如 IBM 对应于 International Business Machines。

接下来的可选描述是一个简单的文本字符串。事实上，UDDI 中的大部分元素都具有一个可选描述。

接下来，Francis 添加了其他一些联系人。对于每个联系人，他可以根据需要指定任意多的信息。通常会提供 personName，但电话号码、电子邮件等其他信息是由个人自行提供的，因为 UDDI 注册中心的所有信息对所有用户均可用。联系人还可能具有地址信息，使用 useType 来指定地址类型。例如，对于联系人，它可以为家庭地址和公司地址等。对于公司，useType 可以为总部、发行中心等等。

businessServices 元素将列出已与 businessEntity 关联的任何服务。由于 Gene 尚未添加任何服务，故而此元素通常为空。最后两项 identifierBag 和 categoryBag 提供了有关公司本身的其他信息，以便进行搜索。我们稍后将对二者分别进行分析。

回页首

publisherAssertion

publisherAssertion 是 businessEntity 之间的关系声明。例如，Francis 知道此项目的目标之一是使用 Daily Star 中提供的服务，其中，Daily Star 将为 Daily Moon 提供体育赛事比分。这使得 Daily Star 成为 Daily Moon 的内容提供者。Francis 可以按照清单 3 中所示的方式表示此关系。

清单 3. publisherAssertion

                    

(businessKey for Daily Star)
(businessKey for Daily Moon)

fromKey 和 toKey 元素表示所涉及的两个实体的唯一 ID。在本例中，这两个实体指 Daily Moon 和 Daily Star。Daily Star 是 Daily Moon 的内容提供者，故而据此放置二者的键。keyedReference 将会多次出现。在本例中，我们可以说引用本身就是内容提供者。keyValue 是 keyedReference 的唯一必需属性，但常常也会包含 keyName（为了提高可读性）和 tModelKey（标识特定的引用类型）。在本例中，tModelKey 表示两个报社之间关联的命名空间（与内部关系相对）。我们稍后将对 tModels 进行进一步的讨论。

回页首

businessService

接下来，Francis 需要输入有关 Daily Moon 将要提供的任何实际服务的信息。除了所需的唯一 serviceKey 和名称外，businessService 对象中还包含两条重要信息。即 bindingTemplates 和服务所属的任何类别。请参见清单 4。

清单 4. businessService

												
														
												 businessKey="optional">




         ...



      ...

回页首

BindingTemplate

Tmodelinstancedetails 指示其兼容的应用程序或规范。请参见清单 5。

清单 5. bindingTemplate

												
														
												 serviceKey="optional"
 bindingKey="required">
                     OR 


>







string



            ...

  
   

TModels (including tModel of tModels)
Serve two purposes.  As specification indicators, and as namespace indicators.
 operator="optional" 
authorizedName="optional">







   
...


      ...

bindingTemplate 定义在何处能找到服务以及其执行什么工作，这听起来并不复杂。不过，这两项功能在 UDDI 上下文中担任了新的重要角色。例如，为了确定可以在何处访问服务，可以提供 accessPoint（表示简单的 URL）或任何其他相应的数据，如求助热线的号码或 hostingRedirector。

分类法

对信息进行分类时，如果能就如何进行分类达成一致则很有帮助。这些一致同意的分类标准称为分类法。

例如，北美工业分类系统 (NAICS) 通过为每种类别指定一个唯一代码来区分“体育用品出租”、“体育用品商店”和“二手体育用品商店”。这样，当遇到代码 532292 时，就知道所说的是出租体育用品的商家，而不是出售这些东西的商家。

UDDI 操作员向系统添加一系列分类法作为例行规定，可供您在无需为其注册 tModels 的情况下使用。例如，jUDDI 可以使用 tModel 键 A035A07C-F362-44DD-8F95-E2B134BF43B4 为 uddi-org:general_keywords 创建 tModel，因此您可以使用它，而不必自己定义。

当服务的绑定发生更改时，将使用 hostingRedirector。例如，如果 Daily Moon 要建立自己的分类广告服务，并允许这两家报社使用 createNewAdd() 调用提交广告，则需要确保服务永远不会更改，或者提供一个方法来告知客户机服务已发生更改。而这就是要使用 hostingRedirector 的地方。在这种情况下，Francis（或实际由 Gene 进行）将创建一个新 bindingTemplate，用于表示新信息，并将该 bindingTemplate 的 bindingKey 输入 hostingRedirector 元素的 bindingKey 属性中。

定义服务能进行的工作可能会更困难。这个原因是两方面的。首先，由于我们讨论的并不一定是 SOAP 服务，因此无法直接为其提供 WSDL 文件。其次，由于这应该是一个自动化过程，因此需要以无歧义的方式提供此信息。

这样所得的结果是一个包括 tModelInstanceDetails 元素的 bindingTemplate，而此元素中又包含一个或多个 tModelInstanceDetail 元素。每个 tModelInstanceDetail 元素又包含一个或多个 tModelInstanceInfo 元素，而后者各自指向一个特定的 tModel。我们稍后将对 tModels 进行讨论。不过，重要的是要理解，tModelInstanceInfo 元素可以包含一个 instanceDetails 元素，后者本身包含一个 overviewDoc，其中包括 overviewURL，即实际定义服务的文档的 URL。（是的，就是在此处指定 WSDL 文件。）

回页首

TModels（包括 tModels 的 tModel）

现在让我们讨论一下 tModels。

tModels 实际有两个用途。第一，就是我们在关于 publisherAssertions 的讨论中了解到的，作为“命名空间指示符”。也就是说，tModel 可以提供用于区分很容易混淆的信息类型的方法。经常给出的一个例子是税码（或其他很容易混淆的数字）。例如，包含以下内容的 keyedReference 并不会提供所有信息，因为这两个税务 ID 属于不同的国家。它们在两个国家里都称为税务 ID，但就编程而言，我们必须提供一个区分二者的方法，如清单 6 中所示。

清单 6. 来自不同国家的税务 ID

这就是要使用 tModel 的地方。我们可以为“美国税码”创建一个键模型，再为“墨西哥税码”创建一个键模型，依此类推。创建了这些模型后，可以使用其 tModel 键来进一步限定这些 keyedReference。请参见清单 7。

清单 7. tModels 和 keyedReferences

                    

   United States codes


   Mexico codes

tModel 的另一个用途是作为规范标识符。例如，Francis 知道 Gene 将为上个月所处理的 ClassifiedService 创建相应的条目。此服务表示特定的接口，因此可以使用 tModel 对其进行标识。tModel 可能与清单 8 中所示类似。

清单 8. tModel

												
														
												 
        operator="optional" authorizedName="optional">

   Classified Service Interface
   

   
      
      
        http://www.daily-moon.com/ClassifiedService-interface.wsdl
      
   

   
...
   

   
      ...

和我们所讨论的各个其他对象一样，tModel 具有一个唯一键，这是它唯一必需的信息。不过，在本例中，我们还要指定 overviewURL，即接口的 WSDL 文件的 URL。（我们将在后面部分创建它。）

同样，可以使用 identifierBag 对 tModels 进行标识，还可以使用 categoryBag 对其进行归类。接下来让我们看一看如何进行此工作。

回页首

identifierBag

由于 UDDI 设计十分灵活，因此没有特定的方式来标识 businessEntity。UDDI 并不强制要求使用其 D-U-N-S 编号、其税务 ID 编号或任何特定的标识方法对公司进行标识。相反，它提供了一个容器，可以根据需要在其中放置任意数量的标识符，如清单9 中所示。

清单 9. indentifierBag

												
														
												
												
														
												
 tModelKey="4064C064-6D14-4F35-8953-9652106476A9" 
         keyName="DUNS Number" keyValue="55555555" /> tModelKey="" 
         keyName="US Tax ID" keyValue="111111111" />

在 identifierBag 中添加的每个 keyedReference 都代表用户在搜索中找到相关对象的另一个机会。

回页首

categoryBag

categoryBag 的工作方式与 identifierBag 类似，因为其中包含一个或多个 keyedReferences。请参见清单 10。

清单 10. categoryBag

												
														
   
												 tModelKey="C0B9FE13-179F-413D-8A5B-5004DB8E5BB2" 
           keyName="optional" keyValue="511110" />

在本例中，Francis 创建了一个 categoryBag，指示 Daily Moon 是一个报社分支机构。现在让我们了解如何使用所有这些对象。

回页首

将 WSDL 映射到 UDDI

在 Gene 编写任何代码将所有这些信息发送到 UDDI 注册中心前，他必须在其当前服务和 UDDI 之间建立一个重要的联系。他必须对其进行调整，以适应 UDDI 的服务、接口和绑定模板概念。

服务与接口

您可能还记得，服务在 UDDI 中包含三个部分：接口（使用 tModels 定义）、businessService 和 bindingTemplate（用于将两者捆绑在一起）。因此，Gene 将首先确定用于定义 SOAP 服务的 WSDL 文件如何适应此结构。

他首先对 WSDL 进行分析。幸运的是，这非常简单。除了实现本身外，其余所有 WSDL 内容都属于接口。请参见清单 11。

清单 11. WSDL 接口

这包括类型定义（XML 模式）、任何消息、portType 甚至 binding，因为绑定并不是特定于实现的。

实现由实际的服务元素组成。请参见清单 12。

清单 12. 服务实现 WSDL

请注意，实现文件导入了接口文件。也就是说，此文件是服务的完整定义。

现在让我们来看一看这如何与我们的 UDDI 对象对应。

回页首

将接口映射到 tModel

Gene 首先必须将接口映射到相应的 tModel。请参见清单 13。

清单 13. tModel

                    


  
 http://www.daily-moon.com/ClassifiedService-
interface
   Interface for the Daily Moon Classified 
Department web application

   
      WSDL interface document
      
          http://www.daily-moon.com/ClassifiedService-interface.wsdl

首先看最下面，请注意 categoryBag。Gene 添加了两个 keyReferences。第一个指定我们事实上在处理 WSDL 文件。已预定义了特定的 tModelKey 来表示 uddi-org:types 命名空间。所有 WSDL 文件都必须采用这种方式指定。第二个引用绑定到 ntis-gov:naics:1997 命名空间，因此 Gene 的用户可以方便地在表示与报纸有关的服务的所有 WSDL 文件中找到此定义。继续往上，我们可以看到 overviewDoc。除了可选描述外，它还指定了实际的 URL，可以在此处找到 WSDL 文件。

最后，tModel 的名称应与 WSDL 文件的目标命名空间匹配。

回页首

将实现映射到绑定模板

Gene 接下来必须将实现本身映射到 bindingTemplate。请参见清单 14。

清单 14. bindingTemplate

                    


   
      http://www.daily-moon.com:8080/axis2/services/ClassifiedService
   

   
      
         
            
               The canonical implementation of 
                  the Daily Moon's classified
 service.
               
                  
           http://www.daily-moon.com/ClassifiedService-impl.wsdl

这里我们看到，Gene 创建了一个新 bindingTemplate，并将 accessPoint 设置为实际服务的 URL。键 modelInstanceDetails 将接口 tModel（通过 tModelKey）链接到实现文档（在 overviewDoc 中指定）。现在他只需要从服务引用它即可。

回页首

从 businessService 和 businessEntity 引用 bindingTemplate

最后一步是将所有这些组装起来，并从 businessService 引用 bindingTemplate、从 businessEntity 引用 businessService。请参见清单 15。

清单 15. 完整的 businessEntity

                    

   The Daily Moon
   La Lune Quotidienne
   
      
         Pat Mooney
         patm@daily-moon.com
      
   

   
      
         ClassifiedService
         
            
               
      http://www.daily-moon.com:8080/axis2/services/ClassifiedService
               

               
                  
                     
                        
                           The canonical
 implementation of the Daily Moon's classified 
service.
                           
                              
           http://www.daily-moon.com/ClassifiedService-impl.wsdl

也就是说，服务现在已经完成：Gene 现在有了一个包含服务的 businessEntity。

回页首

SIMONE 2006-12-29 19:32 发表评论

了解 Web 服务规范: 第 3 部分：统一描述、发现和集成 (UDDI) （1）

SIMONE — Fri, 29 Dec 2006 11:29:00 GMT

级别: 中级

Nicholas Chase (ibmquestions@nicholaschase.com), 顾问, Backstop Media

2006 年 11 月 05 日

面向服务的体系结构（Service-Oriented Architectures，SOA）当前强调的重点在 Web 服务上，但很容易被所传播的各种信息搞得昏头转向。本系列教程将对主要 Web 服务规范进行全面说明，从简单对象访问协议（Simple Object Access Protocol，SOAP）一直介绍到 WS Business Process Execution Language (WS-BPEL)。本教程是系列教程的第 3 部分，将说明统一描述、发现和集成 (UDDI) 的基本概念，并介绍如何使用 Java 应用程序访问它。

开始之前

本教程介绍统一描述、发现和集成 (UDDI)。UDDI 指定 Web 服务和其他公司信息的注册中心，旨在提供一种发现可使用的新 Web 服务并在理想的情况下实现操作自动化的方法。

本教程假定您熟悉 Web 服务和 SOAP 的一般概念。熟悉 WSDL 的相关知识也将有所帮助，但本教程中会对一般概念进行回顾。

为了理解本教程最后一部分给出的代码，您需要熟悉 Java，不过其中的概念与本教程的其他内容一样，适用于任何编程语言。

关于本系列

本系列教程以假想的报社 Daily Moon 为例，为了提高在竞争激烈的环境中的工作效率，其员工将使用各种 Web 服务来创建工作流系统，我们将在此过程中讲解各个 Web 服务基本概念。

第 1 部分说明了 Web 服务背后的基本概念，并演示了如何使用 SOAP（后续教程讨论的大部分内容的基础规范）来将 Classifieds Department 连接到内容管理系统。

第 2 部分进一步深入说明如何使用 Web 服务描述语言 (WSDL) 定义 Web 服务预期产生的消息，从而使团队更方便地创建服务以及连接到服务的客户机。

在第 3 部分中，团队希望准备一系列服务，并希望能方便地查找这些服务。与此对应，统一描述、发现和集成（Universal Description, Discovery and Integration，UDDI）提供了可用服务的可搜索注册中心，以便使自己的服务为其他人所注意。

第 4 部分和第 5 部分讨论 WS-Security 和 WS-Policy，将详细说明如何保证该报社的服务的安全，以及团队为了访问这些刚提供了安全保护的服务需要进行哪些更改。

第 6 部分重点讨论互操作性，因为必须从单个系统访问来自几个不同实现的服务。这一部分还将讨论 WS-I 证书中涉及的要求和测试。

最后，第 7 部分演示如何使用业务流程执行语言（Business Process Execution Language，WS-BPEL）来从各个服务创建复杂应用程序。

接下来让我们更为详细地了解一下本教程中将讨论的内容。

回页首

关于本教程

本系列的第 1 部分介绍了 Web 服务，并强调了 SOAP 的重要性。这些内容是通过虚构的 Daily Moon 报社的 Classifieds Department 进行相关工作的过程说明的。在本系列的第 2 部分中，Classifieds Department 决定创建自己的服务，并使用 Web 服务描述语言 (WSDL) 记录其使用方式。在第 3 部分中，报社的发行人决定全面推行 Web 服务，并强制要求使用 UDDI 注册中心来记录所有可用服务。

在本教程中，您将了解以下内容：

什么是 UDDI
UDDI 的用途
UDDI 数据的结构
如何有效地使用 UDDI 表示 WSDL
可以对 UDDI 数据执行的操作
使用 Java 与 UDDI 注册表交互

回页首

先决条件

为了处理本教程中的代码，您需要有以下软件：

Apache Geronimo 或其他 UDDI 实现。为了处理本教程中的代码，您需要访问 UDDI 注册中心。为了实现此目标，所使用的注册中心类型并不重要，因为 UDDI 根本就是 Web 服务，应该可以从任何平台或语言进行访问，并能够访问任何平台或语言。既然这样，就可以使用我们在本系列的第 1 部分和第 2 部分使用的 Apache Geronimo 应用服务器（同时也是 IBM 的 WebSphere Community Edition 的基础），其中预安装了 Apache 的 UDDI 注册中心实现 jUDDI，并将其配置为基本安装的一部分。您可以从 Apache.org 下载 Apache Geronimo。有关安装 Geronimo 的更多信息，请参见本系列的第 1 部分。

UDDI4J——为了访问注册中心，本教程说明了 UDDI4J 项目的使用方法；此项目提供了 UDDI 概念和 Java 代码间非常紧密的集成。可以从 Sourceforge.net 下载 UDDI4J。

Apache Axis2 或其他 SOAP 实现——可以手动创建 SOAP 消息，也可以手动对其进行解释，但手边如果有一个可用实现就会方便得多。您将使用的是 Apache Axis2，其中包含了各种 SOAP 相关的 API，可极大地简化您的工作。可以从 Apache.org 下载 Apache Axis2 。本教程使用的是 0.94 版，但应该也能使用更高版本。

Java 2 Standard Edition 的 1.4.x 版——所有这些工具都是基于 Java 的，本教程中将要构建的服务和客户机也是如此。可以从 Sun Developer Network 下载 J2SE SDK。Geronimo 将无法与 Java 1.5 一起正常使用。

另外，还需要 Web 浏览器和文本编辑器，但我想您已经有了这两个工具。如果愿意，还可以使用 Eclipse 之类的 IDE，但由于我们的重点是技术而不是工具，因此我将使用文本编辑器和命令行来编辑和编译文件。

回页首

概述

让我们看一看目前已经完成的工作。

已完成的工作

本系列教程逐步说明了虚构的 Daily Moon 报社的员工将其日常操作更改为基于 Web 服务的系统的过程。在第 1 部分中，Classifieds Department 通过与内容管理系统交互了解了 SOAP 的相关信息，在第 2 部分中，他们创建了自己的服务，并使用 Web 服务描述语言 (WSDL) 对其进行描述。现在，该报社的发行人 Rudy 对 Web 服务在其组织内的工作情况印象非常好，希望能更广泛地应用 Web 服务，甚至希望将其用于与其他组织进行交互。

为此，他要求 IT 人员 Gene 和 Francis 创建一个 Web 服务注册中心，以便能让其他部门更方便地找到为了将自己的操作过渡到 Web 服务而需要的构件。

Gene 和 Francis 认为最好的做法是实现统一描述、发现和集成 (UDDI) 注册中心，从而不仅能存储有关报社自己服务的信息，还能够与其他报社的注册中心进行交互。

回页首

WSDL 回顾

向 UDDI 注册中心注册服务的部分过程将涉及到对 WSDL 定义进行操作，因此在开始新项目前，Gene 重新分析了一下上个项目中的文件，以回顾 WSDL 的基本概念。请参见清单 1。

清单 1. WSDL 文件

由于篇幅的原因，我们从此文档中删除了部分代码，但我们仍然能通过剩下的部分了解其一般概念。

首先看最下面，我们定义了实际的服务，可通过特定的位置对其进行访问，且实现了 ClassifiedServiceBinding 接口。该接口表示为绑定，指定在 ClassifiedServicePortType portType 中定义的操作。portType 使用在 types 部分中定义的元素定义输入和输出消息。

XML 客户机可以读取此信息，并将其用于访问 Web 服务。（或者，更为准确地说，Web 服务客户机生成工具可以读取此信息，然后生成可以访问 Web 服务的客户机。）

回页首

我们的目标

在本教程中，Gene 和 Francis 将 Daily Moon 的信息拆分为 UDDI 友好的结构，包括业务信息和服务信息。他们将使用其通过 UDDI4J 将报社的信息和服务输入 UDDI 注册中心。它们还将与另一个报社 Daily Star 的私有注册中心协同工作，以查找提供即时体育赛事比分的服务。

现在让我们看一看到底什么是 UDDI。

回页首

UDDI 简介

UDDI 基本上就是一个 Web 服务，但与 SOAP 和 WSDL 存在很大差异，最好在开始之前了解一些背景知识。

为何使用 UDDI？

当所有应用程序都位于本地时，要找到所需的功能会非常容易。不过，使用 Web 服务之类的分布式系统时，您不能获得中央注册中心的好处。分布式系统也容易发生更改。而这正是 UDDI 的用武之地。它旨在用于两个目的。最初形成时，它被认为是一种“通用业务注册中心”。其想法是，企业可以使用以下三种方法之一搜索合作伙伴：

“白页”：白页与电话簿中用于查找公司信息的白页类似。例如，如果您知道公司的名称，可以在其中查找公司的地址、如何进行联系，甚至还能够确定与组织中的哪个人联系。
“黄页”：同样，黄页与电话簿中的黄页一样，可以在其中根据分类查找公司。UDDI 指定了各种分类法，以供各个公司用于对自己进行分类。例如，如果您在查找体育用具，则可以查找其北美工业分类系统（North American Industry Classification System，NAICS）代码为 339920 的公司。
“绿页”：电话簿中没有绿页，但这里的想法是，公司可以使用此搜索方法来查找实现了特定服务的贸易合作伙伴。例如，可以搜索实现了使用邮政编码的距离计算功能的公司。

UDDI 同时也被认为是一种保持分布式应用程序长期运行的方法。其想法是这样的，可以缓存有关访问特定服务的信息，如果客户机崩溃，应用程序将自动回到注册中心并进行检查，以确定信息是否已更改。如果已更改，则可以直接在应用程序内进行更改（在理想的情况下将自动进行更改）并重试您的请求。

回页首

UDDI 的实际应用

当 Francis 想尝试统一业务注册中心（Universal Business Registry，UBR）时，发现它已不复存在了。事实上，在推出 UDDI 3.0 版时，UBR 已被其企业赞助商终止了。为什么呢？无论 UBR 的想法多么好，但事实是基本上没有人使用它。其原因是双方面的：首先，在 UBR 中几乎没有任何可用信息——除非希望使用的是实时股票行情服务（在此情况下可找到大量信息）。第二个原因是，通常公司并不会与不熟悉的组织开展业务。很少有组织通过自动搜索寻找贸易伙伴，然后在不进行大量前期工作的情况下直接向其开发系统。自动搜索和调用模型并没有实际的效用。

同时，这也受到 UDDI 在某种意义上有些超前的事实的阻碍。它设计为处理所有类型的服务，而不仅是 SOAP over HTTP，并没有提供使用 WSDL 定义的机制（至少尝试使用它的人这样认为）。

不过，这并不是说根本不会使用 UDDI。相反，实际上它更多地用作“私有注册中心”。各个公司创建自己的注册中心，并在其中输入自己的服务。UDDI 还可以用作内部的业务注册中心，就像 LDAP 的传统用法一样。

而且，随着从“只有 Web 服务”的思维方式转变为更多强调面向服务的体系结构（Service Oriented Architecture，SOA）的思维方式，这种处理 SOAP 之外的内容的能力可能具有极高的长期价值。

回页首

UDDI 数据结构

UDDI 注册中心中的信息包含五种不同类型：

businessEntity 或实际企业组织。这可以是整个组织，也可以为隶属部门或分支机构。
publisherAssertion 或各个 businessEntities 间的关系。publisherAssertions 必须由双方共同声明才有效（因此无法将自己声明为另一个公司的分支机构），除非两个实体都对发布者负责，或除非两个实体都由同一个用户帐户输入注册中心。
bindingTemplate，这对服务接口的规范非常重要。它可以由多个 businessServices 进行实现。
businessService 或业务提供的服务。虽然现在看起来有些简单，但在 UDDI 的世界中，这并不意味着它是 Web 服务。例如，可以实际将您的公司的电话服务支持（即用户实际拨打的电话号码以及其他相关的内容）指定为 UDDI 服务。当然，您并不会提供虚拟 WSDL 文档，但这将是您的公司提供的一个服务。
tModels 或元数据模型。研究了 UDDI 后，Francis 得出结论，tModel 可能是 UDDI 未达到预期目标的最大原因。作为服务的注册中心，您希望找到像 WSDL 一样直接为服务指定接口的方法。但是，正如所指出的，UDDI 并不是仅供用于 Web 服务，而是设计时包含了更大的灵活性。tModels 的确可帮助指向 XML 文档（我们稍后将证实这一点），但事实上旨在提供通过服务、业务或任何其他对象指定关于某个事项的信息的通用方法。

以上是 UDDI 的基本数据结构。现在让我们了解一下可以用于与 UDDI 交互的方法。

回页首

UDDI API

UDDI 被认为过于复杂，但其核心在于上述五种数据类型以及四个操作：find、get、save 和 delete。也就是说，UDDI 规范说明了可以对数据进行的以下操作：

find_xx：find_businessEntity、find_businessService 等方法提供了在 UDDI 注册中心中搜索记录的方法。这些方法返回用于标识对象的键。
get_xx：获得了标识对象的唯一键后，可以使用 get_businessService 等 get_xx 方法来检索实际的对象本身。例如，get_businessService 将返回整个 businessService 对象，可从其中获得任何所需的信息。
save_xx：您可能已经猜到，这些方法会将信息添加到数据库，或更改数据库中已经存在的信息。
delete_xx：delete_bindingTemplate、delete_tModel 等方法获取对象的唯一键作为参数，然后将其从数据库中删除。这些方法的实际行为根据所删除的对象不同而有所变化。例如，由于数据库中的其他对象经常引用 tModels，因此并不能实际将其删除，而会将其隐藏。

几乎所有的 UDDI 都依赖于五个对象（businessService、bindingTemplate、publisherAssertion、businessEntity 和 tModel）与四个操作（find、get、save 和 delete）的这 20 个交叉方法。

现在让我们看一看此结构的实际情况。

回页首

SIMONE 2006-12-29 19:29 发表评论

了解 Web 服务规范: 第 2 部分：Web 服务描述语言 (WSDL) （4）

SIMONE — Fri, 29 Dec 2006 11:19:00 GMT

结束语

在本系列教程的第 1 部分中，Daily Moon 报社的 Classifieds Department 了解了如何使用 SOAP Web 服务连接到报社的内容管理系统。在本教程中，其员工了解了如何使用 Web 服务描述语言 (WSDL) 来描述自己的服务，以供其他人使用。本教程介绍了 XML 模式的基本知识，并说明了 WSDL 文件的结构，以便能够手动进行构建。本文还讨论了各种可用样式和编码间的差异。本教程还说明了如何使用随 Apache Axis2 提供的 Java2WSDL 和 WSDL2Java 工具，以便自动从 Java 文件生成 WSDL 或反向生成。

本系列教程的第 3 部分将讨论如何使用 UDDI 构建 Web 服务注册中心。

回页首

下载

描述	名字	大小	下载方法
WSDL files	ws-understand-web-services2-WSDL.zip	3000KB	HTTP


	关于下载方法的信息			Get Adobe® Reader®

参考资料

学习

您可以参阅本文在 developerWorks 全球站点上的英文原文。
在本系列教程的第 1 部分了解 Web 服务规范，第 1 部分：SOAP 中，您将了解有关 Web 服务的总体信息，特别是 SOAP Web 服务。
访问 WSDL 1.1 规范。
WSDL 2.0（候选）推荐标准包括三个文档：第 0 部分：引言、第 1 部分：核心语言和第 2 部分：附录。您还可以参考两个相关文档 SOAP 1.1 绑定和RDF 映射。
访问 Apache Axis2 网站，以获取您的特定版本的文档的相关链接。
Apache Geronimo 网站提供了 Apache Software Foundation 的 J2EE 服务器项目 Apache Geronimo 的详细信息。
developerWorks 教程“XML 入门”（2002 年 11 月）很好地介绍了 XML 的基本知识。
要更好地了解如何将 XML 作为对象处理，请参阅理解 DOM。
我应该采用哪一种 WSDL 样式？是一篇优秀的文章，说明了 Document 与 RPC 及 Encoded 与 Literal 样式的对比情况，其中包括每种样式的优缺点。
借助 RDF 增强您的 WSDL 说明了如何与资源描述框架 (Resource Description Framework) 结合来更好地利用 WSDL；此框架是万维网联盟 (World Wide Web Consortium) 用于定义 XML 对象的元数据的正式格式。
您可以通过导入和包含数据来为 WSDL 添加更多的功能和灵活性，但这样做可能会比较麻烦。Web 服务编程技巧和诀窍: WSDL 文件导入说明了如何正确进行此工作。
Axis2 并不是唯一用于从 WSDL 生成代码的机制。Top-down Web service development: Build a WSDL file to generate a Web service using WebSphere Studio 提供了另一种方法。
使用 XSLT 处理 WSDL 文档说明了多种方法，可通过这些方法深入理解 XSL 样式表中的 WSDL 文件，并了解应该避免的常见错误。
可以在 developerWorks SOA and Web Services 专区获得大量相关信息。
访问 developerWorks Open Source 专区，全面了解 Apache Geronimo。
阅读 developerWorks 上的 Online banking with Apache Geronimo and Axis2 系列教程，以获得一个实际的 Axis2 示例。
访问 developerWorks Java zone，以了解有关 Java 编程的更多信息。
访问 developerWorks XML 专区，全面了解 XML。

获得产品和技术

获取 Apache Geronimo。
获取 Apache Axis2。本教程使用的是 0.95 版，但应该也能使用更高版本。
获取 J2SE SDK。
获取 Apache Ant。

关于作者


		Nicholas Chase 曾参与多家公司的网站开发工作，如 Lucent Technologies、Sun Microsystems、Oracle 和 Tampa Bay Buccaneers。Nick 担任过高中物理教师、低辐射废料处理设施管理员、在线科幻小说杂志编辑、多媒体工程师、Oracle 讲师以及一家交互通信公司的首席技术官。他已经出版了多本图书，其中包括 XML Primer Plus (Sams)。

SIMONE 2006-12-29 19:19 发表评论

了解 Web 服务规范: 第 2 部分：Web 服务描述语言 (WSDL) （3）

SIMONE — Fri, 29 Dec 2006 11:11:00 GMT

摘要: WSDL 样式对于刚刚学习 WSDL 的开发人员而言，最容易混淆的是为文档选择样式。让我们了解一下不同的选项及其对 WSDL 和 SOAP 文档的影响。编程样式和编码在 XML 世界中，通常有两种类型的人：将 XML 视为数据格式的人和将 ... 阅读全文

SIMONE 2006-12-29 19:11 发表评论

了解 Web 服务规范: 第 2 部分：Web 服务描述语言 (WSDL) （2）

SIMONE — Fri, 29 Dec 2006 11:09:00 GMT

创建 WSDL 文档

Christine 负责实际的数据，而 Larry 负责在服务及其客户机间传递的实际消息。为了处理这些消息，他创建了 WSDL 文档。

消息

Larry 的第一步是决定服务将实际执行的函数，然后再为服务定义消息。与部门的其他人商议后，他制订了函数及其对应消息的列表，我们将在这一部分的其余内容中讨论这些函数。

createNewAd

此函数在广告结束日期接受广告的内容，并返回新创建的广告的内容（请参见清单 10 和清单 11）。

清单 10. createNewAdRequest（输入）

                    

 
  
     Vintage 1963 T-Bird...
     4/30/07

清单 11. createNewAdResponse（输出）

editExistingAd

此函数接受现有广告，并替换其在数据库中的内容。它将返回一个 Boolean 值声明，指示操作是否成功（请参见清单 12 和清单 13）。

清单 12. editExistingAdRequest（输入）

                    

 
  
      
         1138
         Vintage 1963 T-Bird...
         4/1/2007
         4/30/2007

清单 13. editExistingAdResponse（输出）

getExistingAds

此函数将返回现有 ClassifiedAds 的列表（请参见清单 14 和清单 15）。

清单 14. getExistingAdsRequest（输入）

清单 15. getExistingAdsResponse（输出）

                    

 
  
    
      
         1138
         Vintage 1963 T-Bird...
         4/1/2007
         4/30/2007
      
      
         2883
         Championship playoff
 tickets...
         4/1/2007
         4/30/2007

finalizeIssue

此函数是“仅输入”的函数，接收最终的发布日期，而并不返回任何数据（请参见清单 16）。

清单 16. finalizeIssueRequest（输入）

有了这些消息后，Larry 开始着手创建实际的 WSDL 文档。

回页首

创建基本文档

Larry 首先创建 WSDL 文档的基本框架（请参见清单 17）。

清单 17. 基本 WSDL 文档

像其所定义的 SOAP 消息一样，WSDL 也是由 XML 组成的。定义位于 definitions 元素内，如此处所示。首先看下面，您定义了 service。service 使用一个特殊的 binding，而后者是 portType 的一个实现。portType 定义操作，而操作由 messages 组成。消息中包含由 types 部分中定义的 XML 组成。

definitions 元素定义两个命名空间。第一个使用前缀 wsdl:，为组成 WSDL 的实际元素提供命名空间。第二个 targetNamespace 定义 WSDL 定义的项所属的命名空间。

Larry 首先定义的是类型。

回页首

定义类型

Larry 拿到 Christine 提供的定义，并将其放入 types 元素中，从而在文档内创建了一个新模式，如清单 18 中所示。

清单 18. 定义类型

                    
xmlns:ns1="http://org.apache.axis2/xsd" 
       targetNamespace="http://ws.apache.org/axis2">

从代码的起始处开始，请注意我们有两个命名空间部分。第一个位于 schema 元素本身中。此处 Larry 定义了两个命名空间。第一个命名空间是 XML Schema 命名空间，使用前缀 xs:。第二个命名空间是 targetNamespace，定义模式创建的定义所属的命名空间。也就是说，当第二个版本创建名为 ClassifiedAd 的 complexType 时，该定义属于命名空间 http://org.apache.axis2/xsd。不过，为了引用该命名空间，Larry 需要创建另一个别名。您可以在以 ns1: 为前缀的 definitions 元素上看到此别名。（Larry 可以直接将该定义放在 schema 元素上，但他稍后需要在 schema 元素外使用此定义。）后面两个属性 elementFormDefault 和 attributeFormDefault 表示元素和属性是否应该有命名空间前缀。

前面四个定义来自 Christine 提供给 Larry 的定义，但其余定义用于定义 Larry 前面创建的消息。

回页首

有关命名空间的说明

和许多编程语言一样，在 XML 中，经常有必要为各种元素和属性指定“命名空间”。这样就能方便地对具有相同名称但用途不同（来源也可能不同）的元素进行区分。XML 通过 URI 引用命名空间。例如，XML 模式命名空间为 http://www.w3.org/2001/XMLSchema。不过，为了方便起见，还为其分配了一个别名（或前缀）。例如，此处的模式命名空间的前缀为 xs:。请记住，别名只是一个别名而已，重要的是 URI。因此，属于 ns1: 命名空间的元素或属性也是模式的 targetNamespace 的一部分。

回页首

创建消息

定义了各个类型后，Larry 就可以定义将在 SOAP 信封中来回传递的消息了（请参见清单 19）。

清单 19. 创建消息

每个消息都具有一个 name，以便稍后对其进行引用。在每个消息内，您可以定义一个或多个 part。请注意，WSDL 2.0 仅允许每个 message 包含一个 part，因此 Larry 此处严格遵循了此约定。

每个 part 都有一个 name，而由 element 的名称组成该 part。元素名称将反过来引用在 types 元素中定义的类型。请注意，元素的名称以 ns1: 为前缀，即与模式的 targetNamespace 匹配的命名空间前缀。也就是说，当 Larry 创建 createNewAdResponse 的定义时，该定义进入了 http://org.apache.axis2/xsd namespace 中，由于前缀 ns1: 也引用此命名空间，因此现在可以使用该前缀引用此命名空间。

回页首

定义接口 (portType)

消息本身并不会带来什么好处，因此 Larry 需要将其与特定的操作关联。这些 operation 属于 portType 的一部分。portType 仅包含定义，而不包含实现。就这个意义而言，它与接口很相似。事实上，在 WSDL 2.0 中，portType 的名称已更改为 interface。Larry 为每个功能创建了一个操作（请参见清单 20）。

清单 20. 添加操作

                    
xmlns:tns=http://ws.apache.org/axis2
       xmlns:ns1="http://org.apache.axis2/xsd" 
       targetNamespace="http://ws.apache.org/axis2">


...



  



  

...

Larry 创建了两种类型的消息。一类消息（如 finalizeIssue）是“仅输入”的操作，因为它仅具有输入消息。消息 finalizeIssueRequest 是前面定义的，和前面一样，我们将创建一个新前缀 tns: 来引用其所属的命名空间。

第二种操作类型是请求/响应操作，如 createNewAd。在这种情况下，Larry 将同时定义输入和输出消息。

回页首

定义绑定

如果 portType 像接口，则 binding 为该接口的实现（请参见清单 21）。

清单 21. 创建绑定

                    
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" 
       xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
       xmlns:tns="http://ws.apache.org/axis2"
       xmlns:ns1="http://org.apache.axis2/xsd" 
       targetNamespace="http://ws.apache.org/axis2">





  

...

首先，请注意绑定 type 引用 Larry 已经创建的 ClassifiedServicePortType。其次，请注意添加了 soap: 命名空间。此 binding 用于 HTTP 上的 SOAP 消息，如 soap:binding 元素中所示。请注意 transport 属性。（尚不用担心 style，我们将在接下来的部分中对其进行讨论。）

对于共享其在 portType 中的名称的每个操作，Larry 现在都要添加一个 soap:operation 元素。此元素执行两个操作。根据此元素的说明，第一个操作实际上是 SOAP 操作。第二个操作用于指定 soapAction，此为在实际 SOAP 消息前发送的 HTTP Header。服务器可以使用此 Header 来将请求路由到相应的操作。

请注意，soapAction 始终有一定的问题，虽然在 WSDL 1.1 是可选的，但已经完全从 WSDL 2.0 中删除了。

每个操作还定义 input 和 output 消息（或者，使用仅输入的消息时，只定义 input 消息），但现在 Larry 还将添加特定的 SOAP 信息。同样，不用担心 use 属性；我们也将在稍后讨论此属性。此元素还为有效负载的内容定义命名空间。

回页首

定义服务

定义了接口和绑定后，接下来就要定义服务了（请参见清单 22）。

清单 22. 定义服务

service 可以具有多个端点，每个端点都由其自己对应的 port 元素进行定义。port 元素与特定绑定对应，包括有关如何访问此绑定的信息。在本例中，Larry 指定可以通过 SOAP 在以下位置访问该端口：http://127.0.0.1:8080/axis2/services/ClassifiedService。

回页首

为服务添加注释

定义了服务后，还要进行一个步骤。虽然是可选的，但真的应该进行此步骤。WSDL 允许您向 WSDL 文档中的任何元素添加 documentation 元素。清单 23 提供了一个示例。

清单 23. 为服务添加注释

                    
...


  The finalizeIssue operation is an "in-only"
         operation that tells the system not to accept any 
         more ads for a particular date.

  
    
  
...

有关 WSDL 的知识还有很多，但上面这些是基本的内容。不过，继续学习本教程之前，让我们了解一些您可能遇到的更为复杂的情况。

回页首

绑定 SOAP over HTTP 之外的其他协议

尽管 WSDL 的最常见用法是定义 SOAP over HTTP，但却不是指定 Web 服务的唯一方法。例如，Larry 可以创建一个使用 SOAP over E-mail 的绑定，并仅为 finalizeIssue 操作启用它（请参见清单 24）。

清单 24. 添加其他绑定

                    
...
EmailBinding" 
                          type="tns:ClassifiedServicePortType">

此处 Larry 添加了第二个绑定 ClassifiedServiceEmailBinding。和 ClassifiedServiceBinding 绑定一样，此绑定基于 ClassifiedServicePortType portType。不过，在本例中，他使用的是 SMTP（用于发送电子邮件的协议），而不是 HTTP。他可以随后向服务添加第二个端口，使其基于新绑定，使用电子邮件 URL 作为地址，而不是 HTTP URL。您可以为单个服务创建任意多的端口。

回页首

SOAP 和 Mime

另一个与此解决方案有关的主题还不甚明显，即将 SOAP 用于附件。由于消息不仅是 XML 文档，您应该如何使用 WSDL 进行指定呢？这个问题的答案涉及到一个事实，即消息是使用“多部分 MIME”发送的。幸运的是，您可以在 WSDL 文档中指定这一点。例如，Larry 希望指定一个操作，通过此操作，用户可以编辑从广告的 PDF 校样获得的现有广告（请参见清单 25）。

>清单 25. 指定包含多个部分的消息

在本例中，返回消息包含 SOAP、一个 HTML 文档和两个图像文件。

回页首

WSDL 2.0 中包含的新内容

在此部分中，我尽力说明 WSDL 2.0 与 WSDL 1.1 的一些不同之处，如从可能出现多个 portType 的情况变为单个 interface，以及 message 不再能包含多个部分等。其他方面也有一定程度的调整。

有多个因素促成了这些更改，但大部分更改的目的都是为了提高互操作性——不符合 WS-I 基本概要 (WS-I Basic Profile) 的构造通常都禁止使用——或为了更方便地将 WSDL 与经过扩展的 SOAP 规范一起使用。例如，WSDL 2.0 更多使用的是“组件”模型，此模型更适合与 WS-Choreography 等规范的要求进行集成。

另一个更改与“消息交换模式”的正式规范有关。WSDL 2.0 不依赖于用户确定是同时存在输入和输出还是仅有一个输入消息，它允许您具体地声明所使用的模式（请参见清单 26）。

清单 26. 指定消息交换模式

                    
...
  pattern=http://www.w3.org/2006/01/wsdl/in-only">
    
  

  pattern="http://www.w3.org/2006/01/wsdl/in-out">
    
    
  
...

现在让我们深入了解一下 WSDL 样式。

回页首

SIMONE 2006-12-29 19:09 发表评论

了解 Web 服务规范: 第 2 部分：Web 服务描述语言 (WSDL) （1）

SIMONE — Fri, 29 Dec 2006 11:04:00 GMT

共享 Web 服务

第 1 页，共 11 页

对本教程的评价

帮助我们改进这些内容

级别: 中级

Nicholas Chase (ibmquestions@nicholaschase.com) Backstop Media

2006 年 10 月 19 日

面向服务的体系结构（Service-Oriented Architectures，SOA）当前强调的重点在 Web 服务上，但很容易被所传播的各种信息搞得昏头转向。本系列教程将对主要 Web 服务规范进行全面说明，从简单对象访问协议（Simple Object Access Protocol，SOAP）一直介绍到 WS Business Process Execution Language (WS-BPEL)。在第 2 部分中，您将了解有关 Web 服务描述语言的内容，因为 Daily Moon Classified Department 需要使用 WSDL 来描述其 Web 服务，以便其他人能够方便地从任何编程语言或平台创建客户机访问此服务。

开始之前

本教程旨在帮助您了解 Web 服务描述语言 (Web Services Description Language)。本教程适合希望通过使用 WSDL 公开自己的服务供他人使用的开发人员，同时也适合拥有希望访问的服务的 WSDL 而需要创建客户机的开发人员。

为了学习本教程，您应该具有 SOAP 的基本知识（可以通过阅读本系列教程的第 1 部分了解 SOAP）和 XML 的基本知识。WSDL 与编程语言无关，但本教程最后的示例使用了 Java 和 Apache Axis2 项目。不过，其中的概念也适用于任何编程语言和环境。与此类似，本教程侧重于通常实现的 WSDL 1.1，但即将推出的 WSDL 2.0 的概念也与此相同，本教程将对二者的基本差异进行说明。

关于本系列

第 1 部分比较简单，说明了 Web 服务背后的基本概念，并演示了如何使用 SOAP（后续教程讨论的大部分内容的基础规范）来将 Classifieds Department 连接到内容管理系统。

在第 2 部分中，Classifieds Department 将开展进一步的工作：使用 Web 服务描述语言 (WSDL) 定义 Web 服务预期产生的消息，从而使团队更方便地创建服务以及连接到服务的客户机。

第 6 部分重点讨论互操作性，因为必须从单个系统访问来自几个不同实现的服务。这一部分还将 WS-I 证书中涉及的要求和测试。

最后，第 7 部分演示如何使用业务流程执行语言（Business Process Execution Language，WS-BPEL）来从各个服务创建复杂应用程序。

接下来让我们更为详细地了解一下本教程中将讨论的内容。

回页首

关于本教程

本系列的第 1 部分了解 Web 服务规范：SOAP 介绍了虚构的 Daily Moon 报社。具体来说，您了解了 Classifieds Department 所进行的工作。在该教程中，Classifieds Department 构建了一个客户机来在表示内容管理系统的 Web 服务间发送 SOAP 消息。在本教程中，由于对所看到的结果印象深刻，Classifieds Department 决定构建自己的 Web 服务来接收和管理 classifieds 数据库中的广告。不过，为了允许其他人使用此服务，他们将需要创建 Web 服务描述语言 (WSDL) 文件。此文件将向构建客户机提供说明，以便了解服务预期和返回的消息。

在本教程中，您将了解以下内容：

WSDL 文件为何重要
可以如何处理 WSDL 文件
XML 模式（出现在 WSDL 文件中）的基本知识
如何设计 WSDL 文件的结构
WSDL 1.1 和 WSDL 2.0 的基本差异
如何自动从表示服务的 Java 类自动生成 WSDL 文件
如何从 WSDL 文件生成表示服务的 Java 类
如何从 WSDL 文件生成 Web 服务客户机

Classifieds Department 将构建一个服务来接收新广告、编辑和显示现有广告，还能结束一个主题，使其不再接受任何广告。他们将同时使用请求/响应和单向消息传递。

回页首

工具和先决条件

本教程的大部分内容都是概念性的，但为了处理整个教程中的代码，您将需要安装以下软件：

Apache Geronimo 或其他应用服务器——团队将在本教程中创建新 Web 服务，您将需要可在其上运行服务的应用程序。当然，由于 Web 服务应当可互操作，因此使用何种应用服务器并不重要。本教程演示了 Apache Geronimo 的用法，而此应用服务器也是 IBM 的 WebSphere Community Edition 的基础。还可以使用 WebSphere Application Server 等其他应用服务器。您可以从以下网址下载 Apache Geronimo：http://geronimo.apache.org/downloads.html。有关安装 Geronimo 的更多信息，请参见本系列的第一篇教程“了解 Web 服务规范，第 1 部分：SOAP”。

Apache Axis2 的 0 .95 或更高版本——可以手动创建 SOAP 消息，也可以手动对其进行解释，但手边如果有一个可用实现就会方便得多。本教程将演示 Apache Axis2 的用法，其中包含了各种 SOAP 相关的 API，可极大地简化您的工作。可以从以下网址下载 Apache Axis2：http://ws.apache.org/axis2/download.cgi。本教程使用的是 0.95 版，但应该也能使用更高版本。（请注意，在本系列教程的第 1 部分使用的是 0.94 版，但并未使用该版本对本部分的代码进行测试。）

Java 2 Standard Edition 的 1.4 或更高版本——所有这些工具都是基于 Java 的，本教程中将要构建的服务和客户机也是如此。可以从以下网址下载 J2SE SDK：http://java.sun.com/j2se/1.5.0/download.jsp。

回页首

概述

在深入了解细节前，让我们了解一下其总体概貌。

Web 服务回顾

相对于传统编程方法而言，使用 Web 服务的主要优势是互操作性。您可以创建一个分布式系统，让分散在各个位置的计算机能够进行通信，但在大多数情况下，您需要使用限制灵活性的专用中间件。也就是说，发送方和接收方都需要使用相同的软件。

Web 服务提供了基于文本（实际上是基于 XML）的方法来往返传递消息，这意味着应用程序不仅不依赖计算机，而且也不依赖于操作系统和编程语言。只要双方遵循相同的 Web 服务标准，就不受各方运行何种软件的影响。

有多个用于传输此信息的标准，但本系列教程重点讨论的是 SOAP，因为此标准非常灵活，而且能与更高级的标准结合使用。

SOAP 知识巩固

SOAP 消息包括三个主要部分：Header、主体和有效负载（包含在主体中）。请看以下示例：

清单 1. 示例 SOAP 消息

                    
    >SOAPenv:Envelope 
       xmlns:SOAPenv="http://schemas.xmlSOAP.org/SOAP/envelope/" 
       xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"<
 >SOAPenv:Body<
  >req:getNumberOfArticles xmlns:req="http://daily-moon.com/CMS/"<
     >req:category/req:category<
  >/req:getNumberOfArticles<
 >/SOAPenv:Body<
>/SOAPenv:Envelope<

整个消息称为信封，其内容由 Header 和主体组成。Header 包括有关消息本身的信息（如路由信息），或要由位于发送方和最终接收方之间可能对消息进行处理的“SOAP 中间层”或服务处理的信息。消息的主体中包含“有效负载”，其中包含传递给 Web 服务的实际数据。

在本例中，有效负载为 getNumberOfArticles 元素及其内容。

回页首

WSDL 的用途

创建服务时，通常的原因都是因为希望其他人使用此服务。为了使用服务，需要知道向服务发送什么信息、服务将发送回什么信息以及在何处能找到此服务。当然，可以将这些放入字处理文档中，但相比之下，如果此信息采用标准的、最好为人机均可读的格式，则要有用得多。

WSDL 就提供了这样的标准格式。除了不会造成混淆不清外，其主要优势是，由于 WSDL 是事实标准，且采用 XML 格式，因而可由计算机进行处理，便于自动创建客户机（甚至自动创建服务的框架）。Classifieds Department 将要创建接受和管理 classified 广告的服务，以允许其他人（如作业聚合网站）能更方便地使用此服务，他们同样也将使用 WSDL 文件对其进行描述。

回页首

本教程的任务

在本教程中，您将逐步了解 Daily Moon Classifieds Department 的员工如何创建服务并将其公开给其他人使用，从而了解有关 WSDL 的知识。

首先，Christine 将设计 XML 模式，其中定义可以在 SOAP 消息中出现的数据。接下来，Larry 形成实际 WSDL 文件的结构，以确定将往返传递何种信息。然后，Gene 拿到 WSDL 文件，以其为基础设计表示服务的 Java 类，随后，为了进一步确认，他使用 Axis2 从该 Java 类生成 WSDL 文件，以了解二者的差异。然后，Francis 得到此 WSDL 文件，使用其生成基本 Web 服务和访问该服务的客户机。

现在让我们开始吧。

回页首

XML 模式简要介绍

Daily Moon 是一家相当小的报社，因此 Classifieds Department 无法承担专用 DBA 带来的相关支出。所以，Christine 总是将数据库视为“自己的孩子”。了解了 WSDL 的规范后，她决定承担起定义 SOAP 消息中可包含的数据的任务。

验证和选项

在首次尝试 Web 服务之后，员工已经熟悉了 XML，因此 Christine 下一步就要了解有关验证的知识。

XML 验证是确保 XML 的结构和内容符合任何预先定义的要求的过程。最初的时候，这表示要符合文档类型定义（Document Type Definition，DTD）；DTD 是从 XML 的前身 SGML 语言保留下来的结构。DTD 并不是很难，但存在一些主要的缺点，缺乏灵活性、缺乏 XML 命名空间支持以及其他问题，因此 XML 社区转而采用其他类型的 XML 模式。

请注意，此处所说的“模式”不是特指的。在这里，我使用的是该术语的一般用法，即文档的具体结构，而不是记录此结构的任何语言。这些 XML 模式的最常见支持是 W3C XML Schema 语言，经常将此语言简称为 XML Schema。（注意首字母大写。）

Christine 知道将使用 XML Schema 构建其 WSDL 1.1 文档，但注意到 WSDL 2.0 还特别支持其他模式，如 RELAX NG 和 Schematron，可以在此处使用这些模式。

回页首

实例文档

Christine 首先从一个与进出系统的预期数据近似的示例文档着手。她以数个现有广告为基础创建了以下 XML：

清单 2. 实例文档

                    
Listing 2: the instance document



   
      Vintage 1963 T-Bird.  Less than 300 miles.  
Driven by my daughter until I took it away.  Serious inquires
only. 555-3264 after 7 PM.
      4/15/2007
      4/1/2007
   

   
      30 ft ladder, only used once.  Willing to let
go for half its worth. Has slight dent near the middle.  
Harder than a human head. $150 OBO.
      4/30/2007
      4/10/2007

此文档称为“实例文档”，代表 XML 模式所定义的数据。在本例中，它包括两个作为 ClassifiedList 元素子项的 ClassifiedAd 元素。每个 ClassifiedAd 都包含一个 adId 属性（此属性与数据库内的主键对应）、广告内容以及广告的开始和结束日期。

她将此文档命名为 classifieds.xml。

回页首

基本模式

Christie 下一步将创建基本模式文档，以便对系统进行测试。实际模式本身也是一个 XML 文档，因此她创建了基础文件 classifieds.xsd 和一个 schema 元素，如清单 3 中所示：

清单 3. Schema 元素

此元素将作为 Christine 创建的所有定义的父项。

回页首

验证文档

测试系统的下一步是形成一个简单的 Java 应用程序，以根据模式验证实例文档。该类所需要进行的工作就是指定验证并对文档进行解析，如清单 4 中所示。

清单 4. ValidateWithSchema 类

                    
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
 
public class ValidateWithSchema {
 
    public static void main(String args[]) {

        DocumentBuilderFactory dbf = 
                        DocumentBuilderFactory.newInstance();
        dbf.setValidating(true);

        dbf.setAttribute(
          "http://java.sun.com/xml/jaxp/properties/schemaLanguage", 
          "http://www.w3.org/2001/XMLSchema");
        dbf.setAttribute(
          "http://java.sun.com/xml/jaxp/properties/schemaSource",
          "classifieds.xsd");

        Document doc = null;
        try{        
           DocumentBuilder parser = dbf.newDocumentBuilder();
           doc = parser.parse("classifieds.xml");
        } catch (Exception e){
           e.printStackTrace();
        }
    }
}

实际进行解析的方法并不十分重要；在本例中，Christine 将使用 DOM 解析器构建应用程序。首先，构建一个工厂，然后指定其创建的所有解析器都应为“验证解析器”。（并不会使用所有解析器进行验证。有些仅验证文档是否“形式良好”，而不会验证其实际结构。）

接下来，指定要使用的模式语言以及模式文档本身。在本例中，Christine 使用的是本地文件，但也可以使用任何可作为 URL 引用的文件。

Christine 保存文件，并对其进行编译，运行该文件后，她得到了以下输出，如清单 5 中所示。

清单 5. 运行空白模式

                    
Warning: validation was turned on but an org.xml.sax.ErrorHandler 
was not set, which is probably not what is desired.  Parser will 
use a default ErrorHandler to print the first 10 errors.  Please call
the 'setErrorHandler' method to fix this.

Error: URI=file:///E:/WSDLFiles/classifieds.xml Line=2: cvc-elt.1: 
Cannot find the declaration of element 'ClassifiedList'.

Warning 并不重要；Christine 仅希望知道文件是否有效，因此她并不需要任何特定的错误处理功能。Error 很重要，因为这意味着分析器在实际查看模式和验证实例文档。

接下来她需要添加实际的定义。

回页首

创建简单的元素

定义最初的数个元素非常简单。content, endDate 和 startDate 元素包含简单的字符串，如清单 6 中所示。

清单 6. 添加简单的元素

在本例中，Christine 定义了三个仅包含文本的元素（与其他元素相对）作为内容。同样，它们都不具有任何属性。XML Schema 推荐标准定义了一系列可用于定义内容的不同类型。例如，可以指定 endDate 和 startDate 值必须为 datetime 类型的值。

回页首

创建更为复杂的元素

当然，如果所有元素都这样简单，您可能根本不需要模式了。Christine 将继续定义 ClassifiedList 元素（请参见清单 7）。

清单 7. 定义 ClassifiedList 元素

首先看最下面，Christine 创建了 ClassifiedAdType complexType。这种元素类型按顺序包含以下内容：一个 content 元素、一个 endDate 元素和一个 startDate 元素。回到最上面，她定义 ClassifiedList 元素包含一个元素，而此元素还包含一系列元素。不过，在本例中，它包含零个或更多 ClassifiedAdType 类型的元素，所有这些元素均命名为 ClassifiedAd。

到目前为止，仅通过这两个定义，她就已覆盖了文档结构的大部分。现在需要做的就是为 adId 属性添加定义。

回页首

添加属性

属性在 complexType 元素中定义，如清单 8 中所示。

清单 8. 添加属性，不过她还可以创建限制性更多的类型。

在本例中，Christine 将 adId 属性的内容限制为整数。不过，她还可以创建限制更多的类型。

回页首

使用 simpleTypes

XML Schema 提供了强大的功能，用以处理您的文档可能包含的实际内容。例如，Christine 可以指定 adId 属性一定只能包含大于或等于 1000 的整数（请参见清单 9）。

清单 9. 限制值

                    


...


   
       
       
       
   
   thousandOrGreater" />

这个定义并不涉及任何元素，因此 Christine 使用了 simpleType 而不是 complexType。她为定义为整数的基本类型创建了一个 restriction（一种对数据类型的限制）。她为该 restriction 添加了一个“facet”，指定最小值为 1000。XML Schema 定义了大量的此类 facet 以供使用。创建了此类型后，她就可以在属性定义中对其进行引用了。因为已经定义了数据，Christine 随后将此模式交给 Larry，供他用于构建实际的 WSDL。

回页首

SIMONE 2006-12-29 19:04 发表评论

了解 Web 服务规范: 第 1 部分：SOAP （3）

SIMONE — Fri, 29 Dec 2006 10:39:00 GMT

构建 SOAP 服务

如果您觉得构建 Web 服务客户机的过程相当简单，事实的确如此。而就很多方面而言，构建服务的过程也同样简单。

总体过程

创建 Axis2 Web 服务的整个过程涉及以下步骤：

创建服务清单
创建类
将其打包为 Axis 存档文件
将 Axis 存档文件上载到 Axis2 Web 应用程序
重新启动服务器（如果有必要）

这就是全部步骤。让我们首先从服务清单开始。

回页首

创建清单

服务清单告知 Axis2 应用程序（就更大的范围而言，应用服务器）哪个请求与哪个类对应。例如，可以如清单 22 中所示的那样指定两个服务函数。

清单 22. 在清单中指定两个服务函数

                    

    
        This is a sample Web Service for the newspaper's
 Content Managment System.
    

    CMSService

首先，定义服务，提供其名称和描述，并指定实际为请求服务的类。接下来，定义实际的操作。请注意，此示例指定了两种不同类型的 messageReceiver。第一个 RawXMLINOutMessageReceiver 用于传统的请求/响应服务。第二个 RawXMLINOnlyMessageReceiver 用于单向消息。操作的名称与有效负载的根元素以及要执行的方法对应。

将此文件保存为 services.xml。

接下来，让我们创建实际的应用程序。

回页首

创建应用程序

让我们首先创建模拟前面看到的 echo 函数的类（将直接返回原始有效负载的副本），如清单 23 中所示。

清单 23. CMSService 类

                    
import org.apache.axis2.om.OMElement;
import javax.xml.stream.XMLStreamException;

public class CMSService {

    public OMElement getNumberOfArticles(OMElement element)
                              throws XMLStreamException {

        element.build();
        element.detach();

        return element;
    }
}

要编译此应用程序，请确保 /lib 中的所有 *.jar 文件都在您的 CLASSPATH 上。

此应用程序相当简单，仅包含一个与 getNumbereOfArticles 操作对应的类。此函数和任何要作为操作的函数一样，接收单个 OMElement 参数（表示有效负载）。此处，您将首先使用 build() 方法来确定已接收到所有数据——AXIOM 使用一个 pull 方法访问数据——然后将元素从其当前树中分离，以便能够将其返回。

如果喜欢冒险，可以自由地部署服务和访问服务，以访问服务并查看结果。应该看到与清单 24 中所示类似的结果输出。

清单 24. CMSService 类响应

                    
classifieds

接下来让我们了解如何实际处理数据。

回页首

提取有效负载

为了从有效负载提取信息，将使用与 DOM 非常类似的技术来对接收到的有效负载元素进行操作（请参见清单 25）。

清单 25. 提取有效负载信息

                    
...
import javax.xml.stream.XMLStreamException;

public class CMSService {
    public OMElement getNumberOfArticles(OMElement element) 
                          throws XMLStreamException {
        element.build();
        element.detach();

        String rootName = element.getLocalName();
        OMElement categoryElement = element.getFirstElement();
        String categoryElementName = categoryElement.getLocalName();
        String categoryValue = childElement.getText();

        return element;
    }
}

请记住，有效负载的根是 getNumberOfArticles 函数接收的元素。在此情况下，将提取元素的名称，然后移动到第一个元素子项（与第一个子项不同，后者可能是空格文本节点）并提取其名称和值。请注意，使用的是 getText() 方法来提取实际上是 category 元素的文本节点子项的值。这无疑非常简捷！

回页首

创建并返回响应

最后，将需要使用从请求的有效负载提取数据来创建响应。在本例中，将从第二个函数（在实际应用程序中，该函数将进行一些其他的工作）提供响应（请参见清单 26）。

清单 26. 创建响应

                    
...
import javax.xml.stream.XMLStreamException;

public class CMSService {
    public OMElement getNumberOfArticles(OMElement element) 
                         throws XMLStreamException {
        element.build();
        element.detach();

        String rootName = element.getLocalName();
        OMElement childElement = element.getFirstElement();
        String childName = childElement.getLocalName();
        String categoryValue = childElement.getText();

        SOAPFactory factory = OMAbstractFactory.getSOAP12Factory();
        OMNamespace namespace = factory.createOMNamespace(
                            "http://daily-moon.com/cms/", "resp");
        OMElement resultElem = factory.createOMElement(
                                   "numberOfArticles",namespace);

        String actualValue = 
                         (articleCount(categoryValue)).toString();
        resultElem.setText(actualValue);

        return resultElem;
    }

    private Integer articleCount(String catId){

       //Perform some function such as searching the CMS 
       //database, and return the actual value.  For our 
       //purposes, you'll hardcode it.
       return new Integer(42);

    }
}

首先，创建将用于创建所有其他对象的工厂，然后创建将添加到响应的有效负载的命名空间。接下来，创建实际结果元素，在本例中为名为 numberOfArticles 的元素。

numberOfArticles 元素的内容将为 articleCount() 函数返回的一个数字,在本例中，该函数可以为任何内容。在实际的应用程序中，将进行所需进行的任何工作来获取此数据。获取了此数据后，会将其设置为 numberOfArticles 元素的内容，并直接返回该元素。

现在剩下的就是部署服务了。

回页首

部署服务

为了部署服务，需要创建一个 Axis 存档文件。此文件和 *.jar 或 *.war 文件类似，实际是使用特殊文件扩展名（在本例中使用的是 .aar）的 zip 文件。请按照以下步骤创建此文件：

将 /lib 目录中的所有文件添加到 CLASSPATH 并编译 CMSService.java 文件。
在与 CMSService.class 文件相同的目录中创建名为 META-INF 的新目录。
从包含 CMSService.class 文件的目录中发出以下命令： jar cvf CMSService.aar ./* 应该看到与以下类似的结果： added manifest adding:CMSService.class(in = 513) (out= 330)(deflated 35%) adding:CMSService.java(in = 328) (out= 182)(deflated 44%) ignoring entry META-INF/ adding:META-INF/services.xml(in = 391) (out= 229)(deflated 41%)
使用安装示例服务中列出的步骤将此服务添加到服务器上。（如果看到 Web 接口上有 Servlet 错误，请确保登录到了 Axis2 应用程序。如果会话已过期，应用程序将不一定会通知您，而可能会直接显示错误。）
如果有必要，请重新启动 Geronimo。（将可能不必在添加服务后进行此操作，但在进行更改后可能必须这样做。）

如果单击 View services 链接，应该看到与图 4 中所示类似的内容。

图 4. 可用服务

回页首

访问服务

现在已经完成了服务构建，接下来要通过客户机对其进行访问。对前面创建的 ClassifiedClient.java 文件进行以下更改（请参见清单 27）。

清单 27. 修改 ClassifiedClient

                    
...
public class ClassifiedClient {
    private static EndpointReference targetEPR = 
         new EndpointReference(
           "http://localhost:8080/axis2/services/CMSService");

    public static OMElement getEchoOMElement() {
        SOAPFactory fac = OMAbstractFactory.getSOAP12Factory();
        OMNamespace omNs = fac.createOMNamespace(
                "http://daily-moon.com/cms", "cms");
        OMElement method = fac.createOMElement("getNumberOfArticles", omNs);
        OMElement value = fac.createOMElement("category", omNs);
        value.addChild(fac.createText(value, "classifieds"));
        method.addChild(value);

        return method;
    }

    public static void main(String[] args) {
        try {
            OMElement payload = ClassifiedClient.getEchoOMElement();
            Options options = new Options();
            options.setTo(targetEPR);
            options.setTransportInProtocol(Constants.TRANSPORT_HTTP);

            ServiceClient sender = new ServiceClient();
            sender.setOptions(options);
            OMElement result = sender.sendReceive(payload);

            String response = result.getText();
            System.out.println("There are "+response+" classifieds at the moment.");

        } catch (Exception e) { //(XMLStreamException e) {
System.out.println(e.toString());
        }
    }
}

编译并运行了此应用程序后，应看到清单 28 中所示的响应。

清单 28. ClassifiedClient 响应

                    
There are 42 classifieds at the moment.

回页首

单向服务

继续讨论之前，让我们了解一下处理单向服务（而非请求/响应服务）时涉及到的不同之处。

服务

创建单向服务非常简单。此过程与创建请求/响应服务完全类似，至少不会实际返回任何内容。例如，可以为 CMSService 类创建 addArticle 操作，如图 29 中所示。

清单 29. CMSServiceclass 中的 addArticle 操作

...
    private Integer articleCount(String catId){
...
    }

    public void addArticle(OMElement element) 
                             throws XMLStreamException{
       element.build();
       System.out.println(element);
    }
}

在 services.xml 文件中，将 addArticle 操作指定为“in only”操作，因此不会等待返回任何内容，但即使这样，也能看到会实际发生一些事项，会在命令行输出接收到的有效负载。您将在 Geronimo 窗口中看到此信息。

在实际应用程序中，此方法将从有效负载提取信息，并会实际添加到某种类型的数据库或其他存储库。

回页首

客户机

此服务的客户机也与请求/响应服务所使用的服务类似（请参见清单 30）。

清单 30. 创建客户机

                    
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.client.ServiceClient;
import org.apache.axis2.om.OMElement;
import org.apache.axis2.SOAP.SOAPFactory;
import org.apache.axis2.om.OMAbstractFactory;
import org.apache.axis2.om.OMNamespace;

public class AddArticleClient {
    private static EndpointReference targetEPR = 
         new EndpointReference(
             "http://localhost:8080/axis2/services/CMSService");

    private static OMElement getOMElement(){

        SOAPFactory fac = OMAbstractFactory.getSOAP12Factory();
        OMNamespace omNs = fac.createOMNamespace(
                "http://daily-moon.com", "cms");
        OMElement method = fac.createOMElement("addArticle", omNs);

        OMElement category = fac.createOMElement("category", omNs);
        category.setText("classifieds");

        OMElement subcategory = 
                        fac.createOMElement("subcategory", omNs);
        category.setText("wantads");

        OMElement adtext = fac.createOMElement("article", omNs);
        adtext.setText("Do you  have good head for numbers"+
              " and a great deal of patience?  Do you like"+
              " to sit for hours sorting objects by their"+
              " size?  If so, then you could be the"+
              " next goober counter in the world famous"+
              " Murphy Brothers peanut factory. "+
              " Willingness to dress up as our mascot"+
              " helpful, but not required.");

        method.addChild(category);
        method.addChild(subcategory);
        method.addChild(adtext); 

        return method;

    }

    public static void main(String[] args) {
        try {
            OMElement payload = AddArticleClient.getOMElement();
            ServiceClient serviceClient = new ServiceClient();

            Options options = new Options();
            serviceClient.setOptions(options);
            options.setTo(targetEPR);

            serviceClient.fireAndForget(payload);

        } catch (AxisFault axisFault) {
            axisFault.printStackTrace();
        }
    }

}

尽管有效负载不同，但正如您在 getOMElement() 方法中看到的，编程方面目前的唯一真正的更改是使用 fireAndForget() 方法替代 sendReceive() 方法。此方法并不会返回响应。

如果运行此客户机，应该在 Geronimo 窗口中看到与图 5 中所示类似的输出。

图 5. 命令行输出

回页首

SIMONE 2006-12-29 18:39 发表评论

了解 Web 服务规范: 第 1 部分：SOAP （2）

SIMONE — Fri, 29 Dec 2006 10:35:00 GMT

理解 SOAP

现在已经安装了软件，接下来可以开始着手处理实际的 Web 服务了。正如我在其他类型的 Web 服务中提到的，您可以选择多种格式。在本系列中，将使用 SOAP。

XML 简介

进行传递的所有这些消息都基于可扩展标记语言（Extensible Markup Language，XML）。如果完全不熟悉 XML，在深入了解各个 Web 服务主题前，真的应该进行一些相关研究。不过，以下提供了继续学习本教程所需的基本知识。

XML 是一种“标记语言”，即给出了一种提供实际内容的附加信息的方式。此信息以“标记”的形式提供，这些标记用于指示“元素”。例如，考虑一下清单 5 中所示的简单 XML 文档。

清单 5. 包含基本内容的 XML 文件

                    

  Fun, fun, fun
  Vintage 1963 T-Bird.  Less than 300 miles.
Driven by my daughter until I took it away.  Serious 
inquires only.  555-3264 after 7 PM.

请留意此文本中的几个值得注意的地方。首先，这是文本。这就使其可以供任何人阅读，或在其中包含关于任何事物的内容。其次，标记使用 > 和 < 指示，开始标记具有一个名称，并可能带有各种属性（如文章 ID），而结束标记以反斜杠 (/) 表示。元素必须为自包含的，并进行了恰当嵌套。也就是说，不能使用与清单 6 所示类似的 XML 文档。

清单 6. 无效 XML 文档示例

                    

  Fun, fun, fun
  Vintage 1963 T-Bird.  
Less than 300 miles. Driven by my daughter until I 
took it away.  Serious inquires only.  555-3264 after 
7 PM.

XML 还提供了将内容划分为不同“命名空间”的方法，以便由应用程序对其进行不同的处理。例如，SOAP 消息可能与以下的清单 7 类似。

清单 7. 示例 SOAP 消息

                    

 
 
 
 
  
    classifieds
    forsale

不要担心消息的实际结构，但要注意存在两种不同的“前缀”，每个前缀与特定的命名空间对应。在这种情况下，我们是为了将 SOAP“信封”与实际的有效负载进行区分。

再次说明，关于 XML 有很多需要学习，但这些只是本教程需要了解的基础知识。

回页首

SOAP 信封

Web 服务消息的基本单元是实际的 SOAP 信封。这是包含处理消息所必需的所有信息的 XML 文档（请参见清单 8）。

清单 8. 示例 SOAP 信封

在本例中，获得了一个简单的 Envelope，其命名空间指定为 SOAP 1.2 版本。其中包含两个子元素 Header 和 Body。让我们了解一下这两个子元素所起的作用。

回页首

SOAP Header

SOAP 消息中的 Header 用于提供有关消息本身的信息，与用于应用程序的信息相对。例如，Header 可以包括路由信息，像清单 9 中的示例类似。

清单 9. Header 中的路由信息

                    

 
 
  
   
http://schemas.xmlSOAP.org/ws/2004/08/addressing/role/anonymous
   
  
  
   
http://localhost:8080/axis2/services/MyService
  
  ECE5B3F187F29D28BC11433905662036

本例中有一个 WS-Addressing 元素，其中包含有关消息将送达何处以及应将应答送达何处的信息。Header 可包含关于消息本身的所有类型的消息。事实上，SOAP 规范中使用了大量篇幅说明哪些元素可以放入 Header以及应由“SOAP 中间层”如何对其进行处理。也就是说，SOAP 规范并不假定消息将直接从一个点传递到另一个点（从客户机到服务器）。规范考虑了 SOAP 消息在送达最终目的地的过程中可能实际由多个中间层处理的情况，很清楚地说明了中间层应如何对待在 Header 中找到的信息。不过，对此的讨论不在本教程的范围之内。因此，目前只要知道 Header 可以提供许许多多的功能（如果您需要）即可。

接下来让我们看看实际的有效负载。

回页首

SOAP 体

发送 SOAP 消息时，都是有目的性的。您在尝试告诉接收者执行某种操作，或尝试向服务器传递相关信息。此信息称为“有效负载”。有效负载位于 Envelope 的 Body 中。它还具有自己的命名空间，在本例中其命名空间与内容管理系统对应。在此情况下，可以完全随意地选择命名空间。只需要与 SOAP 命名空间相异即可（请参见清单 10）。

清单 10. 有效负载示例

                    

 
 
...

 
  
    classifieds
    forsale
    
    Vintage 1963 T-Bird.  Less than 300 miles.  
Driven by my daughter until I took it away.  Serious inquires only.  
555-3264 after 7 PM.

在此例中，有效负载很简单，其中包含将文章添加到 Daily Moon 的内容管理系统的指令。

如何设计有效负载的选择过程将涉及到样式和编码的内容。

回页首

样式和编码

本系列教程的第 2 部分将更深入地了解此主题的内容（该部分讨论 Web 服务描述语言——WSDL），但在创建应用程序时，您将需要确定要发送和接收的实际有效负载的结构。为此，让我们花点时间讨论一下编程样式和编码。

简单来说，有两种不同的主流 SOA 消息编程样式。第一种是 RPC 样式，基于使用 SOAP 消息创建远程过程调用（Remote Procedure Call）的概念。在此样式中，基本思路是在向服务器发送命令（如“添加文章”），并将该命令的参数（如要添加的文章和应该添加到的类别）作为整个方法的子元素包含在其中，如清单 11 中所示。

清单 11. RPC 样式

RPC 样式的替代方法将数据直接作为 SOAP 体的内容处理，并在应用服务器对消息进行路由的信息中包含有关其所属的过程或函数的信息。（请参见清单 12）。

清单 12. 将数据作为 SOAP 体中的内容

                    
 
 
 
 
  
    classifieds
    forsale
    
    Vintage 1963 T-Bird.  Less than 300 
miles.  Driven by my daughter until I took it away.  
Serious inquires only.  555-3264 after 7 PM.

RPC 样式的一个变体就是与上面看到的 RPC/literal 相对的 RPC/encoded。在这种情况下，消息中包含类型信息，如清单 13 中所示。

清单 13. RPC/encoded 示例

                    

 
 
 
 
  
    xsi:type="xsd:string">classifieds
    xsi:type="xsd:string">forsale

    xsi:type="xsd:string" />
    xsi:type="xsd:string">Vintage 1963 
T-Bird.  Less than 300 miles.  Driven by my daughter until
I took it away.  Serious inquires only.  555-3264 after 7 
PM.

第二个样式称为 document/literal 样式，即将相应的数据直接添加到消息中，如清单 14 中所示。

清单 14. Document/literal 样式示例

                    

 
 
 
 
    classifieds
    forsale
    
    Vintage 1963 T-Bird.  Less than 300 miles.
  Driven by my daughter until I took it away.  Serious 
inquires only.  555-3264 after 7 PM.

在这种情况下，消息本身并不包含有关数据所提交到的进程的信息，此工作由路由软件进行。例如，所有对特定 URL 或端点的调用都可能指向特定的操作。另外，从技术上讲，可以使用 document/encoded 样式，但目前还没有人这样做，因此可以将其忽略。

在每个样式中都涉及到不同的折衷，本系列的第 2 部分将进一步对此进行详细讨论。不过，务必知道还有第三种样式“document wrapped”，并未正式地确定此样式，但由于各种互操作性原因而大受欢迎。在此情况下，有效负载的内容包装为单个元素，但元素并不据数据所属的过程或函数进行命名。从肉眼来看，这些消息几乎与 RPC/literal 消息完全相同。

回页首

消息交换模式

谈到发送消息，您有很多选择，可以发送请求并等待响应，发送请求但不等待响应，发送请求并在到达最终的目的地前通过多个中间层。但就实质而言，只有两个选择：

请求/响应：在请求/响应模式种，以 SOAP 消息的形式发送请求，然后直接等待发送回响应。请求可以为同步的，也可以是异步的。
单向消息传递：这种情况也称为“Fire and Forget”方法，发送请求但并不等待响应。可以在仅传递信息时或并不关心接收者对此如何响应时使用此方法。

现在，请注意并没有使用术语“客户机”和“服务器”。之所以这样，是因为这些消息交换模式几乎可以用于创建与上面提到的方法类似的任意数量的不同备选方法。例如，可以发送一条请求，然后依靠接收者对其进行处理，并在将来完成应完成的工作时发送一条消息。为此，将使用多个单向消息的组合，因此谈“客户机”和“服务器”并不合理，因为每个消息都有其接收方和发送方，所谓的客户机和服务器的位置会发生对换。

回页首

构建 SOAP 客户机

上面已经对理论进行了介绍，现在让我们开始构建实际的实现。首先从客户机开始。

以前的老方式

最初出现用于使用 SOAP 消息的 Java API 时，其用途非常特定化。它们的用途相当直接，用于创建 SOAP 消息。需要创建消息、Envelope、Header、Body 等等。例如，可以构建“旧式”客户机来访问前面安装的 MyService 服务的 echo 函数（请参见清单 15）。

注意：为了编译并运行此客户机，将需要 SAAJ 实现（如原始 Axis 软件）。可以从 http://ws.apache.org/axis/ 下载 Axis。据说 Axis2 0.95 也包含此实现，但本教程未针对其进行测试。

清单 15. 旧式 SOAP 客户机

                    
import javax.xml.SOAP.*; 
import javax.xml.transform.*;
import java.io.FileInputStream;
import javax.xml.transform.stream.*;
import org.w3c.dom.*;

public class SendSOAP {
    
   public static void main(String args[]) {
        
      try {
      
         MessageFactory messageFactory = MessageFactory.newInstance();
         SOAPMessage message = messageFactory.createMessage();
         
         //Create objects for the message parts            
         SOAPPart SOAPPart = message.getSOAPPart();
         SOAPEnvelope envelope = SOAPPart.getEnvelope();
         SOAPBody body = envelope.getBody();

         SOAPElement bodyElement = 
           body.addChildElement(envelope.createName("echo", 
            "req", "http://localhost:8080/axis2/services/MyService/"));
         bodyElement.addChildElement("category")
                             .addTextNode("classifieds");
         message.saveChanges();

         SOAPPart SOAPpartbefore = message.getSOAPPart();
         SOAPEnvelope reqenv = SOAPpartbefore.getEnvelope();

         System.out.println("REQUEST:");
         System.out.println(reqenv.toString());

         //Now create the connection
         SOAPConnectionFactory SOAPConnFactory = 
                           SOAPConnectionFactory.newInstance();
         SOAPConnection connection = 
                           SOAPConnFactory.createConnection();
         
         SOAPMessage reply = connection.call(message, 
                   "http://localhost:8080/axis2/services/MyService");

         SOAPPart SOAPpart = reply.getSOAPPart();
         SOAPEnvelope replyenv = SOAPpart.getEnvelope();

         System.out.println("\nRESPONSE:");
         System.out.println(replyenv.toString());

         connection.close();
     
     } catch (Exception e){
         System.out.println(e.getMessage());
     }
  }
}

请注意，您要直接创建 SOAPEnvelope、SOAPBody 等内容。可以向消息体添加 echo 和 category 等元素。将从其中创建连接，进行调用，同样也能遍历 SOAP 消息的结构来获取实际的内容。如果要运行此客户机，应该看到与清单 16 中所示类似的响应。

清单 16. 当时的客户机

                    
REQUEST:

 
  
     classifieds
  
 


RESPONSE:

 
  
   
http://schemas.xmlSOAP.org/ws/2004/08/addressing/role/anonymous
   
  
  
   
http://localhost:8080/axis2/services/MyService
  
  ECE5B3F187F29D28BC11433905662036
 
 
  
     classifieds

echo 服务所进行的所有工作实际就是对其所接收到的请求进行应答，通过这一点可以很好地了解旧式处理方法与新式处理方法间的差别。接下来让我们看看二者的差异。

回页首

新方式

现在越来越趋向于对程序员隐藏使用基于 XML 的 Web 服务消息的复杂性。为此进行了大量的工作，其中大部分的目标都是希望尽可能让 Web 服务编程与任何其他体系结构的编程工作一样进行。

在 Axis2 中，实际上并不仅限于此。Axis2 引入了一种全新的方式来使用表示 SOAP 消息的 XML（尽管表面看来与使用文档对象模型类似）。AxIs 对象模型（Axis Object Model，AXIOM）进行了一系列更改，但我暂时将仅提一下其对消息的信息集的关注，消息集是元素和属性中包含的实际信息，而不是通常看到的序列化版本。不过，更为重要的是，Axis2 将为您处理 SOAP 信封，从而可以将精力放在构建有效负载上（或者，如果是实际的服务，则是分析有效负载和创建响应）。接下来让我们看看如何进行此工作。

回页首

创建请求

要开始创建客户机，请确保 Axis2 lib 目录中的所有 *.jar 文件——指 Standard 分发版，而不是 War 分发版——都在您的 CLASSPATH 上，并创建名为 ClassifiedClient 的新类。创建有效负载，如清单 17 中所示。

17. 有效负载

                    
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.client.ServiceClient;
import org.apache.axis2.om.OMElement;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import java.io.StringWriter;
import org.apache.axis2.om.OMAbstractFactory;
import org.apache.axis2.SOAP.SOAPFactory;
import org.apache.axis2.om.OMFactory;
import org.apache.axis2.om.OMNamespace;

public class ClassifiedClient {

    public static OMElement getEchoOMElement() {
        SOAPFactory fac = OMAbstractFactory.getSOAP12Factory();
        OMNamespace omNs = fac.createOMNamespace(
                "http://daily-moon.com/cms", "cms");
        OMElement method = fac.createOMElement("echo", omNs);
        OMElement value = fac.createOMElement("category", omNs);
        value.addChild(fac.createText(value, "classifieds"));
        method.addChild(value);

        return method;
    }

    public static void main(String[] args) {
        try {
            OMElement payload = ClassifiedClient.getEchoOMElement();
        } catch (Exception e) { //(XMLStreamException e) {
            System.out.println(e.toString());
        }
    }
}

首先，创建工厂和命名空间，并使用其创建各个元素。在本例中，您将创建与前面示例完全相同的元素，因为将再次使用此客户机访问 echo 函数。（稍后将对其进行更改，以访问真正的服务。）

接下来，将创建请求。

回页首

创建请求

下一步将创建实际的请求。同样，这方面也体现出技术随时间的发展。这里不会直接将请求发送到 URL，而要设置“端点引用”，如清单 18 中所示。

清单 18. 请求中的端点引用

                    
...
public class ClassifiedClient {
    private static EndpointReference targetEPR = new
        EndpointReference(
           "http://localhost:8080/axis2/services/MyService");

    public static OMElement getEchoOMElement() {
...
    }

    public static void main(String[] args) {
        try {
            OMElement payload = ClassifiedClient.getEchoOMElement();
            Options options = new Options();
            options.setTo(targetEPR);
            options.setTransportInProtocol(Constants.TRANSPORT_HTTP);

        } catch (Exception e) { //(XMLStreamException e) {
            System.out.println(e.toString());
        }
    }
}

对 WS-Addressing 的全面讨论不在本教程的范畴之内，但完全可以说端点引用包含消息将定向到的 URL，还可以有选择地包含其他信息，如应答地址和其他资源属性等。

首先，为请求创建 Options，以便为请求设置 EPR 和其他信息（如打算使用的传输协议）。完成了这些后，就可以实际发送请求了。

回页首

发送请求

完成了设置后，就可以发送请求了。对于 Axis 的 0.94 版，首选的方式是通过 ServiceClient 类发送消息，如清单 19 中所示。

清单 19. 发送请求

                    
...
    public static void main(String[] args) {
        try {
            OMElement payload = ClassifiedClient.getEchoOMElement();
            Options options = new Options();
            options.setTo(targetEPR);
            options.setTransportInProtocol(Constants.TRANSPORT_HTTP);

            ServiceClient sender = new ServiceClient();
            sender.setOptions(options);
            OMElement result = sender.sendReceive(payload);

        } catch (Exception e) { //(XMLStreamException e) {
            System.out.println(e.toString());
        }
    }
}

将创建 ServiceClient 对象，并为其设置前面创建的 Options。然后就可以直接发送消息了。由于希望得到响应，因此将使用 sendReceive() 方法（该方法用于 in/out 类型的消息）。将在本教程的单向服务部分讨论单向消息的信息。sendReceive() 方法将在客户机接收到实际响应时将其返回。

回页首

输出结果

实际上，sendReceive() 并不会返回整个响应，而仅返回有效负载。如果将结果输出到命令行，应该清楚地看到清单 20 中的内容。

清单 20. sendReceive 输出

                    

...
            sender.setOptions(options);
            OMElement result = sender.sendReceive(payload);

            System.out.println(result.toString());

        } catch (Exception e) { //(XMLStreamException e) {
            System.out.println(e.toString());
        }
    }
}

运行此客户机将获得清单 21 中所示的响应。

清单 21. sendReceive 响应

                    
classifieds

当然，接收到此数据后，可以使用其进行任何工作。接下来，我们将构建实际的 getNumberofArticles() 服务。

回页首

SIMONE 2006-12-29 18:35 发表评论

了解 Web 服务规范: 第 1 部分：SOAP （1） http://ibm.csdn.net/ISN_J.aspx?action=JMP&pointid=1319

SIMONE — Fri, 29 Dec 2006 10:25:00 GMT

什么是 Web 服务？

首先，让我们从总体上了解一下什么是 Web 服务，以及它们为何对软件开发重要。

究竟为什么重要呢？

如果您没有听说过有关面向服务的体系结构 (SOA) 和 Web 服务的大量信息，您就不会阅读本文，那么问题就应该是，为什么此内容这样重要？答案是，此内容之所以重要，是因为这是应用程序彼此进行通信的方式的典型变化。SOAs 已经存在很长很长时间了。SOA 最初主要由中间件应用程序组成，至少进行连接的两端都属于同一种类型的中间件。另一方面，Web 服务由一组标准组成，用于在不需要特定类型的中间件、编程语言甚至操作系统的前提下让各种不同的系统进行通信。接下来，让我们了解一下其发展的历程。

回页首

传统应用程序

首先从计算机发明开始，当时给人感觉非常不错。计算机能执行奇迹般的任务，可实现很多手动工作的自动化，包括复杂的计算、财务工作等等很多其他任务。

但传统应用程序是“竖井”(Silo) 型的。人力资源应用程序无法与财务应用程序真正通信，而后者又无法和分布应用程序进行真正的通信。所有这些应用程序都有独立的领域，在独立的计算机上运行，尽管很有用，但并不能很好地在彼此间共享数据。当时可以选择对批处理流程进行连接，以将数据从一个系统移动到另一个系统，但这并不适合进行实时集成。

回页首

分布式计算

在我们的进化链中的第二步是分布式计算。分布式计算允许不同的应用程序彼此进行通信（即使位于不同的计算机上也是如此）。CORBA、MTS 和 Enterprise Java Bean (EJB) 等技术提供了包含各种类别的注册中心的系统，因此应用程序可以找到其希望与之进行交互的组件，然后像调用本地的组件一样调用这些组件。

这些系统由可同时满足这两个要求的中间件（或更具体一些，面向消息的中间件）提供支持。现在能以特定的方式构建应用程序，即使位于不同的地理位置，也能访问其他系统上的资源。

但仍然有一个问题。虽然系统可以自由地与系统内的任何对象进行通信，但仍然是一个封闭的系统。至少，客户机应用程序必须与服务器应用程序使用相同的技术。另外，通常并不会将系统设计为从创建其的个体组织外进行访问。

回页首

Web 服务

此进化链中下一个几乎不可避免的链接点就是 Web 服务。“Web 服务”基于 XML 和 HTTP（大多数情况下），对很多人具有不同的含义，但在此处，我们要将 Web 服务作为系统间基于 SOAP 的消息交换进行讨论。

这些消息由 XML 组成（XML 是一个基于文本的开放标准），可由来自任何应用程序（任何设计为接收此类消息的应用程序）的任何人进行访问。这就扩展了应用程序的范围，从而包含任何可通过网络对其进行访问的任何人。（如果这让您开始考虑安全问题，不要紧，您将在本系列的第 4 部分了解如何处理这方面的问题。）

基于 SOAP 的 Web 服务将要发送与清单 1 中所示类似的 XML 消息。

清单 1. 基于 SOAP 的 Web 服务

                    

 
  
     classifieds

这些消息将从一个系统进入另一个系统（通常通过 HTTP）。接收系统对消息进行解释，进行应该进行从处理，然后发送另一个 SOAP 消息作为响应。

这个系统很简单，正因为如此，有很多企业级计算方面的内容都尚未涉及。幸运的是，其中的很多方面已被纳入考虑范畴，且具有自己的相关规范来确定此事务应如何进行，以包含传统的面向消息的中间件的很多安全和其他方面的内容。

回页首

其他类型的 Web 服务

如果我没有说明 SOAP 并不是唯一的处理 Web 服务的方法，那就有些失职了。有很多其他基于 XML 的方法用于在系统间发送信息，其中一些适用于企业环境，而另一些则不适合此用途。例如，Amazon 是为公众提供对其系统的 Web 服务访问的第一批基于 Web 服务的公司之一。Amazon 包含了一个基于 SOAP 的服务，但也提供了一个基于 Representational State Transfer (REST) 的服务。

REST 是一种 Web 服务类型，其中，用户直接访问 URL，相应的响应是与清单 2 中所示类似的简单 XML 文档。

清单 2. REST 响应

                    

   classifieds
   forsale
   
       
       30 ft ladder, only used once.  Willing to let
go for half it's worth. Has slight dent near the middle.  
Harder than a human head. $150 OBO.
    
   
       
       Vintage 1963 T-Bird.  Less than 300 miles.  
Driven by my daughter until I took it away.  Serious inquires only.
555-3264 after 7 PM.

这些消息并没有特定的格式。可以为任何数据。

另一种 Web 服务类型要使用 XML-RPC 之类的标准。在这种情况下，命令将通过与清单 3 中所示类似的 XML 发送到系统。

清单 3. XML-RPC

                    


   CMS.getNumberOfArticles
   
      
         classifieds
      
      
         forsale

其响应将采用类似的格式。

在学习使用 SOAP 的过程中，您可以会打心底里认为 REST 和 XML-RPC 比基于 SOAP 的系统要简单得多。的确如此。在某些情况下 REST 和 XML-RPC 比 SOAP 系统简单。不过，我们讨论的不是在网站上显示天气的简单应用程序。我们此处讨论的是企业级应用程序，而企业级的应用程序需要企业级的属性，如安全、互操作性等等。这些功能在有关基于 SOAP 的 Web 服务的其他规范中进行了定义，因而，从长期来看，SOAP 更适合用于企业级应用程序。

让我们了解一下这些规范。

回页首

基本 Web 服务规范

Web 服务规范通常归为两类：基本 Web 服务规范和扩展 Web 服务规范。基本规范有：

SOAP：SOAP 规范是所有基于 SOAP 的 Web 服务的基础，详细说明了实际消息的格式。其中还详细说明了应用程序应如何对待消息的特定方面（如“Header”中的元素），从而可以创建特定类型的应用程序，使其中的消息在达到最终的目的地前在多个中间层之间进行传递。本教程将涵盖 SOAP 规范的内容。
WDSL：Web 服务描述语言是详细说明描述基于 SOAP 的 Web 服务的标准方式的规范，包括消息应采用的形式以及应将其发送到何处。其中还详细说明了此类消息的响应。当与相应的工具结合使用时，WSDL 允许以编程方式创建对 Web 服务的调用，甚至不用知道所查找的 Web 服务是什么；应用程序可以从 WSDL 文件中提取这些详细信息，并提供要使用的编程接口。我们将在本系列的第 2 部分讨论 WSDL。
UDDI：统一描述、发现和集成 (Universal Description, Discovery and Integration) 是一项从最初提出后发生了一系列变化的标准。其最初的目的是为了给各个公司提供在全球注册中心中注册服务并在此注册中心中搜索可能想使用的服务的机制。不过，由于很多公司对于将其系统对外开放的问题上都相当保守，这个目标并没有完全实现。但是，很多公司已将 UDDI 作为内部的服务及服务信息注册中心使用，本系列第 3 部分将对其使用进行详细论述。

以上是一些基础知识。另外差不多还有数十种扩展标准，可进一步扩展基于 SOAP 的服务的用途。

回页首

扩展 Web 服务规范

总共有数十种 WS-* 规范，其中几种对企业尤为有用。即：

WS-Security：此规范处理加密和数字签名，允许创建特定类型的应用程序，以防止窃听消息，且能实现不可否认功能。本系列的第 4 部分将讨论 WS-Security。
WS-Policy：此规范对 WS-Security 进行了扩展，允许更具体地说明谁可以采用何种方式使用服务。本系列的第 5 部分将讨论 WS-Policy。
WS-I：尽管 Web 服务应设计成具有互操作性，但在实际中，各个规范对不同实现的解释的灵活性常常足以导致出现问题。WS-I 提供了一组可用于防止出现各种问题的标准和实践，并提供了标准化测试来检查问题。WS-I 是本系列的第 6 部分将要讨论的主题。
WS-BPEL：单个服务很好处理，但应用程序在大多数情况下则较难处理。企业级计算要求至少将多个服务组合为一个完整的系统，而 WS-BPEL 提供了用于指定创建此类系统所必需的交互（如分支和并发处理）。本系列的第 7 部分将讨论 WS-BPEL。

在 Web 服务中扮演重要角色的其他规范将不在本系列中讨论，其中包括 WS-ReliableMessaging（允许确定检索一个且仅一个消息副本）、Web 服务资源框架 (WSRF)（允许使用在无状态环境中非常重要的状态）和 Web 服务分布式管理 (WSDM)（讨论 Web 服务的管理和使用问题）。可以在本教程的参考资料中获得有关这些规范及其他规范的更多信息。

回页首

将要完成的工作

在本教程中，您将了解 Daily Moon 报社的 Classifieds Department 如何将其自己的系统与内容管理系统使用的基于 Web 服务的接口进行集成。将创建一个应用程序，以创建基于 SOAP 的消息，将其发送到服务，然后检索响应。完成了此工作后，您将了解如何创建服务来响应请求并发送自己的响应。将通过创建 Java 应用程序（使用或不使用应用服务器）来完成此工作。

回页首

设置

现在已经了解了所涉及的基本原理，接下来让我们看看如何实际创建应用程序。首先要使所需软件就绪。

设置 Apache Geronimo

将需要的第一个软件是 Web 应用服务器。为什么需要 Web 应用服务器呢？因为您会发现，没有 Web 应用服务器很难提供 Web 服务。Web 应用服务器将侦听请求，将这些请求转换为实际服务可以理解的内容，然后进行任何必要的处理。

此过程中几乎可以使用任何 Web 服务器，但在大多数情况下都将使用能简化此过程的软件（通常要求使用某种类型的实际应用服务器）。具体来说，本教程假定您将使用 Java 应用服务器。（实际上，将使用 J2EE 应用服务器。）

对于 J2EE 服务器，有很多选择；在本例中将使用 Apache Geronimo。Geronimo 是作为 IBM WebSphere Application Server Community Edition 基础的开放源代码应用服务器。Geronimo 很小，非常易于安装和管理。它还能与其他 Apache 项目（如稍后将安装的 Axis2）一起良好地工作。

请下载相关软件（请参阅先决条件）并将文件提取到目标目录中。您会发现所提取的文件中包含自身的目录，因此可以直接对其进行解包，并可将其移动到任何位置。任何目录都是可接受的，但要避免名称中包含空格的目录，如“Program Files”、“Documents and Settings”或其子目录。例如，本教程的测试安装使用的是 e:\geronimo-1.0。

就是这里。已经在其中安装了 Geronimo。这不是很简单么？

要启动此服务器，请打开命令提示符窗口，并执行以下命令：

cd
java -jar server.jar

要确保服务器正在运行，请打开浏览器，并指向清单 4 中所示的 URL：

清单 4. 服务器 URL

                    
http://localhost:8080

应该看到与图 1 中所示类似的页面。

图 1. 服务器正在运行

现在让我们开始安装 Web 服务软件。

回页首

安装 Apache Axis2

完全可能从普通 HTTP 服务器提供 Web 服务。不过，这样并不明智。处理 SOAP 消息需要进行很多工作，但没有必要完全从头进行所有工作。Apache Axis 项目几年前就对此任务进行了简化，创建了可方便地创建和处理 Web 服务的环境。该软件包含了多个应用程序，可帮助从普通项目创建 Web 服务，从 Web 服务创建 Java 对象，并对二者进行处理。Apache 小组已推出了 Axis 的新版本 Axis2，该版本继承了 Axis 上的所有已有功能，并通过更改体系结构实现了更大的灵活性，从而将其推向了一个新的高度。这很重要，因为 Web 服务规范随时都在增加。Axis2 的构造允许它更方便与 WSS4J、Apache 的 WS-Security 实现等项目集成。由于我们将在以后使用这些项目，因此请现在安装 Axis2（有关下载信息，请参阅先决条件）。

请确保同时下载 Binary Distribution 和 War Distribution。前者将帮助构建客户机，而后者用于帮助构建服务。

要将 Axis2 安装到 Web 服务器中，请将 axis2.war 文件复制到 Geronimo 的 deploy 目录。（您将需要确保已经至少启动过 Geronimo 一次，才能保证存在此目录。）Geronimo 将自动检测其是否存在，因此不必手动部署任何内容。

回页首

验证 Axis 的安装

要确保已经恰当安装了所有内容，请将浏览器指向 http://localhost:8080/axis2/index.jsp 并单击 Validate。

应该看到与图 2 中所示类似的页面。

图 2. Axis 安装成功

在继续本教程的其他内容前，请确保成功安装了 Axis。

回页首

安装示例服务

将要编写的第一个应用程序是客户机，因此将需要其可访问的服务。幸运的是，Axis2 分发版提供了若干此类服务。首先，将按照以下所示安装 MyService 服务：

通过将浏览器指向 http://localhost:8080/axis2/Login.jsp 并登录，从而通过身份验证。缺省用户名和密码分别为 admin 和 Axis2。
单击 Upload service>Browse。
导航到 MyService.aar 文件。可以在标准 Axis2 分发版的 samples\userguide 目录下找到该文件。单击 OK。
单击 Upload。

应该看到一个通知，指示服务已添加（请参阅图 3）。在缺省情况下，Axis2 包含“热部署”功能，因此不必进行任何操作来激活。

如 3. MyService.aar 已上载

现在，让我们了解一下将要构建的内容。

回页首

SIMONE 2006-12-29 18:25 发表评论

通过 Axis2 开发 Web 服务，第 1 部分: 通过 Axis2 运行时部署和使用简单 Web 服务

SIMONE — Wed, 27 Dec 2006 06:24:00 GMT

摘要: 通过 Axis2 开发 Web 服务，第 1 部分: 通过 Axis2 运行时部署和使用简单 Web 服务 ... 阅读全文

SIMONE 2006-12-27 14:24 发表评论

关于Web Services以及Axis2技术(客户端和服务器端实现)

SIMONE — Wed, 27 Dec 2006 05:42:00 GMT

Web Services以及Axis2技术之二

    本篇是继关于Axis2发布Web Service之后的又一随笔，此篇的主要任务是讲述使用Axis2开发客户端和服务器端的具体实现。相信大家在看本篇的时候已经具备了一定的Web Service开发基础，因此我主要是以例子的方式来说明，文字会相对较少。同时，我会在最后提供几个优秀的网址给大家。

    例一（简单的字符串传送服务实现）

客户端：
com.udm.iudmservice.IUDMServiceStub stub = new com.udm.iudmservice.IUDMServiceStub();
com.udm.iudmservice.types.GetUserAllRegServices param234 = (com.udm.iudmservice.types.GetUserAllRegServices) getTestObject (com.udm.iudmservice.types.GetUserAllRegServices.class);
GetUserAllRegServicesResponse resp = stub.getUserAllRegServices(param234);
OMElement ret = resp.get_return()[0];
System.out.println(ret.getText());                               //此为测试语句
服务器端：
GetUserAllRegServicesResponse res = new GetUserAllRegServicesResponse();
OMElement resp = fac.createOMElement("Return", omNs);
resp.setText("返回的结果!");
System.out.println("返回结果为:" + resp.getText()); //此为测试语句
res.set_return(new OMElement[] { resp });

    例二（文件传送的具体实现）

客户端：

import org.apache.axiom.om.OMAbstractFactory;

import org.apache.axiom.om.OMElement;

import org.apache.axiom.om.OMFactory;

import org.apache.axiom.om.OMNamespace;

import org.apache.axiom.om.OMText;

import org.apache.axiom.soap.SOAP11Constants;

import org.apache.axiom.soap.SOAP12Constants;

import org.apache.axis2.Constants;

import org.apache.axis2.addressing.EndpointReference;

import org.apache.axis2.client.Options;

import org.apache.axis2.client.ServiceClient;

import javax.activation.DataHandler;

import javax.activation.FileDataSource;

import javax.xml.namespace.QName;

import java.io.File;

import java.io.InputStream;

public class FileTransferClient {

private static EndpointReference targetEPR = new EndpointReference("http://127.0.0.1:8080/axis2/services/interop");

public static boolean upload(String mailboxnum, short greetingType, File file, String fileType) {

try {

OMElement data = buildUploadEnvelope(mailboxnum, greetingType, file, fileType);

Options options = buildOptions();

ServiceClient sender = new ServiceClient();

sender.setOptions(options);

System.out.println(data);

OMElement ome = sender.sendReceive(data);

System.out.println(ome);

String b = ome.getText();

return Boolean.parseBoolean(b);

}

catch(Exception e) {

}

return false;

}

public static InputStream download(String mailboxnum, short greetingType, String FileType) {

try {

OMElement data = buildDownloadEnvelope(mailboxnum, greetingType, FileType);

Options options = buildOptions();

ServiceClient sender = new ServiceClient();

sender.setOptions(options);

System.out.println(data);

OMElement ome = sender.sendReceive(data);

System.out.println(ome);

OMText binaryNode = (OMText) ome.getFirstOMChild();

DataHandler actualDH = (DataHandler) binaryNode.getDataHandler();

return actualDH.getInputStream();

}

catch(Exception e) {

}

return null;

}

private static OMElement buildUploadEnvelope(String mailboxnum, short greetingType, File file, String FileType) {

DataHandler expectedDH;

OMFactory fac = OMAbstractFactory.getOMFactory();

OMNamespace omNs = fac.createOMNamespace("http://example.org/mtom/data", "x");

OMElement data = fac.createOMElement("upload", omNs);

OMElement fileContent = fac.createOMElement("fileContent", omNs);

FileDataSource dataSource = new FileDataSource(file);

expectedDH = new DataHandler(dataSource);

OMText textData = fac.createOMText(expectedDH, true);

fileContent.addChild(textData);

OMElement mboxnum = fac.createOMElement("mailboxnum", omNs);

mboxnum.setText(mailboxnum);

OMElement gtType = fac.createOMElement("greetingType", omNs);

gtType.setText(greetingType+"");

OMElement fileType=fac.createOMElement("fileType", omNs);

fileType.setText(FileType);

data.addChild(mboxnum);

data.addChild(gtType);

data.addChild(fileType);

data.addChild(fileContent);

return data;

}

private static OMElement buildDownloadEnvelope(String mailboxnum, short greetingType, String FileType) {

OMFactory fac = OMAbstractFactory.getOMFactory();

OMNamespace omNs = fac.createOMNamespace("http://example.org/mtom/data", "x");

OMElement data = fac.createOMElement("download", omNs);

OMElement mboxnum = fac.createOMElement("mailboxnum", omNs);

mboxnum.setText(mailboxnum);

OMElement gtType = fac.createOMElement("greetingType", omNs);

gtType.setText(greetingType+"");

OMElement fileType=fac.createOMElement("fileType", omNs);

fileType.setText(FileType);

data.addChild(mboxnum);

data.addChild(gtType);

data.addChild(fileType);

return data;

}

private static Options buildOptions() {

Options options = new Options();

options.setSoapVersionURI(SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);

options.setTo(targetEPR);

// enabling MTOM in the client side

options.setProperty(Constants.Configuration.ENABLE_MTOM, Constants.VALUE_TRUE);

options.setTransportInProtocol(Constants.TRANSPORT_HTTP);

return options;

}

public static void main(String agrs[]) { //此为测试主函数

String file = "C:/deploy.wsdd";

short gt = 1;

String mn = "20060405";

String ft="wsdd";

boolean rtv = upload(mn,gt,new File(file),ft);

System.out.println(rtv);

InputStream is = download(mn,gt,ft);

}

}
服务器端：

import org.apache.axiom.attachments.utils.IOUtils;

import org.apache.axiom.om.OMAbstractFactory;

import org.apache.axiom.om.OMElement;

import org.apache.axiom.om.OMFactory;

import org.apache.axiom.om.OMNamespace;

import org.apache.axiom.om.OMText;

import org.apache.axis2.AxisFault;

import java.io.FileOutputStream;

import java.io.*;

import java.util.Iterator;

import javax.activation.DataHandler;

import javax.activation.FileDataSource;

public class interopService {

public static final String TMP_PATH = "c:/tmp";

public OMElement upload(OMElement element) throws Exception {

OMElement _fileContent = null;

OMElement _mailboxnum = null;

OMElement _greetingType = null;

OMElement _fileType = null;

System.out.println(element);

for (Iterator _iterator = element.getChildElements(); _iterator.hasNext();) {

OMElement _ele = (OMElement) _iterator.next();

if (_ele.getLocalName().equalsIgnoreCase("fileContent")) {

_fileContent = _ele;

}

if (_ele.getLocalName().equalsIgnoreCase("mailboxnum")) {

_mailboxnum = _ele;

}

if (_ele.getLocalName().equalsIgnoreCase("greetingType")) {

_greetingType = _ele;

}

if (_ele.getLocalName().equalsIgnoreCase("fileType")) {

_fileType = _ele;

}

if (_fileContent == null || _mailboxnum == null || _greetingType== null || _fileType==null) {

throw new AxisFault("Either Image or FileName is null");

}

OMText binaryNode = (OMText) _fileContent.getFirstOMChild();

String mboxNum = _mailboxnum.getText();

String greetingType = _greetingType.getText();

String fileType = _fileType.getText();

String greetingstoreDir = TMP_PATH+"/"+mboxNum;

File dir = new File(greetingstoreDir);

if(!dir.exists()) {

dir.mkdir();

}

String filePath = greetingstoreDir+"/"+greetingType+"."+fileType;

File greetingFile = new File(filePath);

if(greetingFile.exists()) {

greetingFile.delete();

greetingFile = new File(filePath);

}

// Extracting the data and saving

DataHandler actualDH;

actualDH = (DataHandler) binaryNode.getDataHandler();

FileOutputStream imageOutStream = new FileOutputStream(greetingFile);

InputStream is = actualDH.getInputStream();

imageOutStream.write(IOUtils.getStreamAsByteArray(is));

// setting response

OMFactory fac = OMAbstractFactory.getOMFactory();

OMNamespace ns = fac.createOMNamespace("http://example.org/mtom/data", "x");

OMElement ele = fac.createOMElement("response", ns);

ele.setText("true");

return ele;

}

public OMElement download(OMElement element) throws Exception {

System.out.println(element);

OMElement _mailboxnum = null;

OMElement _greetingType = null;

OMElement _fileType = null;

for (Iterator _iterator = element.getChildElements(); _iterator.hasNext();) {

OMElement _ele = (OMElement) _iterator.next();

if (_ele.getLocalName().equalsIgnoreCase("mailboxnum")) {

_mailboxnum = _ele;

}

if (_ele.getLocalName().equalsIgnoreCase("greetingType")) {

_greetingType = _ele;

}

if (_ele.getLocalName().equalsIgnoreCase("fileType")) {

_fileType = _ele;

}

String mboxNum = _mailboxnum.getText();

String greetingType = _greetingType.getText();

String fileType = _fileType.getText();

String filePath = TMP_PATH+"/"+mboxNum+"/"+greetingType+"."+fileType;

FileDataSource dataSource = new FileDataSource(filePath);

DataHandler expectedDH = new DataHandler(dataSource);

OMFactory fac = OMAbstractFactory.getOMFactory();

OMNamespace ns = fac.createOMNamespace("http://example.org/mtom/data", "x");

OMText textData = fac.createOMText(expectedDH, true);

OMElement ele = fac.createOMElement("response", ns);

ele.addChild(textData);

return ele;

}

}
Services.xml配置文件：

name="MTOMService">

This is a sample Web Service with two operations,echo and ping.

name="ServiceClass"locked="false">sample.mtom.interop.service.interopService

name="upload">

urn:upload

class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>

name="download">

urn:download

class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>

两个学习网址http://www-128.ibm.com/developerworks/cn/（IBM的开发网中国站）
http://www.apache.org/ (Apache公司的官方网站)

最后：祝福大家在程序的天空里越飞越高！！！

SIMONE 2006-12-27 13:42 发表评论

本人收集的一些关于WEB SERVICES 的优秀网址跟大家分享

SIMONE — Wed, 27 Dec 2006 05:40:00 GMT

developerWorks 中国网站 Web 服务专区：
http://www-900.ibm.com/developerWorks/cn/webservices/index.shtml
Java Web Services 的中文教程
http://gceclub.sun.com.cn/NASApp/sme/controller/bottomlearning?cat_id=010103

http://www.ws-i.org/
http://www-106.ibm.com/developerworks/webservices/
http://www.w3.org/2002/ws/
http://www.webservices.org/
http://www.webservicesarchitect.com/
http://msdn.microsoft.com/webservices
http://www.soapware.org
http://www.soaprpc.com
http://java.sun.com/webservices
http://www.xmethods.com/
http://hosting.msugs.ch/eyesoft/index.htm
http://www.webservices.org/
http://www.salcentral.com/salnet/webserviceswsdl.asp
http://www.learnxmlws.com/
http://searchwebservices.techtarget.com/
http://forum.uddi-china.org/
http://www.soapwebservices.com/
http://soapagent.com/
http://www.soapclient.com/
http://www.soapware.org/

(如果还有好的网站也请大家补充)

SIMONE 2006-12-27 13:40 发表评论

Axis2体系结构中文手册

SIMONE — Fri, 22 Dec 2006 09:42:00 GMT

摘要: 前言结构都是它本身所能产生效率的结果。任何一个成功结构都是基于它期望的需求。我们通过期望用 Axis2 做什么来开始我们的 Axis2 之旅。用 Axis2 做什么在 SOAP 的术语里，一个 We... 阅读全文

SIMONE 2006-12-22 17:42 发表评论

AXIS服务间传递JavaBean及其安全解决

SIMONE — Thu, 02 Nov 2006 05:39:00 GMT

在AXIS服务间传递JavaBean及其安全解决
这是AXIS学习笔记的最后一篇。在前面我们讨论了最简单的HelloWorld服务，客户端并没有向服务器端
传递参数，现在我们来传传JavaBean。当然，也可以传递你自己定义的JAVA类，但那样你必须自己创建
专门的XML序列化器和反序列化器；而对JavaBean，AXIS提供了现成的序列化器。（有人说：懒惰是程序员最大的美德，我喜欢，所以我就传传JavaBean）

一、服务器端
  1、CLASS类两个Order.class,OrderTest.class，位于%TOMCAT_HOME%\webapps\axis\WEB-INF\classes下
     这两个类都直接给出源码，不再说明
     Order.java
     public class Order {
        private String id;
        private String name;
        public void setId(String id){
           this.id=id;
        }
        public String getId(){
           return id;
        }
        public void setName(String name){
            this.name=name;
        }
        public String getName(){
            return name;
        }
      }

    OrderTest.java
    public class OrderTest {
      public Order returnOrder(Order order){
        Order newOrder=new Order();
        if(order.getId().equals("1"))
           newOrder.setName("ronghao");
        else newOrder.setName("haorong");
        return newOrder;
      }
    }

  2、修改服务器端配置文件server-config.wsdd
   在server-config.wsdd中相应位置添加以下代码



             xmlns:ns1="urn:BeanService"/>

  可以看到和前面的发布服务代码相比仅多了一行代码
             xmlns:ns1="urn:BeanService"/>
   languageSpecificType属性指定JavaBean类文件位置,例如：
   languageSpecificType="java:com.ronghao.axis.Order"
   qname属性指定JavaBean类的名字
   其他是固定的。

二、客户端
   客户端类文件一个OrderClient.class，代码如下（变化的部分加注释）：
   public class OrderClient
{

    public static void main(String args[])
        throws Exception
    {
        String endpoint = "http://localhost:8080/axis/services/Order";  //服务所在位置
        Order order=new Order();   //JavaBean
        order.setId("1");
        Service service = new Service();
        Call call = (Call)service.createCall();
        //注册JavaBean，注意和server-config.wsdd中的配置代码比较
        QName qn = new QName("urn:BeanService", "Order");
        call.registerTypeMapping(Order.class, qn, new BeanSerializerFactory(Order.class, qn),
                                new BeanDeserializerFactory(Order.class, qn));
        String name="no!";
        try
        {
            call.setTargetEndpointAddress(new URL(endpoint));
            //调用的服务器端方法
            call.setOperationName(new QName("Order", "returnOrder"));
            //设定传入的参数，这里qn即Order.class
            call.addParameter("arg1", qn, ParameterMode.IN);
            //设定返回的参数是Order.class
            call.setReturnType(qn, Order.class);
            Order result = (Order)call.invoke(new Object[] {
                order
            });
            if(result != null)
                name = result.getName();
        }
        catch(Exception e)
        {
            System.err.println(e);
        }
        System.out.println(name);
    }
}
  OK！运行一下，就可以看到返回了"ronghao"。

  和上一篇文章一样，我们不容许在网络中传递XML是明文，于是需要加密和验证。这里我们继续采用上次所讲的框架。（已打包成ws-axis.jar)

一、修改服务器端配置文件server-config.wsdd（和上一文章一模一样！不再罗嗦）
  在server-config.wsdd中相应位置添加以下代码

























二、客户端（区别就在这里，注意！！）
  首先在这里要说一下，客户端代码编写困扰了我很长一段时间（整整一天），因为它并不象我想象的那么简单，当然解决起来还是挺简单的：）问题的解决经历了三个阶段

  第一阶段：
   在这个阶段我想当然的在OrderClient.class中加入了如下代码：
            WSClientHandler handler=new WSClientRequestHandler();//注意新加的HANDLER
            handler.setInitialization("f:/client.keystore","changeit","Client","changeit",
                "f:/client.truststore","changeit","serverkey");//初始化
            WSClientHandler handlee=new WSClientResponseHandler();//注意新加的HANDLER
            handlee.setInitialization("f:/client.keystore","changeit","Client","changeit",
                "f:/client.truststore","changeit","serverkey");//初始化
            call.setClientHandlers(handler,handlee);//添加Handler
   这个方法也是我在上一文章里介绍的，结果抛出以下异常：
   faultString: org.xml.sax.SAXException: Deserializing parameter
    'newProfileReturn':  could not find deserializer for type
   {urn:BeanService Order}SerializableProfile
   也就是说不能正常解析XML文件，于是理所当然的郁闷了，觉得代码中肯定漏设了CALL的一个属性，于是查看AXIS的源代码，没有结果！转机出现在下面一行代码，在不断的抛出异常中我修改了代码
   将call.setClientHandlers(handler,handlee);改为
     call.setClientHandlers(null,null);
   结果程序还是抛出同样的异常，于是意识到这可能是AXIS的一个BUG，为证明这一点，我将下面的Handler初始化代码删除
            WSClientHandler handler=new WSClientRequestHandler();//注意新加的HANDLER
            handler.setInitialization("f:/client.keystore","changeit","Client","changeit",
                "f:/client.truststore","changeit","serverkey");//初始化
            WSClientHandler handlee=new WSClientResponseHandler();//注意新加的HANDLER
            handlee.setInitialization("f:/client.keystore","changeit","Client","changeit",
                "f:/client.truststore","changeit","serverkey");//初始化
   结果还是抛出同样的异常，果然是BUG！得到这个结论后去了apache AXIS主页，在问题列表中见到了完全一样问题的提交，但没有解答（晕！）
   最后得到了结论：call的setClientHandlers()方法只有当call处理简单的数据类型，如String,int等等才能正常使用！
   （当然，如果你对这个问题有不同的见解，欢迎和我联系。或许我错了，但程序不运行是真的：））

  第二阶段：
    开始在google上找问题的解决方法，这也是我的习惯：）。找了一个类似问题的讨论，地址如下：
    http://marc.theaimsgroup.com/?l=axis-user&m=111259980822735&w=2
    他们的解决方法是Handler继承于javax.xml.rpc.handler.Handler，然后在程序里动态注册而在我的ws-axis.jar里Handler继承于org.apache.axis.handlers.BasicHandler。当然，
    javax.xml.rpc.handler.Handler是org.apache.axis.handlers.BasicHandler的老爸，但在程序里老爸和儿子之间却不能很好的兼容，这也许就是所谓的代沟？？无奈中重新写了Handler,但在运行中却抛出异常，提示message在被invoke的时候已被更改。我靠，Handler的作用就是来更改message的啊！这是什么世道！
    我知道很多程序采用的就是这种方法，但我好象怎么修改都抛出上述异常。

  第三阶段
     既然在程序里动态注册Handler行不通，于是决定写个单独的配置文件来注册Handler。如果这种方法不幸失败就返回第二阶段。好马为什么不吃回头草？？
  1、ws-axis.jar中修改WSClientHandler.class,修改后如下，我想你一看就明白为何修改

public  class WSClientHandler extends BasicHandler{
  protected String keyStoreFile ;
  protected  String keyStoreType ="JKS";
  protected String keyStorePassword ;
  protected String keyAlias ;
  protected String keyEntryPassword ;
  protected String trustStoreFile ;
  protected String trustStoreType = "JKS";
  protected String trustStorePassword ;
  protected String certAlias ;

  public void init() {
    keyStoreFile = (String)getOption("keyStoreFile");
    if(( keyStoreFile== null) )
      System.err.println("Please keyStoreFile configured for the Handler!");
    trustStoreFile = (String)getOption("trustStoreFile");
     if((  trustStoreFile== null) )
    System.err.println("Please trustStoreFile configured for the Handler!");
    keyStorePassword = (String)getOption("keyStorePassword");
     if(( keyStorePassword== null) )
    System.err.println("Please keyStorePassword configured for the Handler!");
    keyAlias = (String)getOption("keyAlias");
     if(( keyAlias== null) )
    System.err.println("Please keyAlias configured for the Handler!");
    keyEntryPassword = (String)getOption("keyEntryPassword");
     if(( keyEntryPassword== null) )
    System.err.println("Please keyEntryPassword configured for the Handler!");
    trustStorePassword = (String)getOption("trustStorePassword");
     if(( trustStorePassword== null) )
    System.err.println("Please trustStorePassword configured for the Handler!");
    certAlias = (String)getOption("certAlias");
    if ((certAlias==null))
        System.err.println("Please certAlias configured for the Handler!");
    if ((getOption("keyStoreType")) != null)
       keyStoreType = (String)getOption("keyStoreType");
    if ((getOption("trustStoreType")) != null)
       trustStoreType = (String)getOption("trustStoreType");
    }
  public void invoke(MessageContext messageContext) throws AxisFault {
    //do nothing now!
  }
  public void onFault(MessageContext msgContext) {
    System.out.println("处理错误，这里忽略！");
        }
}

  2、写客户端的配置代码client-config.wsdd,如下：

         xmlns="http://xml.apache.org/axis/wsdd/"
      xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
          pivot="java:org.apache.axis.transport.http.HTTPSender"/>
          pivot="java:org.apache.axis.transport.local.LocalSender"/>
          pivot="java:org.apache.axis.transport.java.JavaSender"/>
























同样不再解释，不明白可以参考我的上一篇文章

  3、修改OrderClient.class
   在OrderClient.class中加入了如下代码：
    EngineConfiguration conf =
           new FileProvider("F:\\Tomcat\\webapps\\axis\\WEB-INF\\client-config.wsdd");//位置
     Service service = new Service(conf);
   当然记得导入
   import org.apache.axis.EngineConfiguration;
   import org.apache.axis.configuration.FileProvider;

运行一下，返回"ronghao"，靠，搞定！
注意：这次我把OrderClient.class的调用放到了一个JSP文件中而不是jbuilder中，因为有client-config.wsdd，所以你必须有完整的WEB程序发布到TOMCAT中，否则会报找不到
相应文件。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=471571

SIMONE 2006-11-02 13:39 发表评论

如何在Eclipse中自动生成WebService代理类

SIMONE — Fri, 04 Aug 2006 12:43:00 GMT

刚接触Java就要做WebService,由于第一次使用Eclipse,对这个环境比较陌生,找不到生成代理类的文章,于是将自己的心得写出来.

其实用Eclipse生成WebService代理比较简单,由于我的WebService是用.net写出来的,而在Java中要用到.所以少了一个方便的工具.在Eclipse中,新建一个项目,在项目中再新建一个扩展名为.wsdl的文件,文件名任意.右键选择*.wsdl这个文件,会有一项"WebService",然后选择"Test with WebService Expolor",会在Eclipse中打一个浏览器,在浏览器中选择"WSDL Main",并右边输入WebService的地址,注意,一定要包含(?wsdl),比如http://192.168.0.136:8080/Winstar.Console/CommonService/group.asmx?wsdl这样才是正确的地址,输入完后单击"GO".这时浏览器的左边会出现刚刚输入的WebService地址,选中这个地址,在浏览器的右边会出现"Launch Web Service Wizard"这个选项,选择后会出现"Select a wizard to launch:",再选择"Web Service Client"并单击"GO",就会弹出一个新的窗口,在Configuration中选择"Client project:WebService project",在新弹出的窗口中的Client project这个下拉列表中选择一个已经存在的工程,确定即可.其它的都不用设置,直接点击完成.就会在选择的工程的src下生成一个名为org.tempuri的包,里面包含了Eclipse生成的代理类.如果WebService的类型为int ,boolean ,string这样的简单类型的话,WebService可以说是通用,但如果包含了复杂类型的话就麻烦一点了,我做的就是将.net的WebService调到java里面用,而WebService返回的又是XmlNode这样类型的数据,因为java里面没在XmlNode,但好在有这个包axis-bin-1_4,里面有个org.apache.axis.message.MessageElement[]类型.

SIMONE 2006-08-04 20:43 发表评论

使用myeclipse开发webservice网址

SIMONE — Fri, 04 Aug 2006 12:30:00 GMT

http://www.myeclipseide.com/ContentExpress-display-ceid-49.html

SIMONE 2006-08-04 20:30 发表评论

使用Axis部署Web服务时的常见问题及其解决方法(转)

SIMONE — Fri, 04 Aug 2006 12:09:00 GMT

刘红涛 (redwaveht@hotmail.com)

2003 年 11 月

本文详细介绍了在Linux环境下以Apache Axis+ Resin作为Web服务平台部署Web服务时的常见问题及解决方法。衷心希望本文对Web服务的开发人员或对Web服务感兴趣的读者能起到一定的帮助作用。

1 引言
随着Web服务技术的发展和成熟，其方便性和易用性已逐渐被人们所接受，越来越多的合作伙伴之间开始利用Web服务来实现合作方之间的数据接口。使用Apache Axis和Linux平台是一种低成本的Web服务解决方案，但Apache Axis文档的FAQ对开发者来说内容还不够丰富，本文作者将自己使用Axis时遇到的问题和解决方法整理成文，奉献给Web服务的开发人员和对此感兴趣的读者朋友，旨在帮助大家节约一些宝贵的时间。有关Web服务的基础知识，读者可以阅读参考文献中推荐的文档。作者未在文中介绍Apache和Resin的安装方法，读者可以参考相关网站的说明文档。

作者使用的软件环境如下。

操作系统：Red Hat Linux 7.2

Web服务器: Apache 1.3.27

应用服务器：Resin 2.1.8 ( http://www.caucho.com/ )

SOAP服务器：Apache Axis 1.1

XML解析器：Xerces 2.5.0，Xalan 2.5.1

JDK版本：JDK 1.4.1

2 使用Axis时的常见问题及其解决方法

2.1 Axis运行需要哪些jar文件

对Axis解包后，将axis-1_1/webapps/axis/WEB-INF/lib/目录下的jar文件复制到/usr/local/apache/htdocs/WEB-INF/lib目录下(Web应用程序的目录)。应包括以下jar文件。

														
axis-ant.jar
axis.jar
commons-discovery.jar
commons-logging.jar
jaxrpc.jar
log4j-1.2.8.jar
name.txt
saaj.jar
wsdl4j.jar

如果需要使用axis提供的测试页面，还要将axis-1_1/webapps/axis/目录下的文件复制到/usr/local/apache/htdocs/axis/目录下。应包括以下文件。

														
EchoHeaders.jws
fingerprint.jsp
happyaxis.jsp
index.html

2.2 应该使用哪一种XML解析器

XML解析器选用不当，经常会导致使用Apache Axis时出现一些莫名其妙的问题。

由于Apache Axis 并未对Resin内置的xml解析器进行过测试，因此推荐读者使用已通过测试的Xerces xml解析器。可以从 http://xml.apache.org/xalan-j/index.html 处下载Xalan的Java版XSLT处理器，其中包含了Xerces的Java版XML解析器，不需要再单独下载xml解析器。

Xalan 2.5.1解包后，将bin/目录下的xercesImpl.jar、xml-apis.jar和xalan.jar复制到resin安装目录的lib/目录下，例如/usr/local/resin/lib。

编辑/etc/目录下的profile文件，找到设置CLASSPATH环境变量的位置，在其后加入下面的内容(B shell)。

														
XMLPARSER=$RESIN_HOME/lib/xalan.jar:$RESIN_HOME/lib/xercesImpl.jar:$RESIN_HOME/lib/xml-apis.jar
export CLASSPATH=$XMLPARSER:$CLASSPATH

2.2.1 注意事项
如果CLASSPATH中包含其它的XML解析器设置，应将其从CLASSPATH环境变量的设置中去掉，以免发生冲突。

2.3 如何在Resin中使用Xerces的XML解析器

通过修改resin.conf将resin的XmlParser置换为Xerces的XmlParser。在resin.conf对应的Web应用程序配置中加入以下设置。

														
            "org.apache.xalan.processor.TransformerFactoryImpl"/>
            "org.apache.xerces.jaxp.DocumentBuilderFactoryImpl"/>
            "org.apache.xerces.jaxp.SAXParserFactoryImpl"/>

配置完成后重新启动Resin。

2.4 如何排除XML解析器出现的异常

2.4.1 问题描述

使用http://test.com/axis查看已部署的服务时出现Axis内部错，显示有关WSDD配置的异常信息。如果把WEB-INF目录下的server-config.wsdd删除，再查看就正常了，但只能看到AdminService和Version两个系统缺省的服务，后来部署的服务都看不到了。

2.4.2 原因分析

Axis会在WEB应用程序的WEB-INF/目录下自动生成一个名字为server-config.wsdd的xml文件，其中记录了已部署的WEB服务。每部署一个新的WEB服务时，Axis都会将新服务的描述信息加入到server-config.wsdd中。

故障站点使用的XmlParser是resin内置的XmlParser，Axis并未对其对进行过兼容性测试，查看WEB服务信息时需要从server-config.wsdd(这是一个xml文件)取得已部署的WEB服务描述信息，当server-config.wsdd的内容较复杂时，resin内置的XmlParser因某种原因出现异常，导致Axis内部错误。Server-config.wsdd中记录的Web服务描述信息较少时不会出现异常。

2.4.3 解决方法

修改resin.conf，将resin的XmlParser置换为Xerces的XmlParser。置换方法参见2.3节。

2.4.4 小结

如果Axis报告的错误中有关于xml解析器的错误，建议读者参照本小节描述的方法更换应用服务器的xml解析器，将会有助于问题的解决。

2.5 如何将Axis集成到Resin或其它应用服务器

Axis是以Servlet的方式运行的，而Resin的作用相当于Servlets容器(Container)，因此只要配置得当，就可以使Axis在Resin环境中运行，这一点也适用于Resin以外的其它应用服务器。在Resin中配置Axis的方法如下。

将axis-1_1/webapps/axis/WEB-INF/web.xml中的Servlet配置项复制到resin.conf中对应的Web应用程序配置中。通常应包括以下内容。

														
	
		
		  AxisServlet
		  Apache-Axis Servlet
		  
		      org.apache.axis.transport.http.AxisServlet
		  
		

		
		  AdminServlet
		  Axis Admin Servlet
		  
		      org.apache.axis.transport.http.AdminServlet
		  
		  100
		

		
		  SOAPMonitorService
		  SOAPMonitorService
		  
		      org.apache.axis.monitor.SOAPMonitorService
		  
		  
		    SOAPMonitorPort
		    5001
		  
		  100
		

		
		  AxisServlet
		  /axis/servlet/AxisServlet
		

		
		  AxisServlet
		  *.jws
		

		
		  AxisServlet
		  /services/*
		

		
		  SOAPMonitorService
		  /SOAPMonitor
		

		
		
		
		
		  wsdl
		   text/xml
		

		
		  xsd
		  text/xml

2.6 Axis提供了哪些开发工具

Apache Axis提供了WSDL2Java和Java2WSDL两个开发工具。

WSDL2Java利用已知的WSDL文件生成服务端和客户端代码。该WSDL文件可以是由合作伙伴提供的，也可以是利用Java2WSDL生成的。Java2WSDL根据已有的Java类文件生成WSDL文件，Java类文件可以是接口类文件，并不需要实现细节。

此外Axis还提供了SoapMonitorApplet和TCPMon工具，可用于监测Web服务。

2.7 如何生成Web服务的服务端和客户端代码

2.7.1 生成或取得WSDL文件

Java2WSDL是Axis提供的利用Java类文件得到WSDL文件的工具。类文件可以使用接口文件编译生成，例如下面的接口文件SoftwarePrice.java。

														
package samples.userguide.example6;
/**
 * Interface describing a web service to set and get software prices.
 **/
public interface SoftwarePrice {
    public void setWidgetPrice(String softWareName, String price);
    public String getWidgetPrice(String softWareName);

编译SoftwarePrice.java。

														
javac SoftwarePrice.java

将SoftwarePrice.class复制到正确的package路径下。

执行下面的命令:

														
java org.apache.axis.wsdl.Java2WSDL -o sp.wsdl 
      -l"http://test.com:80/services/SoftwarePrice" 
      -n "urn:SoftwarePrice" -p"samples.userguide.example6" "urn:Example6" 
         samples.userguide.example6.SoftwarePrice

各参数的含义如下。

														
-o：指定输出的WSDL文件的文件名。

-l：指定服务的位置。

-n：WSDL文件的目标名字空间。

-p：指定从package到名字空间的映射，这里可以有多个映射。

最后面的类文件包含了Web服务的接口。

该命令执行后，将生成sp.wsdl文件。

如果按CLASSPATH的设置找不到指定的类文件，Axis将报告异常，如下所示。

														
java.lang.ClassNotFoundException: samples.userguide.example6.SoftwarePrice
        at java.net.URLClassLoader$1.run(URLClassLoader.java:198)
        at java.security.AccessController.doPrivileged(Native Method)
		……

如果出现上面的问题，请检查是否已将有关类文件复制到正确的位置或CLASSPATH设置是否正确。

生成WSDL文件以后，就可以利用Axis提供的WSDL2Java工具生成Web服务的服务端代码和客户端代码了。

2.7.1.1 注意事项

WSDL文件也可以由合作伙伴提供。这种情况下合作伙伴往往是Web服务的提供者或标准接口的制定者，开发者只要按照既定的WSDL文件生成客户端或服务端代码就可以了。

2.7.2 生成客户端或服务端代码

WSDL2Java工具用于从WSDL文件生成客户端存根（stub）代码，服务端框架（skeleton）代码以及WSDL中的数据类型文件(生成与之对应的Java代码)。开发人员只需向框架代码中补充相关的业务逻辑代码即可得到完整的Web服务代码，因此该工具极大地减轻了开发人员的编码负担。WSDL2Java的使用举例如下。

														
java org.apache.axis.wsdl.WSDL2Java --server-side --skeletonDeploy true MyService.wsdl

执行上述命令后将生成下列文件。

No.	文件	用途
1.	deploy.wsdd	MyService服务的部署描述文件
2.	MyService.java	MyService服务的接口文件
3.	MyServiceService.java	获得MyService服务的接口文件
4.	MyServiceServiceLocator.java	实现MyServiceService接口
5.	MyServiceSoapBindingImpl.java	实现MyService接口，应向其中补充业务逻辑
6.	MyServiceSoapBindingSkeleton.java	MyService服务的服务端框架代码,实现MyService, org.apache.axis.wsdl.Skeleton接口
7.	MyServiceSoapBindingStub.java	MyService服务的客户端存根代码,实现MyService接口
8.	undeploy.wsdd	注销MyService服务的部署描述文件

2.7.3 编写Web服务客户端代码

Web服务的客户端程序完成对Web服务的调用，其程序结构如下。

														
import com.chinavnet.zx.service.v1_0.*;// WSDL2Java生成的package的名字空间;
public class TestClient {
    public static void main (String[] args) throws Exception
    {
	com.chinavnet.zx.service.v1_0.SPInterfaceForVNetLocator locator = 
                                     new  SPInterfaceForVNetLocator();//获得一个locator对象
	locator.setMaintainSession(true);
	com.chinavnet.zx.service.v1_0.SPInterfaceForVNetSoap service = 
                                     locator.getSPInterfaceForVNetSoap();//获得服务对象
	com.chinavnet.zx.service.v1_0.DetailLedgerFeedbackResult feedbackRes = null;
	//初始化Web服务中定义的数据类型
         try {
	   feedbackRes =  service.generalLedgerFeedback();//调用Web服务的方法并取得返回值
	   System.out.println("FeedbackResult :");
	   if(feedbackRes != null)
	   {
	        System.out.println("SPID: " +feedbackRes.getSPID());
	        System.out.println("errorDesc: " +feedbackRes.getErrorDescription());
	        System.out.println("result: " +feedbackRes.getResult());
	   }else
	   {
	   System.out.println("feedbackRes is null!");
	}
        } catch (java.rmi.RemoteException re) {
        //throw new junit.framework.AssertionFailedError("Remote Exception caught: "+re );
 	re.printStackTrace();
     }
}//End of main()
}//End of TestClient class

测试客户端程序是非常简单的，将客户端程序编译后，执行"java TestClient"即可。

2.8 如何编写服务端代码

向MyServiceSoapBindingImpl.java添加相关的业务逻辑代码后，将WSDL2Java生成的源程序编译，打包成jar文件，复制到/usr/local/apache/htdocs/WEB-INF/lib/目录下。

2.9 如何发布Web服务

有了deploy.wsdd文件并准备好类文件后，就可以发布MyService服务了。Axis在安装后自动发布了AdminService，利用它可以发布新的Web服务。方法如下。

														
java org.apache.axis.client.AdminClient 
                                 -lhttp://localhost:80/services/AdminService deploy.wsdd
上面的命令执行后，有如下提示。
Processing file deploy.wsdd
Done processing

2.10 执行WSDL2Java时报告" 类型被引用但未定义"

2.10.1 问题描述

执行WSDL2Java时报告下面的异常：

														
java.io.IOException: Type {http://schemas.xmlsoap.org/wsdl/} 
                                    ArrayOfFailedRecord is referenced but not defined.

2.10.2 原因分析

出现上述情况可能的原因有：

类型未定义就被引用。

使用了错误的名字空间。

WSDL文件中存在输入错误。

2.10.3 解决方法

经过仔细检查发现wsdl文件中的

														
                                                         type="s0:ArrayOfFailedRecord" />

的type=" s0:ArrayOfFailedRecord"中的s0:前面有一个空格，将空格删除后问题解决了。

2.10.4 小结

WSDL文件中出现的编辑错误有可能导致执行WSDL2Java时出现"类型被引用但未定义"错误。

2.11 server-config.wsdd的作用是什么

server-config.wsdd记录了axis已发布的Web服务的描述信息。

2.12 发布Web服务时报告"Exception:: (404)Not Found"

2.12.1 问题描述

														
执行java org.apache.axis.client.AdminClient 
        -lhttp://localhost:80/services/AdminService deploy.wsdd命令发布WEB服务时报告如下内容。
Processing file deploy.wsdd
Exception:: (404)Not Found

Apache的access_log显示如下。

														
127.0.0.1 - - [17/Sep/2003:15:56:33 +0800] "POST /services/AdminService HTTP/1.0" 404 293

2.12.2 原因分析

出现这个问题的比较简单的原因可能是端口不对，或URL路径不对(例如路径中多写了目录)，Axis的SoapMonitor服务按指定的端口或URL找不到AdminService，需要检查正确的端口号和URL路径。

比较深层次的原因就复杂得多了。

本文作者遇到的是下面的情况。

AdminService是一个已发布的WEB服务。

AdminClient使用soap协议同AdminService通信，需要按指定的端口和URL定位AdminService，而原来使用的resin.conf中，有两个web-app配置项，配置A的摘要如下所示。

														

      /usr/local/apache/htdocs/

配置B的摘要如下所示。

														

      /usr/local/apache/htdocs/esales/

Axis的有关配置在配置B中。

Httpd.conf中的DocumentRoot是/usr/local/apache/htdocs/。

使用java org.apache.axis.client.AdminClient -lhttp://localhost:80/services/AdminService deploy.wsdd发布WEB服务时，需要按http协议解析url: //localhost:80/services/AdminService。由于htdocs/目录下并没有services/目录(services是Axis在resin.conf中的servlet-mapping)，因此应用服务器按resin.conf中的配置去定位AdminService ，因为url的主机名为localhost，因此resin不会到(配置B)中去定位url，而是到配置A中去定位，在配置A中并没有Axis的配置，找不到与AdminService相关的url，因此报告了前面描述的异常情况。

2.12.3 解决方法

知道了原因后，按如下方法就可以解决了。

将配置B中全部关于Axis的配置移到配置A中，注意相应地要改变/etc/profile中的CLASSPATH变量的值。

保存resin.conf后，重新登录服务器(使新的CLASSPATH生效)，重新启动resin。再次发布WEB服务。

														
java org.apache.axis.client.AdminClient 
                           -lhttp://localhost:80/services/AdminService deploy.wsdd

屏幕显示如下。

														
Processing file deploy.wsdd
Done processing

WEB服务终于发布成功了。

在发布成功的情况下apache的access_log中会看到如下的log：

														
tail -f access_log|grep vice  
127.0.0.1 - - [17/Sep/2003:16:05:00 +0800] 
                             "POST /services/AdminService HTTP/1.0" 200 296 "-" "Axis/1.1"

2.12.4 小结

本小节描述的问题可能是读者遇到的出现最多的异常，但原因并不是唯一的。遇到该问题时，建议读者冷静分析出现问题的可能原因，多实验几种解决方法，最终一定可以成功！

2.13 如何监测SOAP请求和响应流

2.13.1 引言

发布了Web服务以后，如何观察请求和响应数据呢？记录运行日志是一种传统且有效的方法，但对于调试程序来讲还不够方便和直观。值得欣慰的是，Axis为我们提供了在客户端观察SOAP请求和响应流数据的工具SoapMonitor，经过适当配置后，可以实时地观察到Web服务的SOAP请求和响应数据。SoapMonitor是一个Java Applet程序，通过浏览器下载到客户端运行。下面就介绍SoapMonitor的配置和使用方法。

2.13.2 准备SOAPMonitor 小应用程序

在Axis 1.1中，没有为我们编译SOAPMonitor.java程序，但我们可以在axis-1_1/webapps/axis/目录下找到名字为SOAPMonitorApplet.java的源程序文件，自己进行编译。该程序编译后，会生成如下的类文件：

														
SOAPMonitorApplet.class
SOAPMonitorApplet$ServiceFilterPanel.class
SOAPMonitorApplet$SOAPMonitorData.class
SOAPMonitorApplet$SOAPMonitorFilter.class
SOAPMonitorApplet$SOAPMonitorPage.class
SOAPMonitorApplet$SOAPMonitorTableModel.class
SOAPMonitorApplet$SOAPMonitorTextArea.class

读者需要把上述类文件复制到自己的Web应用程序目录下，本例中是/usr/local/apache/htdocs/目录。

在浏览器地址样中输入SOAPMonitor的地址，例如 http://test.com/SOAPMonitor ，浏览器会提示用户正在下载Applet程序，下载完毕后，读者可以在浏览器窗口中看到如图4-1所示的用户界面。如果上述类文件的位置不正确，浏览器会报告"找不到类"的错误。此时应检查是否已将上述类文件复制到正确的目录下。

图 2-1 SOAPMonitor的界面

2.13.3 发布SOAPMonitor服务

图2-1所示的SOAPMonitor界面出现后，并不意味着就可以观察到Web服务的SOAP请求流与响应流了，首先需要发布SOAPMonitorService。该Web服务是由Axis提供的，但需要由用户自己进行发布，方法如下。

获得SOAPMonitor服务的WSDD文件deploy.wsdd，内容如下(也可到 http://www.sosnoski.com/presents/java-xml/axis/axis-monitor.html 复制该文件)：

发布SOAPMonitor服务：

														
java org.apache.axis.client.AdminClient 
                                   -lhttp://localhost:80/services/AdminService deploy.wsdd

2.13.4 修改deploy.wsdd

发布SOAPMonitor服务后，还要对被监测的Web服务进行配置。方法是先注销该Web服务，然后修改该服务对应的WSDD文件，在其中增加请求流和响应流的配置，否则是观测不到SOAP请求和响应流的。

注销Web服务的方法如下。

进入该Web服务的undeploy.wsdd文件所在的目录，执行

														
Java org.apache.axis.client.AdminClient 
                              -lhttp://localhost:80/services/AdminService undeploy.wsdd

修改WSDD文件的方法如下。

以Axis提供的MyService为例，对MyService的WSDD文件做如下修改。

修改前:

修改后: (有下划线的行是新加入的内容)

修改WSDD文件后，重新发布MyService服务：

														
java org.apache.axis.client.AdminClient 
                                 -lhttp://localhost:80/services/AdminService deploy.wsdd

2.13.5 启动SOAPMonitor小应用程序

按2.13.2节介绍的方法启动SOAPMonitor小应用程序。

使用客户端程序测试MyService服务：

														
#  java samples.userguide.example3.Client 
                                       -lhttp://vnet.sohu.com/services/MyService "test"
结果为：You typed : test

注意，一定要先启动SOAPMonitor小应用程序，后调用Web服务才能观察到SOAP请求和响应流。

2.13.6 观察SOAP请求和响应流

这时在SoapMonitorApplet的窗口中可以观察到SOAP和请求和响应消息，如图2-2所示。

图2-2 MyService的Soap请求和响应流

2.14 使用客户端程序测试Web服务时报告"Exception:: (404)Not Found"

2.14.1 问题描述

WEB服务接口编写完成并发布后，客户端测试程序收不到WEB服务的返回结果，Apache或Resin的log中也看不到访问记录。但测试程序返回结果为0(成功)，在没有部署该WEB服务的情况下，也是这个结果，因此怀疑调用的是WSDL文件的提供者自己测试用的WEB服务接口，可能与另一方提供的WSDL文件有关。

2.14.2 原因分析

合作伙伴调用WEB服务就能够成功，从WEB服务主机自己的客户端调用就接收不到数据，估计与合作伙伴提供的WSDL文件有关，该WSDL文件影响了WSDL2Java生成的客户端stub代码。检查stub代码，发现其soapAction都指向了合作伙伴的测试地址。

2.14.3 解决方法

修改stub代码中的soapAction，改为sp(Service Provider)自己的WEB服务URL。重新编译程序并发布Web服务，问题解决。

_call.setSOAPActionURI("sp自己的Web服务地址");

2.14.4 小结

本小节描述的问题出现于Web服务提供方按合作伙伴统一提供的WSDL文件生成客户端代码的情况。遇到这类问题，读者可直接检查WSDL2Java自动生成的代码的有关部分。

在WSDL文件中可以看到与下列内容相似的设置。

其中即为已发布的WEB服务的URL，供客户端调用。

2.15 如何列出已发布的Web服务

使用下面的命令：

														
java org.apache.axis.client.AdminClient -lhttp://localhost:80/services/  list

实际上该命令的输出就是server-config.wsdd文件的内容。

2.16 发布Web服务时报告"调用目标异常"

2.16.1 问题描述

在部署WEB服务时报告：java.lang.reflect.InvocationTargetException异常。

2.16.2 原因分析

在WSDL文件中自定义的名字空间与Axis的services名字空间冲突。

2.16.3 解决方法

修改WSDL文件，将services改为别的名字。

2.17 WSDL文件中的targetNamespace的作用是什么

TargetNamespace指明目标名字空间，用于验证xml文档。

在WSDL文件中，中的targetNamespace与中的targetNamespace应保持一致。

2.18 Web服务部署成功但检测不到

2.19 客户端程序找不到可用的Web服务

2.19.1 问题描述

														
执行 
java org.apache.axis.client.AdminClient 
                                 -lhttp://localhost:80/services/AdminService deploy.wsdd

时显示Done processing，却检查不到新的服务，在WEB-INF/目录下的server-config.wsdd文件中也看不到相应的配置项。

2.19.2 原因分析

新的WEB服务的类文件没有重新编译并复制到正确的位置。

2.19.3 解决方法

WEB服务的类文件可以打包为jar文件。在CLASSPATH环境变量中正确设置jar文件的路径。例如：

														
jar cvf  SPInterfaceSoap.jar com/zx/service/v1_0/*.class

将SPInterfaceSoap.jar复制到WEB-INF/lib/目录下，重新发布WEB服务。

2.20 如何排除原因不明的错误

有时，在对WEB服务执行客户端测试时会出现慕名其妙的错误。为保证环境是正确的，可以按下面的步骤排除原因不明的错误。

1. Undeploy被测试的服务

														
java org.apache.axis.client.AdminClient 
                                 -lhttp://localhost:80/services/AdminService undeploy.wsdd

2. 重新启动resin: /usr/local/resin/bin/httpd.sh restart(如果是其它的应用服务器，请按相应的方法重新启动)

3. 重新发布WEB服务

4. 进行测试

3 小结
目前有很多可以使用的应用服务器和Web服务平台软件，本文仅以Apache Axis和Resin为例介绍了在部署Web服务的过程中可能遇到的问题及其解决方法，其中并未讨论Web服务的安全性问题。对于如何高效地开发和部署Web服务以及如何确保Web服务的安全性，还希望对此感兴趣的读者共同参与讨论，对于文中存在的错误和不足之处也希望读者朋友们能够不吝批评指正。

SIMONE 2006-08-04 20:09 发表评论

实现安全的AXIS Web服务，第2部分(转)

SIMONE — Fri, 04 Aug 2006 12:08:00 GMT

高级软件工程师
2004 年 8 月

本文将首先简单介绍Web 服务安全性相关技术和开发工具，然后介绍了使用WSSecurity工具SOAP消息进行签名和验证的方法；接下来深入讨论了使用现成的WS-Security工具，结合Handler模型开发一个axis下实现WS-Security的通用应用框架。

本文是J2EE Web服务开发系列文章的第十三篇，本文将首先简单介绍Web 服务安全性相关技术和开发工具，然后介绍了使用WSSecurity工具SOAP消息进行签名和验证的方法；接下来深入讨论了使用现成的WS-Security工具，结合Handler模型开发一个axis下实现WS-Security的通用应用框架。

阅读本文前您需要以下的知识和工具：

Apache axis1.1，并且会初步使用；
Tomcat 5.0.16以上, 并且会初步使用；
SOAP消息（SOAP Message）编程知识；
Java安全编程基础知识；
JAX-RPC编程基础知识；
Servlet的开发经验；
Sun提供的JAX-RPC参考实现（jaxrpc-impl.jar，在J2EESDK1.4或者JWSDP1.4中可找到）；
一个JSSE安全提供者（如ISNetworks）；
Trust Services Integration Kit，可在http://www.xmltrustcenter.org上获得。

本文的参考资料见参考资料。

本文的全部代码在这里下载。

Web 服务安全性相关技术和开发工具
Web 服务安全性规范是一套可以帮助 Web 服务开发者保证 SOAP 消息交换的安全的机制。WS-Security 特别描述了对现有的 SOAP 消息传递的增强，从而通过对 SOAP 消息应用消息完整性、消息机密性和单消息认证提供了保护级别。这些基本机制可以通过各种方式联合，以适应构建使用多种加密技术的多种安全性模型。

围绕Web服务的安全，有很多相关的技术，比如WS-Security，WS-Trace等，另外，还有以下相关技术：

XML Digital Signature（XML数字签名）
XML Encryption （XML加密）
XKMS (XML Key Management Specification)
XACML (eXtensible Access Control Markup Language)
SAML (Secure Assertion Markup Language)
ebXML Message Service Security
Identity Management & Liberty Project

由于本文是一个实例性文章，故不对WS-Security做详细的探讨，你可以在develperWorks Web 服务安全专题找到许多相关资料（见参考资料）。

Trust Services Integration Kit提供了一个WS-Security实现。你可以从http://www.xmltrustcenter.org获得相关库文件，分别是wssecurity.jar和tsik.jar。wssecurity.jar中包含一个WSSecurity类，可以使用它来对XML进行数字签名和验证，加密与解密。

下面我们使用WS-Security来对SOAP消息进行数字签名，然后再进行验证。

SOAP消息的签名和验证

使用WSSecurity对SOAP消息数字签名
在对SOAP消息进行签名前，首先生成一个keystore。keystore包含了进行数字签名所需要的身份信息。通过以下批处理脚本来创建keystore：

例程1 创建keystore（server.keystore）


set SERVER_DN="CN=hellking-Server, OU=huayuan, O=huayuan, L=BEIJINGC, S=BEIJING, C=CN"
set KS_PASS=-storepass changeit
set KS_TYPE=-storetype JKS
set KEYINFO=-keyalg RSA
#生成服务器端keystore。
keytool -genkey -dname %SERVER_DN% %KS_PASS% %KS_TYPE% -keystore 
server.keystore %KEYINFO% -keypass changeit

SignAndVerifySoap类中包含了一个对XML进行签名的方法，它就是sign（），这个方法将对SOAP消息进行签名，然后输出和WS-Security兼容的SOAP消息。下面我们看具体代码。

例程2 对SOAP消息签名


	package com.hellking.study.webservice;
import com.verisign.messaging.WSSecurity;
...
public class SignAndVerifySoap {
	
	final String KEY_STORE = "server.keystore";
    final String SOTE_PASS = "changeit";
    final String KEY_ALIAS="mykey";
    final String TARGET_FILE="signed.xml";//签名后的SOAP消息
    final String SOURE_FILE="source.xml";//签名前的SOAP消息
    final String KEY_TYPE="JKS";
	
	/**
	 *对xml进行签名
	 */
	public void sign()
	{	

		try
		{
			System.out.println("开始对SOAP消息进行签名，使用的密匙库：" + KEY_STORE + "\n");
		
		// 获得私有key和相关证书，请参考JAVA安全编程相关书籍
		FileInputStream fileInputStream = new FileInputStream(KEY_STORE);
		System.out.println(java.security.KeyStore.getDefaultType());
		java.security.KeyStore store = java.security.KeyStore.getInstance(KEY_TYPE);
		store.load(fileInputStream, SOTE_PASS.toCharArray());
		PrivateKey key = (PrivateKey)store.getKey(KEY_ALIAS, SOTE_PASS.toCharArray());
		X509Certificate certification = (X509Certificate)store.getCertificate(KEY_ALIAS);

		// 读取XML源文件到文档中
		Document source = readFile(SOURE_FILE);
		SigningKey signingKey = SigningKeyFactory.makeSigningKey(key);
		KeyInfo keyInfo = new KeyInfo();
		keyInfo.setCertificate(certification);

		WSSecurity wsSecurity = new WSSecurity();

		wsSecurity.setPreferredNamespace("http://schemas.xmlsoap.org/ws/2003/06/secext");
		//对SOAP消息进行签名
		wsSecurity.sign(source, signingKey, keyInfo);
		// 保存签名后的SOAP消息	
		writeFile(source, new FileOutputStream(TARGET_FILE));
		System.out.println("把签名后的文件写入： " + TARGET_FILE + "，请查看结果！");
	}
	catch(Exception e)
	{
		e.printStackTrace();
	}		
	}

在执行此程序前，请把wssecurity.jar、source.xml和tsik.jar设置到类路径环境变量中。签名前的SOAP为：

例程3 签名前的SOAP消息（source.xml）




 
  
   5000.0

签名后的SOAP消息如例程4所示。

例程4 签名后的SOAP消息（signed.xml）




 

MIICUjCCAbsCBEDB0GIwDQYJKoZIhvcNAQE…VkTkPw==








ZjRVnI2g7kcX0h9r4JtiltpYQPA=



moZ0d+8mH1kfNw0VEK39V0Td9EM=


fPpYrf0uNP8W2XVVIQNc3OQt2Wn90M/0uJ0dDZTNRR0NxBBBX36wSXt7NfI5Fmh4ru44Wk34EGI7mqMAE5O0
/wtIlFRJt3zAvA6k3nhgcYj6tn/9kZwwxh1RkFTfTX9xdQ6Xn+P6m+YBm1YEEcTWkJd7XcxdyDEns2kYOhONx1U=







2004-07-04T08:41:23Z


  
   5000.0

签名后的SOAP消息中，头部包含了签名信息以及验证SOAP消息所需要的key。描述了已签署的消息内容。指出了签名算法（Signature Method Algorithm）。这个算法被用来将规范算法的输出转换成签名值（Signature Value）。Key Info 元素包含的部分就是数字证书本身。

对签名的SOAP消息进行验证
对SOAP消息进行验证就是使用keystore的信息生成TrustVerifier对象，然后调用WSSecurity的verify方法进行验证。

例程5 验证签名后的SOAP消息


	/**
	 *验证已经签名的SOAP消息
	 */
	public void verify()
	{
		try
		{
			System.out.println("开始检验SOAP消息，使用的密匙库：" + KEY_STORE + "\n");
		
		// 获得私有key和相关证书，请参考JAVA安全编程相关书籍
		FileInputStream fileInputStream = new FileInputStream(KEY_STORE);

		java.security.KeyStore store = java.security.KeyStore.getInstance(KEY_TYPE);
		store.load(fileInputStream, SOTE_PASS.toCharArray());
	
		// 读取XML源文件到文档中
		Document source = readFile(TARGET_FILE);
		org.xmltrustcenter.verifier.TrustVerifier verifier =
            new org.xmltrustcenter.verifier.X509TrustVerifier(store);

		WSSecurity wsSecurity = new WSSecurity();

        com.verisign.messaging.MessageValidity[] resa =
     wsSecurity.verify(source,verifier,null,null);
       System.out.println("检验结果：");
	   for (int len = 0; len < resa.length; len++){
      System.out.println("result[" + len + "] = " + (resa[len].isValid()?"验证通过":"验证不通过"));
    }
    }

    catch(Exception e)
	{
		e.printStackTrace();
	}
}

执行SignAndVerifySoap的verify方法，可以看到类似以下的结果。

图1 对SOAP消息进行验证

在AXIS下实现WS-Security的应用框架
待开发的应用开发框架基于Handler实现，将达到以下目标：此框架基于JAX-RPC环境下实现WS-Security应用，它可以部署到任何需要实现WS-Security的axis环境下的Web服务应用中，同时具体的应用程序不做任何编码修改。

由于此基于Handler实现，我们有必要回顾一下Handler的一些基础知识。

SOAP消息Handler能够访问代表RPC请求或者响应的SOAP消息。在JAX-RPC技术中，SOAP消息Handler可以部署在服务端，也可以在客户端使用。

SOAP消息Handler非常像Servlet技术中的Filter，它们共同的特点是请求发送到目标前，Handler/Filter可以截取这些请求，并对请求做一些处理，从而达到一些辅助的功能。多个Handler可以组成一个Handler链，链上的每个Handler都完成某个特定的任务。比如有的Handler进行权限验证，有的Handler进行日志处理等。关于Handler更详细的介绍，请参考本系列文章《 J2EE Web服务开发系列之六: 使用Handler来增强Web服务的功能》。

实现原理
图2是此例子具体实现原理图。

图2 Handler结合WSSecurity实现Web服务安全的工作原理

处理流程如下：

1、客户端（WSSClient）发出调用Web服务请求；

2、客户端Handler（WSSecurityClientHandler）截获请求的SOAP消息；

3、客户端Handler对截获的SOAP消息进行数字签名（使用client.keystore作为签名依据）；

4、客户端Handler对签名后的SOAP消息进行加密（使用RSA算法加密）；

5、被加密的SOAP消息通过互联网传送到目标Web服务端口；

6、服务器端Handler（WSSecurityServerHandler）截获加密的SOAP消息；

7、服务器端Handler对加密的SOAP消息进行解密；

8、服务器端Handler对SOAP消息进行身份验证（server.truststore包含了所信任的身份信息），如果验证不通过，将抛出异常；

9、服务器端Handler删除被解密后的SOAP消息中与WS-Security相关的元素；

10、解密后的原始SOAP消息被发送到目标Web服务端口（如TaxService）；

11、目标Web服务对Web服务请求进行处理，然后返回响应的SOAP消息；

12、服务器端Handler截获响应的SOAP消息；

13、服务器端Handler对截获的SOAP消息进行数字签名（使用server.keystore作为签名依据）；

14、服务器端Handler对签名后的SOAP消息进行加密（使用RSA算法加密）；

15、被加密的SOAP消息通过互联网传送到目客户端；

16、客户端Handler截获加密的SOAP消息；

17、客户端Handler对加密的SOAP消息进行解密；

18、客户端Handler对SOAP消息进行身份验证（client.truststore包含了所信任的身份信息），如果验证不通过，将抛出异常；

19、客户端Handler删除被解密后的SOAP消息中与WS-Security相关的元素；

20、被解密后的SOAP消息发送到目标客户端，客户端输出调用结果。

从上面可以看出，在一个SOAP调用回合中，要对SOAP消息进行四次处理。基本上都是"签名'加密'解密'验证"的过程。

创建相关密匙库
客户端和服务端都有相关的密匙库，其中：

client.keystore：客户端自身的身份信息；
client.truststore：客户端所信任的身份信息，在此例中也就是包含了服务器的身份信息；
server.keystore：服务器自身的身份信息；
server.truststore：服务器所信任的身份信息（即客户端身份信息）。

你可以使用以下的批处理脚本创建上面四个密匙库。

例程6 创建相关密匙库（gen-cer-store.bat）


set SERVER_DN="CN=hellking-Server, OU=huayuan, O=huayuan, L=BEIJINGC, S=BEIJING, C=CN"
set CLIENT_DN="CN=hellking-Client, OU=tsinghua, O=tsinghua, L=BEIJING, S=BEIJING, C=CN"
set KS_PASS=-storepass changeit
set KEYINFO=-keyalg RSA
#生成server.keystore。
keytool -genkey -dname %SERVER_DN% %KS_PASS% -keystore server.keystore %KEYINFO% -keypass changeit
#从server.keystore导出数字证书。
keytool -export -file test_axis.cer %KS_PASS% -keystore server.keystore
#从服务器的数字证书导出到客户端信任的truststore中。
keytool -import -file test_axis.cer %KS_PASS% -keystore client.truststore -alias serverkey -noprompt

#生成client.keystore。
keytool -genkey -dname %CLIENT_DN% %KS_PASS% -keystore client.keystore %KEYINFO% -keypass changeit
#从client.keystore导出数字证书。
keytool -export -file test_axis.cer %KS_PASS% -keystore client.keystore
#从客户端的数字证书导出到服务器信任的truststore中。
keytool -import -file test_axis.cer %KS_PASS% -keystore server.truststore -alias clientkey -noprompt

#end

签名、加密、解密、身份验证的实现
对SOAP消息的签名、加密、解密、身份验证都放在一个名为WSSHelper的类中进行。

例程7 签名、加密、解密、身份验证功能的实现――WSSHelper.java


package com.hellking.study.webservice;
import com.verisign.messaging.WSSecurity;
...
public class WSSHelper {
	static String PROVIDER="ISNetworks";//JSSE安全提供者。	
   //添加JSSE安全提供者，你也可以使用其它安全提供者。只要支持DESede算法。
	static
	{
	java.security.Security.addProvider(new com.isnetworks.provider.jce.ISNetworksProvider());
    }
    /**
     *对XML文档进行数字签名。
     */
	public static void sign(Document doc, String keystore, String storetype,
						String storepass, String alias, String keypass) throws Exception {
		FileInputStream fileInputStream = new FileInputStream(keystore);
		java.security.KeyStore keyStore = java.security.KeyStore.getInstance(storetype);
		keyStore.load(fileInputStream, storepass.toCharArray());
		PrivateKey key = (PrivateKey)keyStore.getKey(alias, keypass.toCharArray());
		X509Certificate cert = (X509Certificate)keyStore.getCertificate(alias);

		SigningKey sk = SigningKeyFactory.makeSigningKey(key);
		KeyInfo ki = new KeyInfo();
		ki.setCertificate(cert);

		WSSecurity wSSecurity = new WSSecurity();
		wSSecurity.sign(doc, sk, ki);//签名。
	}
    /**
     *对XML文档进行身份验证。
     */
	public static boolean verify(Document doc, String keystore, String storetype,
						String storepass) throws Exception {
		FileInputStream fileInputStream = new FileInputStream(keystore);
		java.security.KeyStore keyStore = java.security.KeyStore.getInstance(storetype);
		keyStore.load(fileInputStream, storepass.toCharArray());

		TrustVerifier verifier = new X509TrustVerifier(keyStore);

		WSSecurity wSSecurity = new WSSecurity();
		MessageValidity[] resa = wSSecurity.verify(doc, verifier, null,null);
		if (resa.length > 0)
			return resa[0].isValid();
		return false;
	}
   /**
    *对XML文档进行加密。必须有JSSE提供者才能加密。
    */
	public static void encrypt(Document doc, String keystore, String storetype,
						String storepass, String alias) throws Exception {
		try
		{
				
		FileInputStream fileInputStream = new FileInputStream(keystore);
		java.security.KeyStore keyStore = java.security.KeyStore.getInstance(storetype);
		keyStore.load(fileInputStream, storepass.toCharArray());
		X509Certificate cert = (X509Certificate)keyStore.getCertificate(alias);
		
		PublicKey pubk = cert.getPublicKey();
		KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede",PROVIDER);		
		keyGenerator.init(168, new SecureRandom());
		SecretKey key = keyGenerator.generateKey();
		KeyInfo ki = new KeyInfo();
		ki.setCertificate(cert);

		WSSecurity wSSecurity = new WSSecurity();
		//加密。
		wSSecurity.encrypt(doc, key, AlgorithmType.TRIPLEDES, pubk, AlgorithmType.RSA1_5, ki);
	}
	catch(Exception e)
	{
		e.printStackTrace();
	}
	}
    /**
     *对文档进行解密。
     */
	public static void decrypt(Document doc, String keystore, String storetype,
						String storepass, String alias, String keypass) throws Exception {
		FileInputStream fileInputStream = new FileInputStream(keystore);
		java.security.KeyStore keyStore = java.security.KeyStore.getInstance(storetype);
		keyStore.load(fileInputStream, storepass.toCharArray());
		PrivateKey prvk2 = (PrivateKey)keyStore.getKey(alias, keypass.toCharArray());

		WSSecurity wSSecurity = new WSSecurity();
		//解密。
		wSSecurity.decrypt(doc, prvk2, null);
		WsUtils.removeEncryptedKey(doc);//从 WS-Security Header中删除 EncryptedKey 元素
	}

	public static void removeWSSElements(Document doc) throws Exception {
		WsUtils.removeWSSElements(doc);// 删除WSS相关的元素。
	}		
}

WSSHelper类中使用了ISNetworks安全提供者，ISNetworks实现了RSA加密、解密算法。当然，你也可以使用其它的安全提供者，并且可以使用不同的加密算法。可以从网络上下载ISNetworks相关包。

WSSHelper中包含了一个WsUtils类，它的功能就是从加密后的SOAP消息中删除一些WS-Security元素，删除这些元素后的SOAP消息才能被最终的客户端或者Web服务端处理。

服务器端Handler开发
当请求到达后，服务端Handler调用handleRequest方法，执行如下过程：对请求SOAP消息解密'身份验证'删除WSS元素'把Document转换成SOAP消息。 Web服务端点对请求做出响应后，将调用handleResponse方法，执行如下过程：对响应的SOAP消息进行数字签名'加密'把Document转换成SOAP消息。

例程8 服务器端Handler（WSSecurityServerHandler.java）


package com.hellking.study.webservice;
...

//服务器端Handler
public class WSSecurityServerHandler implements Handler 
{
	 	//密匙库相关信息
private String keyStoreFile = null;
		private String keyStoreType = "JKS";
		。。。
		
		public WSSecurityServerHandler()
		{
			System.out.println("服务端Handler：构造方法");
		}
	    /**
	     *处理请求
	     *流程：解密-->身份验证-->删除WSS元素'把Document转换成SOAP消息。
	     */	     
	    public boolean handleRequest(MessageContext messageContext) {
	 	
	        	System.out.println("开始处理请求。。。");
    	if (messageContext instanceof SOAPMessageContext){
			try {
	SOAPMessageContext soapMessageContext = (SOAPMessageContext)messageContext;
				SOAPMessage soapMessage = soapMessageContext.getMessage();
				soapMessage.writeTo(System.out);
	Document doc = MessageConveter.convertSoapMessageToDocument(soapMessage);
                    //解密
				WSSHelper.decrypt(doc, keyStoreFile, keyStoreType,
						keyStorePassword, keyAlias, keyEntryPassword);
                     //身份验证
				WSSHelper.verify(doc, trustStoreFile, trustStoreType, trustStorePassword);
				//删除WSS元素
WSSHelper.removeWSSElements(doc);

				soapMessage = MessageConveter.convertDocumentToSOAPMessage(doc);
				soapMessageContext.setMessage(soapMessage);
			} catch (Exception e){

				System.err.println("在处理请求时发生了异常： " + e);
				e.printStackTrace();
				return false;
			}
		} else {
			System.out.println("MessageContext是以下类的实例： " + messageContext.getClass());
		}
		 System.out.println("处理请求完毕！");
        return true;
    }
    
    /**
     *处理响应
     *流程：数字签名-->加密-->把Document转换成SOAP消息。
     */
     public boolean handleResponse(MessageContext messageContext) {
        	System.out.println("开始处理Web服务响应。。。");
        if (messageContext instanceof SOAPMessageContext){
			try {
		SOAPMessageContext soapMessageContext = (SOAPMessageContext)messageContext;
				SOAPMessage soapMessage = soapMessageContext.getMessage();
		Document doc = MessageConveter.convertSoapMessageToDocument(soapMessage);
				WSSHelper.sign(doc, keyStoreFile, keyStoreType,
						keyStorePassword, keyAlias, keyEntryPassword);
				WSSHelper.encrypt(doc, trustStoreFile, trustStoreType,
						trustStorePassword, certAlias);

				soapMessage = MessageConveter.convertDocumentToSOAPMessage(doc);
				soapMessageContext.setMessage(soapMessage);
			} catch (Exception e){
				System.err.println("在处理响应时发生以下错误： " + e);
				e.printStackTrace();
				return false;
			}
		}
	
		System.out.println("处理响应完毕！");
        return true;
    }
    /**
     *初始化，主要是初始化一些相关参数。
     */
     public void init(HandlerInfo config) {
		System.out.println("WSSecurityServerHandler初始化");
		Object param = "";
		Map configs = config.getHandlerConfig();
		keyStoreFile = (String)configs.get("keyStoreFile");
		trustStoreFile = (String)configs.get("trustStoreFile");
		…//其它参数初始化	
    }
	…
}

客户端Handler开发
客户端Handler可以是任何JAX-RPC兼容的Handler处理器。比如AXIS Handler实现或者SUN 提供的JAX-RPC Handler参考实现。这里使用后者来作为客户端Handler处理器。

客户端Handler和服务器端Handler原理一样，但处理过程完全相反。

例程9 客户端Handler（WSSecurityClientHandler.java）


package com.hellking.study.webservice;
…

//客户端Handler
public class WSSecurityClientHandler implements Handler 
{       
       //密匙库相关信息   
	    ...
		
	    /**
	     *处理请求
	     *流程：数字签名-->加密-->把Document转换成SOAP消息。
	     */	     
	    public boolean handleRequest(MessageContext messageContext) {
	 	
	        	System.out.println("开始处理请求。。。");
           …
		       	WSSHelper.sign(doc, keyStoreFile, keyStoreType,
				keyStorePassword, keyAlias, keyEntryPassword);
			    WSSHelper.encrypt(doc, trustStoreFile, trustStoreType,
trustStorePassword, certAlias);
				soapMessage = MessageConveter.convertDocumentToSOAPMessage(doc);
				soapMessageContext.setMessage(soapMessage);
			…
		 System.out.println("处理请求完毕！");
        return true;
    }
    
    /**
     *处理响应
     *流程：解密-->身份验证-->删除WSS元素'把Document转换成SOAP消息。
     */
     public boolean handleResponse(MessageContext messageContext) {

        	System.out.println("开始处理Web服务响应。。。");
       …
			    WSSHelper.decrypt(doc, keyStoreFile, keyStoreType,
						keyStorePassword, keyAlias, keyEntryPassword);				
				
				WSSHelper.verify(doc, trustStoreFile, trustStoreType, trustStorePassword);
				WSSHelper.removeWSSElements(doc);

				
				soapMessage = MessageConveter.convertDocumentToSOAPMessage(doc);
								System.out.println("the final message is:");
								soapMessage.writeTo(System.out);
				soapMessageContext.setMessage(soapMessage);
			…		
			System.out.println("处理响应完毕！");
        return true;
    }
    /**
     *初始化，主要是初始化一些相关参数。
     */
     public void init(HandlerInfo config) {
		…
    }
	…
}

部署服务器端Handler
为了使用Handler，需要在Web服务部署描述符中指定使用此Handler。Handler包含的初始化参数也在此描述，如例程10所示。

例程10 服务器端Handler部署代码

requestFlow表示Web服务PersonalTaxServicePort的请求处理Handler链。这里只有一个Handler，就是WSSecurityServerHandler。当Web服务请求到达PersonalTaxServicePort时，WSSecurityServerHandler的handleRequest方法将被自动调用。

注意：部署时，请改变Handler相关参数以和目标的Web服务一致，比如trustStoreFile的路径等。

调用测试
这里采用代理的方式来调用Web服务，先编写一个Web服务接口。

例程11 TaxServiceInterface


package com.hellking.study.webservice;
…
/**
 *个人所得税Web服务。
 */
public interface TaxServiceInterface extends Remote
{
	public double getTax(double salary)throws java.rmi.RemoteException;
}

WSSClient客户端程序是通过代理的方式来访问Web服务的。由于要使用Handler，所以在访问前通过registerHandlers（）方法注册了WSSecurityClientHandler，并且初始化了WSSecurityClientHandler的相关参数。当然，JAX-RPC"参考实现"还支持在Web服务客户端配置文件中描述Handler信息，这样就不需要在客户端代码中对Handler进行注册了，你可以参考相关文档。

例程12 测试客户端程序（WSSClient）


package com.hellking.study.webservice;

...
/**
 *调用需要验证的Web服务
 */
public class WSSClient
{
	static	final double salary=5000;
    public static void main(String [] args)
    {
        try {
        	//服务端的url，需要根据情况更改。            
            String endpointURL = "http://localhost:8080/axis/services/PersonalTaxServicePort";
            String wsdlURL=endpointURL+"?wsdl";
            java.net.URL targetURL= new java.net.url(/blog/wsdlURL);
            String nameSpaceUri = "http://hellking.webservices.com/";
            String svcName = "PersonalTaxService";		
		    String portName = "PersonalTaxServicePort";

            ServiceFactory svcFactory = ServiceFactory.newInstance();

            Service svc = svcFactory.createService(targetURL, new QName(nameSpaceUri, svcName));
            //cfg表示客户端的配置信息。
            java.util.HashMap cfg = new java.util.HashMap();
			
			cfg.put("keyStoreFile", "client.keystore");			
			cfg.put("trustStoreFile", "client.truststore");			
			cfg.put("certAlias", "changeit");
			
		    Class hdlrClass = com.hellking.study.webservice.WSSecurityClientHandler.class;
			
			java.util.List list = svc.getHandlerRegistry().
			
			               getHandlerChain(new QName(nameSpaceUri, portName));
			
			list.add(new javax.xml.rpc.handler.HandlerInfo(hdlrClass, cfg, null));
			
		     registerHandlers (svc);
			
			 TaxServiceInterface myProxy = 
               ( TaxServiceInterface) svc.getPort(new QName(nameSpaceUri, portName), 
                 TaxServiceInterface.class);       
              double ret=myProxy.getTax(5000);
			System.out.println("使用HTTP协议来作为Web服务的传输协议！");			
            System.out.println("已经成功调用。请参看服务端的输出!");
            System.out.println("输入工资"+salary+"元，应交个人所得税："+ret);
        } catch (Exception e) {
        	e.printStackTrace();
        }
    }
    //注册Handler
    private static void registerHandlers ( Service service ) 
		throws javax.xml.rpc.ServiceException {
		
		java.util.HashMap cfg = new java.util.HashMap();
			
			cfg.put("keyStoreFile", "client.keystore");			
			cfg.put("trustStoreFile", "client.truststore");			
			cfg.put("certAlias", "changeit");
			
		/*
		* 封装客户端Handler到HandlerInfo 中，然后添加到Handler链中。
		*/ 
	javax.xml.rpc.handler.HandlerInfo info = new javax.xml.rpc.handler.HandlerInfo
	(com.hellking.study.webservice.WSSecurityClientHandler.class, cfg, null );
		java.util.ArrayList handlerList = new java.util.ArrayList();
		handlerList.add(info);
		
		/*
		* 获得Handler注册
		*/
		javax.xml.rpc.handler.HandlerRegistry handlerRegistry = service.getHandlerRegistry();
		
		/*
		* 把Handler添加到所有的port中。
		*/
		java.util.Iterator portIterator = service.getPorts();
		while ( portIterator.hasNext()) {
			Object obj=portIterator.next();
		QName portName = (QName) obj;
		handlerRegistry.setHandlerChain(portName, handlerList);
		}
    }
    
}

注意：由于客户端使用了SUN公司提供的"JAX-RPC参考实现"，所以必须把jaxrpc-impl.jar包设置在CLASSPATH环境变量中，并且不要把axis.jar设置在客户端CLASSPATH环境变量，否则会出现ClassCastException异常。这是因为axis也是JAX-RPC的实现，如果它在CLASSPATH环境变量中，当调用：

ServiceFactory svcFactory = ServiceFactory.newInstance()方法时，就可能初始化一个axis的ServiceFactory 实现。

本文源代码中client目录下wss-client.bat文件包含了执行WSSClient脚本，修改了部分环境变量参数后，才能执行。

总结
本文和上一篇文章介绍了几种不同实现Web服务安全的方法，你可以根据具体应用对安全的要求级别采用不同的方式。对于安全级别要求不高的应用，可以采用在Web服务器上使用基本认证、使用Axis的Handler或者使用Servlet过滤器来实现访问控制；对于安全要求高的应用，可以采用本篇介绍开发的"axis下实现WS-Security的通用应用框架"来实现安全性。

SIMONE 2006-08-04 20:08 发表评论

实现安全的AXIS Web服务

SIMONE — Fri, 04 Aug 2006 12:07:00 GMT

高级软件工程师

2004 年 8 月 01 日

本文首先简单介绍Web服务安全性基本概念，然后介绍在axis Web服务开发工具下处理安全性问题的一些常用方法；接下来以安全性实现方法为线索，介绍了怎么在Web应用的基础上配置Web服务的访问控制、怎么使用axis的Handler和Servlet的过滤器进行访问控制，最后讨论怎么在tomcat下配置SSL 以实现Web服务的安全传输。

axis是流行的Web服务开发工具，如何在axis下开发安全的Web服务，这是摆在每个开发者面前的问题。本文是J2EE Web服务开发系列文章的第十二篇，将首先简单介绍Web服务安全性基本概念，然后介绍在axis Web服务开发工具下处理安全性问题的一些常用方法；接下来以安全性实现方法为线索，介绍了怎么在Web应用的基础上配置Web服务的访问控制、怎么使用axis的Handler和Servlet的过滤器进行访问控制，最后讨论怎么在tomcat下配置SSL 以实现Web服务的安全传输。本文下一篇将介绍怎么在axis中实现WS-Security。

阅读本文前您需要以下的知识和工具：

Apache axis1.1，并且会初步使用；
Tomcat 4.0以上, 并且会初步使用；
Servlet的开发经验；
SOAP消息（SOAP Message）编程知识；
JAX-RPC编程基础知识；
Java安全编程基础知识。

本文的参考资料见参考资料。

本文的全部代码在这里下载。

Web服务安全概述

安全的Web服务是Web服务成功的必要保证。但众所周知的是，Web服务使用XML来进行数据交换，而XML在默认情况下是明文编码的；同时，大部分Web服务使用HTTP协议作为传输协议，同样，HTTP也是使用明文方式来传输数据的。这就造成了在不加密的传输协议上传输不加密的信息，从而使信息传输的保密性受到威胁。作为企业级的应用，以上的方式不能满足安全性基本要求：

数据在因特网上传播时不应该被第三方看到；
双方必须能够确定消息的来源；
双方必须能够确定被传送的数据没有被篡改。

通过使用SSL协议可以解决第一个问题："不应该被第三方看到"；使用数字签名和数字证书可以解决后面两个问题。当使用数字证书方法时，Web 服务请求者必须有一个由可信认证中心签署的数字证书。请求者使用这个证书来表明它们的身份，并对 SOAP 消息进行数字签名。对方系统接收到消息后，就可对消息做时间戳记并进行日志记录。此时，数字签名会得到验证。验证过程将确保消息来自发送方，并且还要验证消息内容在传输过程中没有被篡改。

IBM、Microsoft 和 Verisign 于2002年十二月份联合发布了一个关于 Web 服务安全性（Web Services Security，WS-Security）的规范，该规范描述如何向 SOAP 消息附加签名和加密报头；另外，它还描述如何向消息附加安全性令牌（包括二进制安全性令牌，如 X.509 证书），提供了一套帮助 Web 服务开发者保护 SOAP 消息交换的机制。

根据应用的对安全要求的级别不同，可以采用不同的方式来实现安全性，以下是目前最常用的一些实现方式（从低到高排列）：

J2EE Web应用默认的访问控制（数据是明文的）；
使用axis的Handler进行访问控制（数据是明文的）；
使用Servlet过滤器（Filter）进行访问控制（数据是明文的）；
使用SSL/HTTPS协议来传输（加密的数据传输协议）；
使用WS-Security规范对信息进行加密与身份认证（数据被加密传输）。

前三种方式对于安全级别要求不高的应用是可行的，它能够使用Web应用访问认证机制来进行权限验证，从而保护对资源的访问。但需要注意的是，虽然它们进行了身份验证，但信息的传递还是以明文的方式进行的，不能保证信息在传输过程中不被窃取。SSL是一个安全的传输协议，使用它传输Web服务能保证信息不被第三方窃取。但它有个缺点就是对系统资源消耗大。采用最后一种方式，信息被签名后再加密，然后把加密后的信息网络上传播，这样，即使第三方获得加密后的传输信息，也不能解密。对于安全级别要求高的系统，应该采用WS-Security规范来作为Web服务安全性解决方案。

回页首

开发、部署示例Web服务

作为一个实例性的教程，我们有必要先开发一个简单的Web服务作为示例。关于如何在Axis下开发并部署一个简单的Web服务你可以参考下面这篇文章：用JAX-RPC开发Web服务：Servlet作为Web服务端点。

下面的例子提供的是一个提供个人所得税计算的Web服务。客户端传入工资的金额，Web服务将计算个人所得税金额。

例程 1 个人所得税Web服务

package com.hellking.study.webservice;
public class PersonalTaxService
{
	final double base=1200;//所得税上缴基数。	
	public  double getTax(double salary)
    {
    	double tax_salary=salary-1200;    	
    	double tax=0.0d;//计算后的所得税。    	
    	if(0>tax_salary)                             tax=0;
    	else if(0

编译后，你只要在Axis的部署配置文件（AXIS_HOME\Web-INF\server-config.wsdd）的适当位置增加以下部署代码，Web服务就可以部署成功。

例程2 部署示例Web服务

部署后的Web服务URL为： http://localhost:8080/axis/services/PersonalTaxService?wsdl （请先部署好这个Web服务再进行下面的学习。）

回页首

从Web应用的基本认证说起

不管客户端通过什么API来调用Web服务，它总是先构造SOAP消息，然后通过HTTP POST方法把消息发送到Web服务的URL（注1：当然，Web服务也可以通过其它基于文本的协议传输，但是由于非常少见，在这里不讨论）。而我们知道，不管axis部署在哪种服务器上（Tomat还是Websphere），它总是以Servlet方式来运行的。所以最简单实现Web服务安全的方式就是通过在web应用的配置文件（web.xml）来实现访问控制。

J2EE web应用中有多种认证方式：BASIC（基本认证方法）、FORM（基于表单）、DIGEST（消息摘要）和CLIENT-CERT（数字证书）。关于J2EE Web应用的其它认证方式的配置请参考其它资料，在此不再介绍。

下面以Tomcat使用服务器为例，使用Web应用模型中基本认证方法来配置Web服务的安全访问。

Web应用的基本认证是建立在J2EE角色和用户的基础之上，首先在Tomcat角色配置文件中增加一个角色和一个帐号。

例程3 在tomcat-users.xml中增加角色（Tomcat_Home\conf\tomcat-users.xml）

上面配置代码在tomcat配置文件中添加了一个department-manager角色，并且在此角色中添加了一个名为hellking的用户。要使tomcat-users.xml中配置的角色和用户生效，需要配置tomcat使用UserDatabaseRealm。打开Tomcat_Home\conf\server.xml配置文件，在GlobalNamingResources中添加以下描述：

例程4 在tomcat中添加UserDatabaseRealm

  
...
  
    
    
      
        factory
        org.apache.catalina.users.MemoryUserDatabaseFactory
      
      
        pathname
        conf/tomcat-users.xml

然后再web应用的部署描述符中指定Web服务资源的访问控制，如下所示：

例程5 配置对Servlet的访问控制（AXIS_HOME\WEB-INF\web.xml）


  
    Tax Web service 
    /services/PersonalTaxService
  
  
    department-manager
  


  BASIC
  Axis Basic Authentication Area


  department-manager

url-pattern指定了需要通过角色验证的URL样式，在这里是"/services/PersonalTaxService"；role-name是能够访问制定URL的角色，这里是department-manager。以上配置的意思是只有角色类型是"department-manager"的用户才能访问URL样式为"/services/PersonalTaxService"Web服务。

下面我们看怎么在axis客户端代码中axis客户端，如例程6所示。

例程6 axis客户端代码

package com.hellking.study.webservice;

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

/**
 *调用需要验证的Web服务
 */
public class AuthClient
{
	static	final double salary=5000;
    public static void main(String [] args)
    {
        try {
        	//服务端的url，需要根据情况更改。            
            String endpointURL = "http://localhost:8080/axis/services/PersonalTaxService?wsdl";//
// Web服务端点地址            
            Service  service = new Service();
            Call     call    = (Call) service.createCall();
            call.setTargetEndpointAddress( new java.net.url(/blog/endpointURL) );
            call.setOperationName( new QName("PersonalTaxService", "getTax") );//设置操作的名称。
            //由于需要认证，故需要设置调用的用户名和密码。
            call.getMessageContext().setUsername("hellking");//设置用户名。
            call.getMessageContext().setPassword("simplewebservices");//设置密码
            call.addParameter( "op1", XMLType.XSD_DOUBLE, ParameterMode.IN );//参数的类型
		   call.setReturnType( XMLType.XSD_DOUBLE );//返回的数据类型
            Double ret = (Double) call.invoke( new Object [] { new Double(salary) });//执行调用
		  System.out.println("使用HTTP协议来作为Web服务的传输协议！");			
            System.out.println("已经成功调用。请参看服务端的输出!");
            System.out.println("输入工资"+salary+"元，应交个人所得税："+ret);
     。。。
    }
}

可以看出，通过使用call.getMessageContext().setUsername("hellking")来设置调用的用户名，通过setPassword来设置调用的密码。通过上面的代码可以看出，除了为Call对象设置的用户名和密码外，其它的代码和不使用访问控制时一样。

下面我们看看它的运行结果：

使用HTTP协议来作为Web服务的传输协议！
已经成功调用。请参看服务端的输出!
输入工资5000.0元，应交个人所得税：445.0

从输出可以看到，客户端成功通过了验证，并且返回了正确的结果。

回页首

使用axis的Handler进行访问控制

axis为Web服务的访问控制提供了相关的配置描述符，并且提供了一个访问控制的简单Handler（关于Handler的详细介绍见" J2EE Web服务开发系列之六: 使用Handler来增强Web服务的功能"）。默认情况下，你只要在配置描述符中添加用户，然后在Web服务器的部署描述符中自动允许的角色即可。

首先在axis的配置文件users.lst（位于WEB-INF目录下）中添加一个用户，如"axisuser pass"，表示用户名为axisuser，密码为pass。然后把案例的Web服务重新部署，在server-config.wsdd中添加例程7所示的部署代码。

例程7 重新部署PersonalTaxService

在这个部署描述符中，指定PersonalTaxService2服务只能被axisuser访问，要想使访问控制生效，还必须把SimpleAuthenticationHandler添加到请求Handler链中。

你只要修改AuthClient代码的服务端点URL和访问用户名、密码，就可以测试新的Web服务了，如例程8所示。

例程8 HandlerAuthClient

public class HandlerAuthClient
{
。。。  
String endpointURL = "http://localhost:8080/axis/services/PersonalTaxService2?wsdl";
      。。。
   call.getMessageContext().setUsername("axisuser");//axis中的用户名。
   call.getMessageContext().setPassword("pass");//密码
。。。

执行HandlerAuthClient，能够顺利访问Web服务；如果修改用户名或者密码，那么就不能访问，这说明Axis的Handler对Web服务的访问权限进行了有效的控制。

使用Servlet过滤器（Filter）进行访问控制 Axis的Web服务端本质上是以Servlet方式在运行，所有我们完全可以在Web应用上部署一个Servlet过滤器，通过此过滤器来达到访问控制的效果。

Web应用中的过滤器截取从客户端进来的请求，然后进行一系列处理，最后把请求发送到目标Servlet。过滤器的工作原理如下图所示。

图1 过滤器工作原理

过滤器可以说是外部进入Web服务器的第一道关，它能决定请求是否继续向前转发，也能对请求中的信息进行处理。如果过滤器用于对Web服务进行访问控制，那么它能根据客户端信息决定目标的服务是否能调用成功。

将要开发的过滤器将根据客户端IP地址进行过滤，如果客户端的IP地址在限制范围中，那么就不能访问目标的Web服务。过滤器部分代码如下。

例程9 用过滤器限制Web服务的访问权限

package com.hellking.study.webservice;

import javax.servlet.FilterChain;
。。。
public class WebServicesFilter implements Filter
{
     //没有权限访问的IP地址
	static final String[] deniedIPList=new String[]{
		               "123.201",
		               "192.168",
		               "25.46",
		               "124.0.0.1"
		            };	
	 public boolean isIPDenied(String ipAddr)
     {
     	…
     }
	
	//过滤处理的方法
	public void doFilter(final ServletRequest req,final ServletResponse res,FilterChain chain)
		throws IOException,ServletException
	{
		 HttpServletRequest hreq = (HttpServletRequest)req;
         HttpServletResponse hres = (HttpServletResponse)res;
         //HttpSession session = hreq.getSession();
         String clientIp=req.getRemoteAddr();
         System.out.println("开始过滤。。。");
         if(isIPDenied(clientIp))
		 {
		 	 //验证不成功，让用户登录。
		 	throw new ServletException("无权限访问此Web服务！");
		  }		
		 else
			 {
			 	//验证成功，继续处理
			   chain.doFilter(req,res);		 	

			 }	 
		 	
	}	
	…
}

WebServicesFilter 过滤器限制了deniedIPList中指定的所有客户端。编写了过滤器后，需要在Web应用的部署描述符中指定使用此过滤器，并且把过滤器映射到目标URL上。当然，你也可以开发其它过滤器进行访问控制，比如Web服务客户端登录时，把登录信息保存在HTTP会话中，当客户端访问受限的资源时，读取HTTP会话中客户端信息以决定客户端是否有权限访问目标资源。

除了编写Servlet过滤器实现类外，还需要在web.xml中对它进行配置，并且把过滤器映射到要过滤的目标URI上。以下是过滤器的部署描述符。

例程10 部署过滤器

    
        WebServicesFilter
        com.hellking.study.webservice.WebServicesFilter
        
    
        WebServicesFilter
        /services/*

url-pattern指定了过滤器要过滤的范围。"/services/*"表示以"/services"开始的URL将全部被过滤，这正是AxisServlet默认的URL。通过上面的配置，只要客户端调用axis Web服务，就会被WebServicesFilter过滤器过滤。如果客户端IP地址在过滤器的deniedIPList中，那么就不能访问目标服务。

回页首

使用SSL作为Web服务的传输协议

Web服务也可以使用SSL作为传输协议。虽然JAX-RPC并没有强制规定是否使用SSL协议，但在tomcat下使用HTTPS协议。

相关知识：

SSL由两个共同工作的协议组成："SSL 记录协议"（SSL Record Protocol）和"SSL 握手协议"（SSL Handshake Protocol）。SSL 记录协议建立在可靠的传输协议（如TCP）之上，为高层协议提供数据封装、压缩、加密等基本功能的支持；SSL 握手协议建立在SSL记录协议之上，用于在实际的数据传输开始前，通信双方进行身份认证、协商加密算法、交换加密密钥等。

SSL握手协议包含两个阶段，第一个阶段用于建立私密性通信信道，第二个阶段用于客户认证。第一阶段是通信的初始化阶段，在此阶段，首先SSL要求服务器向浏览器出示证书；然后浏览器中的SSL软件发给服务器一个随机产生的传输密钥，此密钥由已验证过的公钥加密，随机产生的传输密钥是核心机密，只有客户的浏览器和此公司的Web服务器知道这个数字序列。第二阶段的主要任务是对客户进行认证，此时服务器已经被认证了。服务器方向客户发出认证请求消息。客户收到服务器方的认证请求消息后，发出自己的证书，并且监听对方回送的认证结果。而当服务器收到客户的证书后，给客户回送认证成功消息，否则返回错误消息。到此为止，握手协议全部结束。

要使用SSL协议，服务器至少有一个私有密匙和一个用于验证身份的证书。私有密匙在密匙交换算法中用到，证书将发送到客户端，以通知服务器端的身份。如果SSL服务器要验证客户端的身份，那么客户端必须也有自己的密匙库（包含私有密匙和证书）。JSSE中引入了信任库（truststore）的概念，它是用来保存证书的数据库。客户端或者服务器通过信任库来验证对方的身份。

在使用SSL前，必须确保系统安装了JSSE。JDK1.4版本默认以及安装了JSSE。如果没有安装，把下载安装好的jar文件拷贝到%JAVA_HOME%\ jre\lib\ext目录下。这样，就安装好了JSSE的运行环境。

下面我们使用JDK自带的工具创建密匙库和信任库。

1）通过使用一下的命令来创建服务器端的密匙库。

        keytool -genkey -alias hellking -keystore server.keystore -keyalg RSA
输入keystore密码：  changeit
您的名字与姓氏是什么？
  [Unknown]：  hellking-Server
您的组织单位名称是什么？
  [Unknown]：  huayuan
您的组织名称是什么？
  [Unknown]：  huayuan
您所在的城市或区域名称是什么？
  [Unknown]：  beijing
您所在的州或省份名称是什么？
  [Unknown]：  beijing
该单位的两字母国家代码是什么
  [Unknown]：  cn
CN=chen ya qiang, OU=huayuan, O=huayuan, L=beijing, ST=beijing, C=cn 正确吗？
  [否]：  y

输入的主密码
        （如果和 keystore 密码相同，按回车）：

以上命令执行完成后，将获得一个名为server.keystore的密匙库。

2)生成客户端的信任库。首先输出RSA证书：

keytool -export -file test_axis.cer -storepass changeit -keystore server.keystore

然后把RSA证书输入到一个新的信任库文件中。这个信任库被客户端使用，被用来验证服务器端的身份。

keytool -import -file test_axis.cer -storepass changeit -keystore client.truststore -alias serverkey -noprompt

3）创建客户端密匙库。重复步骤1，创建客户端的密匙库。也可以使用以下命令来完成：

keytool -genkey -dname " CN=hellking-Client, OU=tsinghua, O=tsinghua, L=BEIJING, S=BEIJING, C=CN"
-storepass changeit -keystore client.keystore -keyalg RSA -keypass changeit

4）生成服务器端的信任库。

keytool -export -file test_axis.cer -storepass changeit -keystore client.keystore
keytool -import -file test_axis.cer -storepass changeit -keystore server.truststore -alias clientkey -noprompt

生成了密匙库和信任库，我们把服务器端的密匙库（server.keystore）和信任库（server.truststore）拷贝到Tomcat的某个目录。

下面需要更改Tomcat的配置文件（server.xml），增加一下部署描述符：

例程11 为Tomcat配置SSL协议。

clientAuth参数制定服务器是否要验证客户端证书，如果指定为true，那么客户端必须拥护服务器端可信任的证书后服务器才能响应客户端；如果指定为false，那么服务器不需要验证客户端的证书。

在此，我们又把PersonalTaxService部署一次，在server-config.wsdd中添加如下部署代码。

最后我们需要修改客户端调用程序，如例程12所示。

例程12 SSL客户端调用程序

package com.hellking.study.webservice;
….
public class SSLAuthClient
{
	static	final double salary=5000;
    public static void main(String [] args)
    {
        try {
        	//服务端的url，注意使用了SSL协议后，前缀是https。 
           String endpointURL = "https://localhost:8443/axis/services/PersonalTaxService3?wsdl";
           ….
            //由于使用了证书数字证书，所以不使用用户名和密码验证。
//call.getMessageContext().setUsername("hellking");。
            //call.getMessageContext().setPassword("simplewebservices");
           ….
            Double ret = (Double) call.invoke( new Object [] { new Double(salary) });
			System.out.println("使用SSL协议来作为Web服务的传输协议！");		
             System.out.println("已经成功调用。请参看服务端的输出!");
             System.out.println("输入工资"+salary+"元，应交个人所得税："+ret);
        } catch (Exception e) {
        	e.printStackTrace();
        }
    }
}

最后使用一下的命令来执行客户端程序：

set AXIS_LIB=K:\jakarta-tomcat-5.0.16\webapps\axis\WEB-INF\lib
SET CLASSPATH=.;%CLASSPATH%;%AXIS_LIB%\wsdl4j.jar.jar;%AXIS_LIB%\axis.jar;%AXIS_LIB%\jaxrpc.jar;%AXIS_LIB%
\saaj.jar;%AXIS_LIB%\commons-discovery.jar;%AXIS_LIB%\commons-logging.jar
java -Djavax.net.ssl.keyStore=client.keystore \
-Djavax.net.ssl.keyStorePassword=changeit \
-Djavax.net.ssl.trustStore=client.truststore \
com.hellking.study.webservice.SSLAuthClient

参数解释：通过-Djavax.net.ssl.keyStore来指定客户端密匙库，-Djavax.net.ssl.trustStore来指定客户端信任库。

最后的输出结果如下：

使用SSL协议来作为Web服务的传输协议！
已经成功调用。请参看服务端的输出!
输入工资5000.0元，应交个人所得税：445.0

回页首

总结、下一步

使用Web应用模型中基本认证方法来配置Web服务的安全访问以及使用axis的Handler、Servlet的过滤器来进行访问控制，它们都是一些轻量级控制Web服务安全解决方案，因为都是把未加密的信息在网络上传播。使用了SSL作为传输协议后，信息在网络上是加密传输的，但对资源消耗多，并且对客户端要求严格（必须支持SSL），不能满足Web服务访问的便利性。下一部分将介绍怎么在安全性要求高的环境下在axis开发工具里实现WS-Security。

下载样例代码在此。

回页首

参考资料

回页首

关于作者


		陈亚强：北京华园天一科技有限公司高级软件工程师，擅长J2EE技术，曾参与多个J2EE项目的设计和开发，对Web服务有很大的兴趣并且有一定的项目经验。热爱学习，喜欢新技术，曾参与多本图书的写作。好交朋友，您可以通过 cyqcims@mail.tsinghua.edu.cn和他联系。

SIMONE 2006-08-04 20:07 发表评论

使用SOAP开发java web服务--Axis开发方案

SIMONE — Fri, 04 Aug 2006 12:06:00 GMT

本文的预定读者首先要对j2ee有所了解，熟悉xml，tomcat等基本内容，本文主要是简单介绍一下web服务的基本内容，怎样在java web开发中构建SOAP服务：
一、SOAP（Simple Object Access Protocol）简单对象访问协议，要了解SOAP，首先就需要了解分布式计算的由来，随着下一代的分布式计算体系web服务的出现，SOAP成为了创建和调用通过网络发布的应用程序的实际通信标准。SOAP类似传统的二进制协议IIOP（CORBA）和JRMP（RMI），但它不采用二进制数据表示法，而是采用使用XML的，基于文本的数据表示法。
        通过XML表示法，SOAP定义了一种小型有线连接协议和编码格式，以表示数据类型、编程语言和数据库，还可以使用各种Internet标准协议作为其消息传输工具，还可以提供表示RPC和文档驱动的消息交换等通信模型的约定。请注意，W3C正致力于SOAP的研究，http://www.w3c.org/2000/xp/Group/ ，并得到了主流供应商的积极响应，以便对于基于XML的协议相关的重要任务达成共识，并定义其关键要求和使用场景。
        SOAP1.2的基本规范定义了以下基本内容：
       1）用于将XML文档表示为结构化SOAP消息的语法和语义
       2）在SOAP消息中表示数据的编码标准
       3）用于交换SOAP消息的通信模型
       4）SOAP传输等底层协议的绑定
      SOAP消息主要包括了信封头，消息头，主体，附件几部分
      一个简单的SOAP消息表示：
      POST   /StudentInfo   HTTP/1.1
      Host：anthropology.cun.edu
      Content-Type: text/xml;charset="utf-8"
      Content-Length: 640
      SOAPAction:  "GetStudentInfo"

http://www.w3c.org/2001/06/soap-envelope"
              xmlns:xsi="http://www.w3c.org/2001/XMLSchema-instance"
              xmlns:xsd="http://www.w3c.org/2001/XMLSchema"
             SOAP-ENV:encodingStyle="http://www.w3c.org/2001/06/soap-encoding">

xyz@cun.edu

                        Wang wen yin

   以上是1.2版本命名空间，1.1的命名空间 SOAP ENVELOPE：http://schemas.xmlsoap.org/soap/envelop/ ,SOAP ENCODING: http://schemas.xmlsoap.org/soap/encoding/
   关于SOAP编码规范请参阅www.w3c.org/TR/xmlschema-2/ 定义的编码值，其他的一些规范可以上www.w3c.org 上具体查看。
二、以下从实际例子来学习，这里我使用的是Apache的一个子项目Axis的具体例子，便于深入了解soap的运行：
    1）下载Axis的相关内容http://ws.apache.org/axis/：
    2）建立一个实例程序（遵守j2ee的web程序规范），如（WebServiceTest目录）
          把axis中lib文件夹的内容拷到你的WebServiceTest/WEB-INF/lib下，同时上网下载xerces(下载地点：http://xml.apache.org/xerces-j/）解释器的包文件xerces.jar，也拷到WebServiceTest/WEB-INF/lib文件夹下,（若要配置log4j，请把属性文件log4j.properties拷到WebServiceTest/WEB-INF/classes文件夹下)
    3)修改应用程序WebServiceTest/WEB-INF中的web.xml文件：主要servlet设置如下

TestServlet

org.apache.axis.transport.http.AxisServlet

TestServlet

*.jws

TestServlet

/servlet/TestServlet

TestServlet

/services/*

          AdminServlet

               org.apache.axis.transport.http.AdminServlet

          100



          AdminServlet
          /servlet/AdminServlet



          wsdl
          text/xml



          xsd
          text/xml

    你现在可以在网址里输入http://localhost/WebServiceTest/servlet/TestServlet 看到了吗？Axis是使用axis.jar包里的org.apache.axis.transport.http.AxisServlet对应用程序进行处理的，基本配置就讲到这里。
三、接着我们来说Axis中的内核。
1）不使用Tomcat引擎运行Axis。
       先建立一个脚步文件，对环境变量classpath进行设置要把lib下的那些包文件的路径全都包括进去，运行：java  org.apache.axis.transport.http.SimpleAxisServer
2）内部服务处理程序是org.apache.axis.providers.java.RPCProvider，标志出服务所需的方法，然后提供从SOAP请求消息组成部分的参数。
3）Axis的应用程序端管理功能：
       java org.apache.axis.client.AdminClient 就会列出参数，可供你选择。我们的例子是：java org.apache.axis.client.AdminClient -l http://localhost/WebserviceTest/servlet/TestServlet list 就会显示出服务列表，返回的是xml文件
4）wsdl2java应用程序可以把wsdl文件创建基于java的程序，如占位程序等
     java org.apache.axis.wsdl.WSDL2java
Axis的基本内容说到这里
四、具体例子
1）编写逻辑程序，简单如：SoapTest.java
    public class SoapTest{
        public String getStr(String name){
            return "Hello，"+name;
        }
    }
2) 部署服务，编写wsdd文件SoapTest_deploy.wsdd:
     http://xml.apache.org/axis/wsdd/"
         xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"
         xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
         xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance">





    其中className参数是你的想部署的类名（全名），allowedMethods是调用的服务的方法，如果有多个方法的话可以用空格分开（如： ),当用*的时候表示全部。
     好了现在准备部署了，确保环境路径classpath设置正确，运行：
        java org.apache.axis.client.AdminClient -l http://localhost/WebserviceTest/servlet/TestServlet SoapTest_deploy.wsdd
     （这里不懂的话，请参考以上的说明）
ok，呵呵，至此，我们已经完成了一个web服务的部署：测试http://localhost/WebServiceTest/servlet/TestServlet 看里面是否多了一个选择SoapTest服务？
      如果不想要服务了那重新编写一个wsdd文件，内容改为：
http://xml.apache.org/axis/wsdd/"
         xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"
         xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
         xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance">


和上面一样，对比一下就ok了。
五、客户端测试：
     客户端我们也可以使用java来进行测试，网上也有资料的，你可以去学习，很简单的。现在为了体现web服务的魅力，我用.NET平台来测试吧，客户端使用c#编写（先要安装.net framework sdk)：
    1）通过wsdl生成web服务代理，在net平台下运行：
      wsdl /l:CS /protocol:SOAP /out:SoapTestClient.cs http://localhost/WebserviceTest/services/SoapTest?wsdl
        我们通过wsdl得到了一个cs文件SoapTestClient.cs（当前目录），你可以打开cs文件，研究一下里面的代码，那个getStr(string name)就是我们需要调用的方法，我们的客户端通过调用该方法就可以调用服务器端的方法，内部的转化wsdl.exe工具已经帮我们完成了，axis下的WSDL2Java工具也是一样的功能，可以参考我上面所说的关于Axis的内核内容
   2)编译cs文件成程序集dll：
      csc /target:library /r:System.Web.Services.dll /r:System.Xml.dll SoapTestClient.cs
      最后我们等到了一个dll文件SoapTestClient.dll，客户端程序通过调用它就行了
   3）编写客户端应用程序SoapTestClientApp.cs
      using System;

      namespache jws.client{
         public class SoapTestClientApp{
            public SoapTestClientApp(){
            }
            public static void Main(string[] args){
                if(args.Length!=1){
                    Console.WriteLine("Usage:SoapTestClientApp ");
                    Environment.Exit(1);
                }
                SoapTestService st_service=new SoapTestService();
                st_service.getStr("Wang wenyin");
           }
        }
     }
４）编译文件csc /r:SoapTestClient.dll SoapTestClientApp.cs
    运行SoapTestClientApp
输出结果：
     Hello,Wang wenyin
与预期结果相符。

SIMONE 2006-08-04 20:06 发表评论

WebService学习，开发总结

SIMONE — Fri, 04 Aug 2006 12:04:00 GMT

摘要: 基本概念： 1，什么是 Web 服务？ Web 是使应用程序可以以与平台和编程语言无关的方式进行相互通信的一项技术。Web 服务是一个软件接口，它描述了一组可以在网络上通过标准化的 XML 消息传递访问的操作。它使用基于 XML 语言的协议来描述要执行的操作或者要与另一个 Web 服务交... 阅读全文

SIMONE 2006-08-04 20:04 发表评论

关于XML（XMLHTTP）跨域加载数据不会出现跨域的安全提示信息的问题

SIMONE — Thu, 30 Mar 2006 07:02:00 GMT

网上看了很多资料，但好象很少人谈到跨域读取XML文档的问题，有些论坛或BLOG关于XML跨域读取的问题，实现起来非法复杂。
在这里我介绍一下XMLHTTP跨域读取页面数据的问题，以JS为例

一、读取数据

//建立对象
var xml = new ActiveXObject("Microsoft.XMLHTTP")

//这里的abc.xml是被读取的文件，当然也可以换成别的文件，false表示非异步传输，async是asynchronism简写
xml.open("get","http://www.mydomain.com/abc.xml",false)
xml.send()

二、在被读取数据的域根下（上例是在www.mydomain.com/下），建立一个XML 策略文件，名字一定要是crossdomain.xml。

在策略文件中加入以下代码

//domain属性的值就是被允许从本站读取数据的来源域名

这样就完成了跨域读取数据并不会出现跨域的安全提示信息了

SIMONE 2006-03-30 15:02 发表评论

Axis开发之Stubs方式

SIMONE — Thu, 30 Mar 2006 04:55:00 GMT

1、建立代理接口文件
public interface ISendSms extends java.rmi.Remote {
public String getUser(String id,String type);
}

转到在目录..\WebRoot\WEB-INF\classes下:

2、生成client stub文件, 生成SendSms.wsdl文件
java -Djava.ext.dirs=../lib org.apache.axis.wsdl.Java2WSDL -oSendSms.wsdl -lhttp://localhost:8080/websms/services/SendSms -n"urn:SendSms" -p"sample.webservice" "urn:SendSms" sample.webservice.ISendSms

生成的SendSms.wsdl文件中，参数名称默认为in1,in2等，需要改成相应的名称。

3、生成client stub
java -Djava.ext.dirs=../lib org.apache.axis.wsdl.WSDL2Java -o . -d Session -s -S true -Nurn:SendSms sample.webservice SendSms.wsdl

生成的文件列表如下:
deploy.wsdd
undeploy.wsdd
ISendSms.java
ISendSmsService.java
ISendSmsServiceLocator.java
SendSmsSoapBindingImpl.java
SendSmsSoapBindingSkeleton.java
SendSmsSoapBindingStub.java

4、布署服务,在WEB-INF目录下生成server-config.wsdd文件, 随Tomcat启动自动加载里面定义的服务
转到目录..\WebRoot\WEB-INF\classes\sample\webservice下
java -cp %AXISCLASSPATH% org.apache.axis.client.AdminClient -lhttp://localhost:8080/websms/services/AdminService deploy.wsdd

在Axis里书写deploy.wsdd并利用org.apache.axis.client.AdminClient发布，其主要工作就是把标签中的内容添加在server-config.wsdd里，所以一般直接编辑server-config.wsdd文件会更方便一些。不过当你还没有server-config.wsdd文件时，使用deploy.wsdd的方法会更方便些，因为AdminClient会帮你生成一些额外的xml元素（等等），而这些元素是必要的。

5、项目中加入Axis所需的包, web.xml加入相关定义
Apache-Axis

    Apache-Axis Servlet
    AxisServlet

        org.apache.axis.transport.http.AxisServlet


    Axis Admin Servlet
    AdminServlet

        org.apache.axis.transport.http.AdminServlet

    100

    AxisServlet
    /services/*

通过http://localhost:8080/websms/services/SendSms?wsdl来查看WSDL描述了

6、测试代码
public static void main(String[] args) {
  try{
/*ISendSmsService service = new ISendSmsServiceLocator();
   ISendSms sender = service.getSendSms();
   String result = sender.send("cid","cname");
   System.out.println("call result:"+result);*/
   String tvServiceURL = "http://localhost:8080/websms/services/SendSms"; //web service 地址
   java.net.URL endpointURL = new java.net.URL(tvServiceURL);
   String result = "ok";
   result = new SendSmsSoapBindingStub(endpointURL,null).send("id","cname");
   System.out.println("call result:"+result);
  }
  catch(Exception ex){
   ex.printStackTrace();
  }
}

我们还可以通过IE浏览器直接调用服务，方法是在服务URL后加“method=xxx”，其中xxx是要调用的方法名称。例如可以通过http://localhost:8080/websms/services/SendSms?method=send&userId=uid&...调用方法。
====================================================================================
另外, 也可能过新建一个deploy.wsdd文件，通过这个文件直接布署我们的服务
java -Djava.ext.dirs=lib org.apache.axis.client.AdminClient -lhttp://localhost:8080/websms/services/SendSms deploy.wsdd
// 它会在WEB-INF目录生成server-config.wsdd文件, 若此文件已存在, 它会在文件加入当前服务的注册。

生成wsdl文件
java -Djava.ext.dirs=../lib org.apache.axis.wsdl.Java2WSDL -oSendSms.wsdl -lhttp://localhost:8080/websms/services/SendSms -nsendsms sample.webservice.SendSms

生成客户端文件
java -Djava.ext.dirs=../lib org.apache.axis.wsdl.WSDL2Java SendSms.wsdl -p client

***************************************************************************************
org.apache.axis.wsdl.Java2WSDL 中的命令解释
-o ：生成的WSDL文件
-l ：Web服务的位置
-n ：WSDL文件的名字空间
-p ：包到名字空间的映射

***************************************************************************************

java org.apache.axis.wsdl.WSDL2Java -o . -d Session -s -S true

-Nurn:BookServletService com.hellking.webservice.servlet temp.wsdl

使用这个命令后将生成以下文件：

BookServiceInterface.java：新的BookServiceInterface接口，它扩展了java.rmi.Remote接口；

BookServiceInterfaceService.java：客户端服务接口，用来获得BookServiceInterface对象的引用；

BookServiceInterfaceServiceLocator.java：在客户端使用，主要用来服务定位；

BookServletServiceSoapBindingImpl.java：服务端实现类，它实现了BookServiceInterface接口，服务端的业务方法实现代码就在这里编写；

BookServletServiceSoapBindingSkeleton.java：服务端Skeleton；

BookServletServiceSoapBindingStub.java：客户端Stub；

BookVO.java：新的BookVO序列化对象；

deploy.wsdd：部署这个Web服务的脚本；

undeploy.wsdd：卸载这个Web服务的脚本。

SIMONE 2006-03-30 12:55 发表评论

axis 开发 web service 实战

SIMONE — Thu, 30 Mar 2006 04:54:00 GMT

一、axis安装
1.环境
  J2SE SDK 1.3 or 1.4:  我使用 1.4.2
   Servlet Container: 我使用Tomcat 5.0
2.到 http://ws.apache.org/axis/网站下载axis安装包
3.解压缩安装包，将AXIS_UNZIP_PATH\axis-version\webapps下的axis包拷贝到TOMCAT_HOME\webapps\下，
    以下约定AXIS_HOME为该TOMCAT_HOME\webapps\axis目录
4.启动tomcat,访问http://localhost:8080/axis 检查安装是否成功
5.以上步骤执行成功，可以开发webservice例子了

axis支持三种web service的部署和开发，分别为：
1。Dynamic Invocation Interface ( DII)
2。 Stubs方式
3。Dynamic Proxy方式

以下逐一讲述web service在axis上的部署和开发，设置classpath
set CLASSPATH=.;%AXIS_HOME%\lib\axis.jar;%AXIS_HOME%\lib\axis-ant.jar;%AXIS_HOME%\lib\commons-discovery-0.2.jar;%AXIS_HOME%\lib\commons-logging-1.0.4.jar;%AXIS_HOME%\lib\jaxrpc.jar;%AXIS_HOME%\lib\saaj.jar;%AXIS_HOME%\lib\wsdl4j-1.5.1.jar;%AXIS_HOME%\lib\log4j-1.2.8.jar;E:/thirdparty/activation/activation.jar;E:/thirdparty/activation/mail.jar

二、编写DII(Dynamic Invocation Interface )方式web服务
1.编写服务端程序HelloClient
public class HelloClient {
    public String getName(String name)
    {
        return "hello "+name;
    }
}

2.将源码拷贝到AXIS_HOME下，重命名为 HelloClient.jws
3.访问连接http://localhost:8080/axis/HelloClient.jws?wsdl，页面显示axis自动生成的wsdl
4.编写访问服务的客户端 TestHelloClient.java

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import javax.xml.namespace.QName;
import javax.xml.rpc.ServiceException;
import java.net.MalformedURLException;
import java.rmi.RemoteException;

public class SayHelloClient2 {
    public static void main(String[] args) {
        try {
            String endpoint = "http://localhost:8080/axis/HelloClient.jws";

            Service service = new Service();
            Call call = null;

            call = (Call) service.createCall();

            call.setOperationName(new QName(
                    "http://localhost:8080/axis/HelloClient.jws", "getName"));
            call.setTargetEndpointAddress(new java.net.URL(endpoint));

            String ret = (String) call.invoke(new Object[] {"zhangsan"});
            System.out.println("return value is " + ret);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}
三、编写Dynamic Proxy方式访问服务
1.编写部署服务端程序，同上边DII方式，本次仍使用上边部署的HelloClient
2.编写代理接口
public interface HelloClientInterface extends java.rmi.Remote {
    public String getName(String name) throws java.rmi.RemoteException;
}
3.编写并执行客户端程序TestHelloClient.java

import javax.xml.rpc.Service;
import javax.xml.rpc.ServiceFactory;
import java.net.URL;
import javax.xml.namespace.QName;

public class TestHelloClient {
    public static void main(String[] args) {
        try
        {
            String wsdlUrl = "http://localhost:8080/axis/HelloClient.jws?wsdl";
            String nameSpaceUri = "http://localhost:8080/axis/HelloClient.jws";
            String serviceName = "HelloClientService";
            String portName = "HelloClient";

            ServiceFactory serviceFactory = ServiceFactory.newInstance();
            Service afService = serviceFactory.createService(new URL(wsdlUrl),
                    new QName(nameSpaceUri, serviceName));
            HelloClientInterface proxy = (HelloClientInterface)
                                           afService.getPort(new QName(
                    nameSpaceUri, portName), HelloClientInterface.class);
            System.out.println("return value is "+proxy.getName("john") ) ;
        }catch(Exception ex)
        {
            ex.printStackTrace() ;
        }
    }
}

四、编写wsdd发布web服务，编写stub client访问web服务

1.编写服务端程序server,SayHello.java，编译server.SayHello.java
package server;
public class SayHello {
    public String getName(String name)
    {
        return "hello "+name;
    }
}
2.编写LogHandler.java
import org.apache.axis.AxisFault;
import org.apache.axis.Handler;
import org.apache.axis.MessageContext;
import org.apache.axis.handlers.BasicHandler;

import java.util.Date;

public class LogHandler extends BasicHandler {
    public void invoke(MessageContext msgContext) throws AxisFault
    {
        /** Log an access each time we get invoked.
         */
        try {
            Handler serviceHandler = msgContext.getService();

            Integer numAccesses =
                             (Integer)serviceHandler.getOption("accesses");
            if (numAccesses == null)
                numAccesses = new Integer(0);

            numAccesses = new Integer(numAccesses.intValue() + 1);

            Date date = new Date();
            String result = date + ": service " +
                            msgContext.getTargetService() +
                            " accessed " + numAccesses + " time(s).";
            serviceHandler.setOption("accesses", numAccesses);

            System.out.println(result);
        } catch (Exception e) {
            throw AxisFault.makeFault(e);
        }
    }
}
3..编写wsdd文件
deploy.wsdd
            xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">









3.将编译后的文件拷贝到AXIS_HOME/WEB-INF/classes下，如：D:\tomcat\webapps\axis\WEB-INF\classes
4.发布服务：
java org.apache.axis.client.AdminClient deploy.wsdd
5.生成client stub文件
   a:方式1
      将SayHello.java拷贝到AXIS_HOME/下，重命名为SayHello.jws，执行下面的命令生存client stub
      java org.apache.axis.wsdl.WSDL2Java  -p client  http://localhost:8080/axis/services/SayHello.jws?wsdl
    b:方式2
    执行如下命令生成SayHello.wsdl
         java org.apache.axis.wsdl.Java2WSDL -oSayHello.wsdl -lhttp://localhost:8080/axis/services/SayHello -nsayhello server.SayHello
          执行如下命令生成client stub
      java org.apache.axis.wsdl.WSDL2Java  SayHello.wsdl  -p client
   生成的stub client文件列表为：
   1。SayHello.java
   2。SayHelloService.java。
   3。SayHelloServiceLocator.java
   4。SayHelloSoapBindingStub.java
6.编写客户端程序，编译并执行
public class SayHelloClient {
    public static void main(String[] args) {
        try {

            SayHelloService service = new client.
                                               SayHelloServiceLocator();
            client.SayHello_PortType client = service.getSayHello();
            String retValue=client.getName("zhangsan");
            System.out.println(retValue);


        } catch (Exception e) {
            System.err.println("Execution failed. Exception: " + e);
        }
    }
}

SIMONE 2006-03-30 12:54 发表评论