AXIS2 学习总结(1)

AXIS2 学习总结

经过对AXIS2 1.1 和 1.2的研究没有发现这两个版本的不同之处，不过真正的部署成功是在1.2版本中。

学习AXIS2需要了解的一些基础知识如下：

什么是WEB SERVICE,SOAP,WSDL,UDDI。
简单地说，Web Services 是一种基于组件的软件平台,是面向服务的Internet 应用。Web Services 是应用于Internet 的,而不是限于局域网或试验环境。这要求提出的Web Services 框架必须适用于现有的Internet 软件和硬件环境,即服务的提供者所提供的服务必须具有跨平台、跨语言的特性。其次,Web Services 所提供的服务不仅是向人,更需服务于其它应用系统。现有的Web网站也可以认为是面向服务的,但这种服务仅仅可以提供给人使用(只有人类才可以读懂浏览器下载的页面) 。而新一代的Web Services 所提供的服务应能被机器所读懂,例如其它应用程序及移动设备中的软件系统。这样,我们可以看出,Web Services 的发展方向实际上是构造一个在现有Internet 技术上的分布计算系统。Web Services 框架的核心技术包括SOAP ,WSDL 和UDDI ,它们都是以标准的XML 文档的形式表的。SOAP 是Web services 的通信协议。SOAP是一种简单的、轻量级的基于XML 的机制，用于在网络应用程序之间进行结构化数据交换。SOAP包括三部分:一个定义描述消息内容的框架的信封，一组表示应用程序定义的数据类型实例的编码规则，以及表示远程过程调用和响应的约定。WSDL表示WEB服务说明语言。WSDL文件是一个XML 文档，用于说明一组SOAP消息以及如何交换这些消息。UDDI(统一描述发现和集成) 提供一种发布和查找服务描述的方法。UDDI 数据实体提供对定义业务和服务信息的支持。WSDL 中定义的服务描述信息是UDDI注册中心信息的补充。Web Services 服务提供方通过WSDL(Web Services Description Language) 描述所提供的服务,并将这一描述告知Web Services 注册服务器。注册服务器依据WSDL 的描述,依照UDDI (Universal Description Discovery and Integration) 的协定更新服务目录并在Internet 上发布。用户在使用Web Services 前先向注册服务器发出请求,获得Web Services 提供者的地址和服务接口信息,之后使用SOAP 协议(Simple Object Access Protocol) 与Web Services 提供者建立连接,进行通信。Web Services 的技术主要建立在XML 的规范之上,这保证了这一体系结构的平台无关性、语言无关性和人机交互性能。SOAP：简单对象访问协议。这是一种在松散的、分布的环境中使用XML对等地交换结构化的和类型化的信息提供了一个简单且轻量级的机制，它是一个基于XML的协议。它包括四个部分：SOAP封装（envelop），封装定义了一个描述消息中的内容是什么，是谁发送的，谁应当接受并处理它以及如何处理它们的框架；SOAP编码规则（encoding rules），用于表示应用程序需要使用的数据类型的实例; SOAP RPC表示(RPC representation)，表示远程过程调用和应答的协定;SOAP绑定（binding），使用底层协议交换信息。 虽然这四个部分都作为SOAP的一部分，作为一个整体定义的，但他们在功能上是相交的、彼此独立的。特别的，信封和编码规则是被定义在不同的XML命名空间(namespace)中，这样使得定义更加简单。SOAP的主要设计目标是简明性和可扩展性。这就意味着有一些传统消息系统或分布式对象系统中的特性将不包含在SOAP的核心规范中。这些特性包括：分布式垃圾收集；批量消息传输/处理；对象引用；对象激活。 WSDL：Web Service描述语言。使用了WSDL，我们就可以通过这种跨平台和跨语言的方法使Web Service代理的产生自动化。就像COM和CORBA的IDL文件，WSDL文件由客户和服务器约定。由于WSDL设计成可以绑定除SOAP以外的其他协议，这里我们主要关注WSDL在HTTP上和SOAP的关系。同样，由于SOAP目前主要用来调用远程的过程和函数，WSDL支持SOAP传输的文档规范。WSDL文档可以分为两部分。顶部分由抽象定义组成，而底部分则由具体描述组成。抽象部分以独立于平台和语言的方式定义SOAP消息，它们并不包含任何随机器或语言而变的元素。这就定义了一系列服务，截然不同的网站都可以实现。

XML Web Service 基础

摘要： 本文概述了 XML Web Service 对于开发人员的价值，同时还介绍了 SOAP、WSDL 和 UDDI。
 
什么是 XML Web Service？ 　　
XML Web Service 是在 Internet 上进行分布式计算的基本构造块。开放的标准以及对用户和应用程序之间的通信和协作的关注产生了这样一种环境，在这种环境下，XML Web Service 成为应用程序集成的平台。应用程序是通过使用多个不同来源的 XML Web Service 构造而成的，这些服务相互协同工作，而不管它们位于何处或者如何实现。
有多少个构建 XML Web Service 的公司，就可能有多少种 XML Web Service 定义。不过几乎所有定义都具有以下共同点： 　　
XML Web Service 通过标准的 Web 协议向 Web 用户提供有用的功能。多数情况下使用 SOAP 协议。 　　
XML Web Service 可以非常详细地说明其接口，这使用户能够创建客户端应用程序与它们进行通信。这种说明通常包含在称为 Web 服务说明语言 (WSDL) 文档的 XML 文档中。 　　
XML Web Service 已经过注册，以便潜在用户能够轻易地找到这些服务，这是通过通用发现、说明和集成 (UDDI) 来完成的。 　　

本文将介绍这三种技术，但首先需要解释一下为什么要关注 XML Web Service。XML Web Service 体系结构的主要优点之一是：允许在不同平台上、以不同语言编写的各种程序以基于标准的方式相互通信。对这一行业有所了解的用户可能马上会说：“等一等，CORBA 和之前的 DCE 不是都做过相同的承诺吗？这和它们有什么区别？”最重要的区别在于：SOAP 比以前的方法要简单得多，因此要实现与标准兼容的 SOAP，障碍也要少得多。Paul Kulchenko 在 http://www.soapware.org/directory/4/implementations（英文）上提供了一个 SOAP 实现方案的列表。上次统计时，该列表已经包含了 79 项。正如您所预料，多数大的软件公司都提供 SOAP 实现方案，但也有许多实现方案是由个别开发人员创建和维护的。相对以前的方案而言，XML Web Service 的另一大优点是使用标准的 Web 协议 - XML、HTTP 和 TCP/IP。许多公司都已经建立了 Web 基础结构，同时它们的员工在维护方面也都具备相应的知识和经验。因此，引入 XML Web Service 与引入以前的技术相比，其成本要低得多。我们将 XML Web Service 定义为：通过 SOAP 在 Web 上提供的软件服务，使用 WSDL 文件进行说明，并通过 UDDI 进行注册。那么，您也许要问：“使用 XML Web Service 能够做什么？”最初的 XML Web Service 通常是可以方便地并入应用程序的信息来源，如股票价格、天气预报、体育成绩等等。我们很容易想到，可以构建一整类应用程序以分析和汇总所关心的信息，并以各种方式提供这些信息；例如，您可以使用 Microsoft? Excel 电子表格来汇总所有的财务信息 - 股票、401K、银行存款、贷款等等。如果能够通过 XML Web Service 获得这些信息，Excel 就可以不断对其进行更新。这些信息中有些是免费的，有些则可能需要订阅才能获得相应服务。大部分这种信息现在已经可以在 Web 上找到了，但是 XML Web Service 可以使编程访问更简单，也更可靠。以 XML Web Service 方式提供现有应用程序，可以构建新的、更强大的应用程序，并利用 XML Web Service 作为构造块。例如，用户可以开发一个采购应用程序，以自动获取来自不同供应商的价格信息，从而使用户可以选择供应商，提交订单，然后跟踪货物的运输，直至收到货物。而供应商的应用程序除了在 Web 上提供服务外，还可以使用 XML Web Service 检查客户的信用、收取货款，并与货运公司办理货运手续。 将来，某些最有趣的 XML Web Service 所支持的应用程序还可以利用 Web 完成目前无法完成的任务。例如，日历服务就是 Microsoft .NET My Services（英文）项目即将支持的服务之一。如果您的牙医和机械师通过这一 XML Web Service 提供其日程安排，您就可以通过网络与他们安排约会；如果您愿意，他们也可以直接在您的日历上约定清洁和日常保养的日期。不难想象，只要能够对 Web 进行编程，您就可以创建数以百计的应用程序。有关 XML Web Service 及其可以构建的应用程序的详细信息，请参阅 MSDN Web 服务（英文）主页。

SOAP
　　
Soap 是 XML Web Service 的通信协议。当把 SOAP 描述为一种通信协议时，多数人都会想到 DCOM 或 CORBA，并且会问“SOAP 如何激活对象？”或“SOAP 使用什么样的命名服务？”等问题。虽然 SOAP 实现方案可能会包含上述内容，但 SOAP 标准并未对其进行规定。SOAP 一种规范，用来定义消息的 XML 格式 - 这是规范中所必需的部分。包含在一对 SOAP 元素中的、结构正确的 XML 段就是 SOAP 消息。这是不是很简单？ 　　SOAP 规范的其他部分介绍如何将程序数据表示为 XML，以及如何使用 SOAP 进行远程过程调用 (RPC)。这些可选的规范部分用于实现 RPC 形式的应用程序，其中客户端将发出一条 SOAP 消息（包含可调用函数，以及要传送到该函数的参数），然后服务器将返回包含函数执行结果的消息。目前，多数 SOAP 实现方案都支持 RPC 应用程序，这是因为习惯于开发 COM 或 CORBA 应用程序的编程人员熟悉 RPC 形式。SOAP 还支持文档形式的应用程序，在这类应用程序中，SOAP 消息只是 XML 文档的一个包装。文档形式的 SOAP 应用程序非常灵活，许多新的 XML Web Service 都利用这一特点来构建使用 RPC 难以实现的服务。 　　SOAP 规范的最后一个可选部分定义了包含 SOAP 消息的 HTTP 消息的样式。此 HTTP 绑定非常重要，因为几乎所有当前的 OS（以及许多以前的 OS）都支持 HTTP。HTTP 绑定虽然是可选的，但几乎所有 SOAP 实现方案都支持 HTTP 绑定，因为它是 SOAP 的唯一标准协议。由于这一原因，人们通常误认为 SOAP 必须使用 HTTP。其实，有些实现方案也支持 MSMQ、MQ 系列、SMTP 或 TCP/IP 传输，但由于 HTTP 非常普遍，几乎所有当前的 XML Web Service 都使用它。由于 HTTP 是 Web 的核心协议，因此大多数组织的网络基础结构都支持 HTTP，并且员工已经了解了如何对其进行管理。如今，已经建立了用于 HTTP 的安全保护、监视和负载平衡的基础结构。 　　开始使用 SOAP 时，最容易混淆的是 SOAP 规范及其许多实现方案之间的差异。多数使用 SOAP 的用户并不直接编写 SOAP 消息，而是使用 SOAP 工具包来创建和分析 SOAP 消息。这些工具包通常将函数调用从某种语言转换为 SOAP 消息。例如，Microsoft SOAP Toolkit 2.0 将 COM 函数调用转换为 SOAP，而 Apache Toolkit 将 JAVA 函数调用转换为 SOAP。函数调用的类型和支持的参数的数据类型随每个 SOAP 实现方案的不同而不同，因此适用于一个工具包的函数可能并不适用于另一个工具包。这并不是 SOAP 的限制，而是所使用的特定实现方案的限制。 　　到目前为止，SOAP 最引人注目的特征是它可以在许多不同的软件和硬件平台上实现。这意味着 SOAP 可用于链接企业内部和外部的不同系统。过去曾试过多种方法以提出一个可用于系统集成的通用通信协议，但它们都没有象 SOAP 一样获得广泛的认可。为什么呢？因为与许多早期的协议相比，SOAP 更小巧，而且更易于实现。例如，DCE 和 CORBA 的实现需要数年时间，所以只发布了很少几个实现方案。而 SOAP 可以利用现有的 XML 分析器和 HTTP 库完成大部分艰苦的工作，因此 SOAP 实现方案在数月内便可完成。这就是为什么现在已经有 70 多个 SOAP 实现方案的原因。当然，SOAP 并不具备 DCE 或 CORBA 的全部功能，虽然功能减少了，但由于其复杂程度大大降低了，因此 SOAP 更易于应用。 　　HTTP 的普及和 SOAP 的简单性使您几乎可以从任何环境调用它们，因此成为 XML Web Service 的理想基础。有关 SOAP 的详细信息，请参阅 MSDN SOAP（英文）主页。
安全性如何？ 　　
通常，刚接触 SOAP 的用户提出的第一个问题就是 SOAP 如何解决安全性问题。在其早期开发阶段，SOAP 被看作是基于 HTTP 的协议，所以认为 HTTP 的安全性对于 SOAP 已经足够了。毕竟目前有数以千计的 Web 应用程序都在使用 HTTP 安全性，所以这对于 SOAP 确实已经足够。因此，当前的 SOAP 标准假定安全性属于传输问题，而并不作为安全性问题处理。 　　当 SOAP 扩展至更为通用的协议，并运行于众多传输之上时，安全性问题就变得突出了。例如，HTTP 提供若干种方法对进行 SOAP 调用的用户进行身份验证，但是当消息从 HTTP 路由到 SMTP 传输时，怎样传播该身份标识呢？SOAP 是作为构造块协议进行设计的，所以幸运的是，已经有了相应的规范以基于 SOAP 为 Web 服务提供额外的安全保护功能。WS-Security 规范（英文）定义了一套完整的加密系统，而 WS-License 规范（英文）定义了相应的技术，以保证调用者的身份标识，并确保只有授权用户才可以使用 Web 服务。 WSDL 　　WSDL (Web Services Description Language) 表示 Web 服务说明语言。在本文中，我们可以认为 WSDL 文件是一个 XML 文档，用于说明一组 SOAP 消息以及如何交换这些消息。换句话说，WSDL 对于 SOAP 的作用就象 IDL 对于 CORBA 或 COM 的作用。由于 WSDL 是 XML 文档，因此很容易进行阅读和编辑；但大多数情况下，它由软件生成和使用。 　　要查看 WSDL 的值，可以假设您要调用由您的一位业务伙伴提供的 SOAP 方法。您可以要求对方提供一些 SOAP 消息示例，然后编写您的应用程序以生成并使用与示例类似的消息，但这样很容易出错。例如，您可能看到一个 2837 的客户 ID，并假设它为整数，而实际上它是一个字符串。WSDL 通过明确的表示法指定请求消息必须包含的内容以及响应消息的样式。 　　WSDL 文件用于说明消息格式的表示法以 XML 架构标准为基础，这意味着它与编程语言无关，而且以标准为基础，因此适用于说明可从不同平台、以不同编程语言访问的 XML Web Service 接口。除说明消息内容外，WSDL 还定义了服务的位置，以及使用什么通信协议与服务进行通信。也就是说，WSDL 文件定义了编写使用 XML Web Service 的程序所需的全部内容。有几种工具可以读取 WSDL 文件，并生成与 XML Web Service 通信所需的代码。其中一些最强大的工具可在 Microsoft Visual Studio? .NET 中找到。 　　当前，许多 SOAP 工具包都包括从现有程序接口生成 WSDL 文件的工具，但却几乎没有直接用于编写 WSDL 的工具，而且 WSDL 的工具支持也很不完整。但不久就会出现编写 WSDL 文件的工具，接着还会有生成代理和存根的工具（与 COM IDL 工具很相似），这些工具将成为多数 SOAP 实现方案的一部分。到那时，WSDL 将成为创建 XML Web Service 的 SOAP 接口的首选方法。 　　这里有一个非常好的 WSDL 说明（英文），您还可以在 http://www.w3.org/TR/wsdl（英文）找到 WSDL 规范。

UDDI 　　

通用发现、说明和集成 (UDDI) 是 Web 服务的黄页。与传统黄页一样，您可以搜索提供所需服务的公司，阅读以了解所提供的服务，然后与某人联系以获得更多信息。当然，您也可以提供 Web 服务而不在 UDDI 中注册，就象在地下室开展业务，依靠的是口头吆喝；但是如果您希望拓展市场，则需要 UDDI 以便能被客户发现。 UDDI 目录条目是介绍所提供的业务和服务的 XML 文件。UDDI 目录条目包括三个部分。“白页”介绍提供服务的公司：名称、地址、联系方式等等；“黄页”包括基于标准分类法（例如 North American Industry Classification System 和 Standard Industrial Classification）的行业类别；“绿页”详细介绍了访问服务的接口，以便用户能够编写应用程序以使用 Web 服务。服务的定义是通过一个称为类型模型（或 tModel）的 UDDI 文档来完成的。多数情况下，tModel 包含一个 WSDL 文件，用于说明访问 XML Web Service 的 SOAP 接口，但是 tModel 非常灵活，可以说明几乎所有类型的服务。 　　UDDI 目录还包含若干种方法，可用于搜索构建您的应用程序所需的服务。例如，您可以搜索特定地理位置的服务提供商或者搜索特定的业务类型。之后，UDDI 目录将提供信息、联系方式、链接和技术数据，以便您确定能满足需要的服务。 　　UDDI 允许您查找提供所需的 Web 服务的公司。如果您已经知道要与谁进行业务合作，但尚不了解它还能提供哪些服务，这时该如何处理呢？WS-Inspection 规范（英文）允许您浏览特定服务器上提供的 XML Web Service 的集合，从中查找所需的服务。 其他内容 　　到现在为止，我们已经讨论了如何与 XML Web Service 通信 (SOAP)，XML Web Service 是怎样进行说明的 (WSDL)，以及如何查找 XML Web Service (UDDI)。这些内容构成了一套基本规范，为应用程序的集成和聚合提供了基础。根据这些基本规范，公司可以构建实际的解决方案，并从中获益。 　　为实现 XML Web Service，我们已经做了许多工作，但仍有大量工作需要完成。今天，人们已经使用 XML Web Service 取得了成功，但对于开发人员来说，仍有许多环节需要完善。例如，安全性、运营管理、事务处理以及可靠的消息传递等。Global XML Web Services Architecture 将通过以下方式帮助 XML Web Service 进入下一个发展阶段：提供一个一致的通用模型，以模块化和可扩展的方式向 XML Web Service 添加新的高级功能。 　　上面提到的安全模块（WS-Security [英文] 和 WS-License [英文]）就是 Global Web Services Architecture 规范的一部分。运营管理的需要（例如在多个服务器之间路由消息，以及动态配置这些服务器以便进行处理）也是 Global Web Services Architecture 的一部分，它们是通过 WS-Routing 规范（英文）和 WS-Referral 规范（英文）来实现的。随着 Global Web Services Architecture 的发展，还将进一步介绍满足上述需要以及其他需要的规范。

下面开始AXIS2之旅，AXIS2简单地说就是一个Web应用程序（依赖Tomcat之类的容器构建应用），也可以理解成是一个web容器(服务部署在webapps\axis2.1.2\WEB-INF\services目录下，相当于Tomcat的webapps)，它实现了web service。

在页面http://ws.apache.org/axis2/download.cgi下有已经发布的各个版本，如下载地址http://ws.apache.org/axis2/download/1_1/download.cgi，找到Standard Binary Distribution，下载标准版有例子，简单的例子位于\samples\userguide\src\userguide\example1，编译MyService.java，需要导入Standard Binary Distribution/lib下的jar。编译后打包成MyService.aar，目录为，类包含在包所在的文件夹里，可根据services.xml查看类所在的文件夹，services.xml包含在META-INF文件夹里，这样就构造了一个简单的服务端。在下载页找到WAR (Web Archive) Distribution部署到Tomcat下，
目录如下：
axis2-web
META-INF
WEB-INF
    classes
    conf
        axis2.xml
    lib
        activation.jar
        ...
        xmlSchema.jar
    modules
        modules.list
        addressing.mar
        ...
        soapmonitor.mar
    services
        services.list
        aservice.aar
        ...
        version.aar
    web.xml
将MyService.aar拷贝到webapps\axis2\WEB-INF\services文件夹里，启动Tomcat发布成功。-------建立起服务端，可以通过两种方式来创建 web services，上述为第一种方式1.使用 Axis2 的 API ，实现业务代码；第2种方式为.从 WSDL 开始，生成代码框架，然后实现业务逻辑。首先要写好服务的 wsdl，然后利用 WSDL2Java 工具，
该工具的命令有：
Usage WSDL2Code -uri <location of="" wsdl=""></location>: WSDL file location
-o <output location=""></output>: output file location
-a : Generate async style code only. Default is off
-s : Generate sync style code only. Default is off. takes precedence over -a
-p <package name=""></package> : set custom package name
-l <language></language>: valid languages are java and csharp. Default is java
-t : Generate TestCase to test the generated code
-ss : Generate server side code (i.e. skeletons). Default is off
-sd : Generate service descriptor (i.e. services.xml). Default is off. Valid with -ss
-d <databinding></databinding>: valid databinding(s) are adb, xmlbeans and jaxme. Default is adb
-g Generates all the classes. valid only with the -ss
-pn <port_name></port_name> : name of port in the presence of multiple ports
-sn <service_name></service_name>: name of service in the presence of multiple services
-u : unpacks the databinding classes
-r <repository_path></repository_path>: path of the repository against which code is generated
 
在 windows 平台下可以用
WSDL2Java -uri ..\samples\wsdl\Axis2SampleDocLit.wsdl -ss -sd -d xmlbeans -o ..\samples -p org.apache.axis2.userguide
 
在 Linux 平台下可以用
WSDL2Java -uri ../samples/wsdl/Axis2SampleDocLit.wsdl -ss -sd -d xmlbeans -o ../samples -p org.apache.axis2.userguide
于是生成了服务的代码框架，在代码框架中填入代码

创建服务客户端
因为服务各种各样，有的简单、时间消耗低，有的复杂、时间消耗高，因此不能采用一个统一的机制来调用这些时间消耗差别很大的服务。
两种机制：
Blocking API:        当服务调用请求发出后，客户端等待服务结果的返回，这期间不能再发出服务调用请求。
Non-Blocking API:    这是一个基于 callback 或者 polling 的 API ，让客户端发出服务调用请求的时候，客户端程序立刻得到控制权，服务的调用结果由 callback 对象来接收。这样，客户端就可以同时调用多个服务而不进行阻止。

WSDL工具
你可以手工创建WSDL文件，不过，你还可以采用相当多的工具通过WSDL来为你自动处理和定义Web服务。推荐工具软件如下：
Omniopera-一图形用户界面的WSDL、XML和XSD编辑器
Microsoft的SOAP Toolkit-一种工具包，其中包括根据WSDL定义创建COM接口的向导程序，还包括根据COM接口创建WSDL的向导程序
IBM的Web Services Toolkit-一种工具包，其中包括产生WSDL和SOAP部署说明的向导程序

AXIS2.1.2中学习到的如下：

Axis2 is a slick and robust way to get web services up and running in no time. This guide presented five methods of creating a service deployable on Axis2, and four methods of creating a client to communicate with the services. You now have the flexibility to create Web services using a variety of different technologies.

Creating services

有这样的一个服务类The StockQuoteService class

package samples.quickstart.service.pojo;
import java.util.HashMap;
public class StockQuoteService {
    private HashMap map = new HashMap();

    public double getPrice(String symbol) {            //in-only
        Double price = (Double) map.get(symbol);
        if(price != null){
            return price.doubleValue();
        }
        return 42.00;
    }

    public void update(String symbol, double price) {   //in-out
        map.put(symbol, new Double(price));
    }
}

Wait for Getting Ready
Before we build anything using Axis2, we have to take care of a little housekeeping. First off, you'll need to get your environment ready for working with Axis2. Fortunately, it involves just a few simple steps:

Download and install Java. (Minimum version is JDK1.4)
Download Axis2 and extract it to a target directory.
Copy the axis2.war file to the webapps directory of your servlet engine.
Set the AXIS2_HOME environment variable to point to the target directory in step. Note that all of the scripts and build files Axis2 generates depend on this value, so don't skip this step!
In most cases, we're also going to need a WSDL file for our service. Axis2's Java2WSDL can be used to bootstrap a WSDL. To generate a WSDL file from a Java class, perform the following steps:

Create and compile the Java class.
Generate the WSDL using the command:
%AXIS2_HOME%/bin/java2wsdl -cp . -cn samples.quickstart.service.pojo.StockQuoteService -of StockQuoteService.wsdlOnce you've generated the WSDL file, you can make the changes you need. For example, you might add custom faults or change the name of the generated elements. For example, this StockQuoteService.wsdl is in %AXIS2_HOME%/samples/quickstartadb/resources/META-INF folder, which we'll be using throughout the rest of this guide, replaces the generic parameters created by the generation process.

---------------------五个创建服务端、四个创建客户端的方式-------------------------
 
Deploying POJOs

服务类无需修改，如上
services.xml如下
<service name="StockQuoteService" scope="application" targetnamespace="http://quickstart.samples/"></service>
    <description></description>
        Stock Quote Service
   
    <messagereceivers></messagereceivers>
        <messagereceiver mep="http://www.w3.org/2004/08/wsdl/in-only"></messagereceiver>                         class="org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver"/>
        <messagereceiver mep="http://www.w3.org/2004/08/wsdl/in-out"></messagereceiver>                         class="org.apache.axis2.rpc.receivers.RPCMessageReceiver"/>
   
    <schema schemanamespace="http://quickstart.samples/xsd"></schema>
    <parameter name="ServiceClass"></parameter> samples.quickstart.service.pojo.StockQuoteService

注：欲调用的服务的方法名不明确，无法得知。
将服务类和services.xml按规范打包成StockQuoteService.aar（可利用eclipse的export功能）
Then check to make sure that the service has been properly deployed by viewing the list of services at:
http://localhost:8080/axis2/services/listServices

You can also checkout the WSDL at:
http://localhost:8080/axis2/services/StockQuoteService?wsdl

And the schema at:
http://localhost:8080/axis2/services/StockQuoteService?xsd

Once the URLs are working, quickly test the service. Try pointing your browser to the following URL:
http://localhost:8080/axis2/services/StockQuoteService/getPrice?symbol=IBM

You will get the following response:
<ns:getpriceresponse xmlns:ns="http://pojo.service.quickstart.samples/xsd"><ns:return>42</ns:return></ns:getpriceresponse>

If you invoke the update method as,
http://localhost:8080/axis2/services/StockQuoteService/update?symbol=IBM&price=100and then execute the first getPrice URL, you will see that the price has got updated.

Building the service using AXIOM
 
services.xml修改如下
<service name="StockQuoteService" scope="application"></service>
    <description></description>
        Stock Quote Service
   
    <operation name="getPrice"></operation>
        <messagereceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"></messagereceiver>
   
    <operation name="update"></operation>
        <messagereceiver class="org.apache.axis2.receivers.RawXMLINOnlyMessageReceiver"></messagereceiver>
   
    <parameter name="ServiceClass"></parameter> samples.quickstart.service.axiom.StockQuoteService

服务类修改如下：
The StockQuoteService Class using AXIOM

package samples.quickstart.service.axiom;

import javax.xml.stream.XMLStreamException;
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 java.util.HashMap;
public class StockQuoteService {
    private HashMap map = new HashMap();

    public OMElement getPrice(OMElement element) throws XMLStreamException {
        element.build();
        element.detach();

        OMElement symbolElement = element.getFirstElement();
        String symbol = symbolElement.getText();

        String returnText = "42";
        Double price = (Double) map.get(symbol);
        if(price != null){
            returnText  = "" + price.doubleValue();
        }
        OMFactory fac = OMAbstractFactory.getOMFactory();
        OMNamespace omNs =
            fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");
        OMElement method = fac.createOMElement("getPriceResponse", omNs);
        OMElement value = fac.createOMElement("price", omNs);
        value.addChild(fac.createOMText(value, returnText));
        method.addChild(value);
        return method;
    }

    public void update(OMElement element) throws XMLStreamException {
        element.build();
        element.detach();

        OMElement symbolElement = element.getFirstElement();
        String symbol = symbolElement.getText();

        OMElement priceElement = (OMElement)symbolElement.getNextOMSibling();
        String price = priceElement.getText();

        map.put(symbol, new Double(price));
    }
}
如上方式测试服务。

Generating the service using ADB

得先有WSDL文件然后利用如下命令生成JAVA服务：
%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.adb -d adb -s -ss -sd -ssi -o build/service

详细的步骤如下：
To generate and deploy the service using the Axis2 Databinding Framework (ADB), execute the following steps.

Generate the skeleton using the WSDL2Java utility by typing the following in the Axis2_HOME/samples/quickstartadb directory:

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.adb -d adb -s -ss -sd -ssi -o build/service

Else, simply type ant generate.service in the Axis2_HOME/samples/quickstartadb directory.

The option -d adb specifies Axis Data Binding (ADB). The -s switch specifies synchronous or blocking calls only. The -ss switch creates the server side code (skeleton and related files). The -sd switch creates a service descriptor (services.xml file). The -ssi switch creates an interface for the service skeleton. The service files should now be located at build/service.

If you generated the code by using WSDL2Java directly, next you have to modify the generated skeleton to implement the service (if you used "ant generate.service", a completed skeleton will be copied over the generated one automatically).

Open the build/service/src/samples/quickstart/adb/service/StockQuoteServiceSkeleton.java file and modify it to add the functionality of your service to the generated methods; shown in Code Listing 6.

Defining the Service Skeleton File

package samples.quickstart.service.adb;

import samples.quickstart.service.adb.xsd.GetPriceResponse;
import samples.quickstart.service.adb.xsd.Update;
import samples.quickstart.service.adb.xsd.GetPrice;

import java.util.HashMap;

public class StockQuoteServiceSkeleton {

    private static HashMap map;

    static{ map = new HashMap(); }

    public void update(Update param0) {
        map.put(param0.getSymbol(), new Double(param0.getPrice()));
    }

    public GetPriceResponse getPrice(GetPrice param1) {
        Double price = (Double) map.get(param1.getSymbol());
        double ret = 42;
        if(price != null){
            ret = price.doubleValue();
        }
        GetPriceResponse res =
                new GetPriceResponse();
        res.set_return(ret);
        return res;
    }
}

Now you can build the project by typing the following command in the build/service directory:

ant jar.server

If all goes well, you should see the BUILD SUCCESSFUL message in your window, and the StockQuoteService.aar file in the build/service/build/lib directory. Copy this file to the webapps/axis2/WEB-INF/services directory of the servlet engine.

You can check to make sure that the service has been properly deployed by viewing the list of services at,
http://localhost:8080/axis2/services/listServices

You can also check the custom WSDL at,
http://localhost:8080/axis2/services/StockQuoteService?wsdl

and the schema at,
http://localhost:8080/axis2/services/StockQuoteService?xsd
 
Generating the service using XMLBeans

得先有WSDL文件然后利用如下命令生成JAVA服务：
%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.xmlbeans -d xmlbeans -s -ss -sd -ssi -o build/service

详细的步骤如下：
To generate a service using XMLBeans, execute the following steps.

Generate the skeleton using the WSDL2Java utility by typing the following in the Axis2_HOME/samples/quickstartxmlbeans directory.

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.xmlbeans -d xmlbeans -s -ss -sd -ssi -o build/service

Else simply type ant generate.service in the Axis2_HOME/samples/quickstartxmlbeans directory.

The option -d xmlbeans specifies XML Beans data binding. The -s switch specifies synchronous or blocking calls only. The -ss switch creates the server side code (skeleton and related files). The -sd switch creates a service descriptor (services.xml file). The -ssi switch creates an interface for the service skeleton. The service files should now be located at build/service.

If you generated the code by using WSDL2Java directly, next you have to modify the generated skeleton to implement the service (if you used "ant generate.service", a completed skeleton will be copied over the generated one automatically).

Next open the build/service/src/samples/quickstart/service/xmlbeans/StockQuoteServiceSkeleton.java file and modify it to add the functionality of your service to the generated methods (see Code Listing 7).

Code Listing 7: Defining the Service Skeleton

package samples.quickstart.service.xmlbeans;

import samples.quickstart.service.xmlbeans.xsd.GetPriceDocument;
import samples.quickstart.service.xmlbeans.xsd.GetPriceResponseDocument;
import samples.quickstart.service.xmlbeans.xsd.UpdateDocument;

import java.util.HashMap;

public class StockQuoteServiceSkeleton implements StockQuoteServiceSkeletonInterface {

    private static HashMap map;

    static{ map = new HashMap(); }

    public void update(UpdateDocument param0) {        map.put(param0.getUpdate().getSymbol(), new Double(param0.getUpdate().getPrice()));
    }

    public GetPriceResponseDocument getPrice(GetPriceDocument param1) {        Double price = (Double) map.get(param1.getGetPrice().getSymbol());
        double ret = 42;
        if(price != null){
            ret = price.doubleValue();
        }
        System.err.println();
        GetPriceResponseDocument resDoc =
                GetPriceResponseDocument.Factory.newInstance();
        GetPriceResponseDocument.GetPriceResponse res =
                resDoc.addNewGetPriceResponse();
        res.setReturn(ret);
        return resDoc;
    }
}
Build the project by typing the following command in the build/service directory, which contains the build.xml file:

ant jar.server

If all goes well, you should see the BUILD SUCCESSFUL message in your window, and the StockQuoteService.aar file in the newly created build/service/build/lib directory. Copy this file to the webapps/axis2/WEB-INF/services directory of the servlet engine.

You can check to make sure that the service has been properly deployed by viewing the list of services at,
http://localhost:8080/axis2/services/listServices

You can also check the custom WSDL at,
http://localhost:8080/axis2/services/StockQuoteService?wsdl

and the schema at,
http://localhost:8080/axis2/services/StockQuoteService?xsd

Generating the service using JiBX

得先有WSDL文件然后利用如下命令生成JAVA服务：
%AXIS2_HOME%/bin/wsdl2java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.jibx -d jibx -s -ss -sd -ssi -uw -o build/service

详细的步骤如下：
To generate and deploy the service using JiBX data binding, execute the following steps.

Generate the skeleton using the WSDL2Java utility by typing the following at a console in the Axis2_HOME/samples/quickstartjibx directory:

%AXIS2_HOME%/bin/wsdl2java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.jibx -d jibx -s -ss -sd -ssi -uw -o build/service

Else, simply type "ant generate.service" in the Axis2_HOME/samples/quickstartjibx directory.

The option -d jibx specifies JiBX data binding. The -s switch specifies synchronous or blocking calls only. The -ss switch creates the server side code (skeleton and related files). The -sd switch creates a service descriptor (services.xml file). The -ssi switch creates an interface for the service skeleton. The -uw switch unwraps the parameters passed to and from the service operations in order to create a more natural programming interface.

After running WSDL2Java, the service files should be located at build/service. If you generated the code by using WSDL2Java directly, you need to modify the generated skeleton to implement the service (if you used "ant generate.service" a completed skeleton will be copied over the generated one automatically). Open the build/service/src/samples/quickstart/service/jibx/StockQuoteServiceSkeleton.java file and modify it to add the functionality of your service to the generated methods, as shown in Code Listing 8.

Code Listing 8: Defining the Service Skeleton File

package samples.quickstart.service.jibx;

import java.util.HashMap;

public class StockQuoteServiceSkeleton implements StockQuoteServiceSkeletonInterface {
    private HashMap map = new HashMap();

    public void update(String symbol, Double price) {
        map.put(symbol, price);
    }

    public Double getPrice(String symbol) {
        Double ret = (Double) map.get(symbol);
        if (ret == null) {
            ret = new Double(42.0);
        }
        return ret;
    }
}

Now you can build the project by typing the following command in the build/service directory:

ant jar.server

If all goes well, you should see the BUILD SUCCESSFUL message in your window, and the StockQuoteService.aar file in the build/service/build/lib directory. Copy this file to the webapps/axis2/WEB-INF/services directory of the servlet engine.

You can check to make sure that the service has been properly deployed by viewing the list of services at,
http://localhost:8080/axis2/services/listServices

You can also check the custom WSDL at,
http://localhost:8080/axis2/services/StockQuoteService?wsdl

and the schema at,
http://localhost:8080/axis2/services/StockQuoteService?xsd

Generating Clients

Creating a client using AXIOM

The AXIOMClient class using AXIOM

package samples.quickstart.clients;

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.axis2.Constants;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.client.ServiceClient;

public class AXIOMClient {

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

    public static OMElement getPricePayload(String symbol) {
        OMFactory fac = OMAbstractFactory.getOMFactory();
        OMNamespace omNs = fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");

        OMElement method = fac.createOMElement("getPrice", omNs);
        OMElement value = fac.createOMElement("symbol", omNs);
        value.addChild(fac.createOMText(value, symbol));
        method.addChild(value);
        return method;
    }

    public static OMElement updatePayload(String symbol, double price) {
        OMFactory fac = OMAbstractFactory.getOMFactory();
        OMNamespace omNs = fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");

        OMElement method = fac.createOMElement("update", omNs);

        OMElement value1 = fac.createOMElement("symbol", omNs);
        value1.addChild(fac.createOMText(value1, symbol));
        method.addChild(value1);

        OMElement value2 = fac.createOMElement("price", omNs);
        value2.addChild(fac.createOMText(value2,
                                         Double.toString(price)));
        method.addChild(value2);
        return method;
    }

    public static void main(String[] args) {
        try {
            OMElement getPricePayload = getPricePayload("WSO");
            OMElement updatePayload = updatePayload("WSO", 123.42);
            Options options = new Options();
            options.setTo(targetEPR);
            options.setTransportInProtocol(Constants.TRANSPORT_HTTP);

            ServiceClient sender = new ServiceClient();
            sender.setOptions(options);

            sender.fireAndForget(updatePayload);
            System.err.println("done");
            OMElement result = sender.sendReceive(getPricePayload);

            String response = result.getFirstElement().getText();
            System.err.println("Current price of WSO: " + response);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
   
}
 
Generating a client using ADB

利用工具WSDL2Java
详细的如下：
To build a client using Axis Data Binding (ADB), execute the following steps.

Generate the client databings by typing the following in the Axis2_HOME/samples/quickstartadb directory:

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.clients -d adb -s -o build/client

Else, simply type ant generate.client in the Axis2_HOME/samples/quickstartadb directory.

Next take a look at quickstartadb/src/samples/quickstart/clients/ADBClient.java, and see how it's defined in Code Listing 10.

Code Listing 10: The ADBClient Class

package samples.quickstart.clients;

import samples.quickstart.service.adb.StockQuoteServiceStub;

public class ADBClient{
    public static void main(java.lang.String args[]){
        try{
            StockQuoteServiceStub stub =
                new StockQuoteServiceStub
                ("http://localhost:8080/axis2/services/StockQuoteService");

            getPrice(stub);
            update(stub);

        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* fire and forget */
    public static void update(StockQuoteServiceStub stub){
        try{
            StockQuoteServiceStub.Update req = new StockQuoteServiceStub.Update();
            req.setSymbol ("ABC");
            req.setPrice (42.35);

            stub.update(req);
            System.err.println("done");
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* two way call/receive */
    public static void getPrice(StockQuoteServiceStub stub){
        try{
            StockQuoteServiceStub.GetPrice req = new StockQuoteServiceStub.GetPrice();

            req.setSymbol("ABC");

            StockQuoteServiceStub.GetPriceResponse res =
                stub.getPrice(req);

            System.err.println(res.get_return());
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

}

This class creates a client stub using the Axis Data Bindings you created. Then it calls the getPrice and update operations on the Web service. The getPrice method operation creates the GetPrice payload and sets the symbol to ABC. It then sends the request and displays the current price. The update method creates an Update payload, setting the symbol to ABC and the price to 42.35.

Now build and run the client by typing ant run.client in the Axis2_HOME/samples/quickstartadb directory.

You should get the following as output:

42
done

 
Generating a client using XML Beans

利用工具WSDL2Java
详细的如下：
To build a client using the XML Beans data bindings, execute the following steps.

Generate the databings by typing the following in the xmlbeansClient directory.

%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.xmlbeans -d xmlbeans -s -o build/client

Else, simply type ant generate.client in the Axis2_HOME/samples/quickstartxmlbeans directory.

Note that this creates a client stub code and no server side code.

Next take a look at quickstartxmlbeans/src/samples/quickstart/clients/XMLBEANSClient.java, and see how it's defined in Code Listing 11.

Code Listing 11: The XMLBEANSClient class

package samples.quickstart.clients;

import samples.quickstart.service.xmlbeans.StockQuoteServiceStub;
import samples.quickstart.service.xmlbeans.xsd.GetPriceDocument;
import samples.quickstart.service.xmlbeans.xsd.GetPriceResponseDocument;
import samples.quickstart.service.xmlbeans.xsd.UpdateDocument;

public class XMLBEANSClient{

    public static void main(java.lang.String args[]){
        try{
            StockQuoteServiceStub stub =
                new StockQuoteServiceStub
                ("http://localhost:8080/axis2/services/StockQuoteService");

            getPrice(stub);
            update(stub);

        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* fire and forget */
    public static void update(StockQuoteServiceStub stub){
        try{
            UpdateDocument reqDoc = UpdateDocument.Factory.newInstance();
            UpdateDocument.Update req = reqDoc.addNewUpdate();
            req.setSymbol ("ABC");
            req.setPrice (42.32);

            stub.update(reqDoc);
            System.err.println("done");
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* two way call/receive */
    public static void getPrice(StockQuoteServiceStub stub){
        try{
            GetPriceDocument reqDoc = GetPriceDocument.Factory.newInstance();
            GetPriceDocument.GetPrice req = reqDoc.addNewGetPrice();
            req.setSymbol("ABC");

            GetPriceResponseDocument res =
                stub.getPrice(reqDoc);

            System.err.println(res.getGetPriceResponse().getReturn());
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }
}

This class creates a client stub using the XML Beans data bindings you created. Then it calls the getPrice and the update operations on the Web service. The getPrice method operation creates the GetPriceDocument, its inner GetPrice classes and sets the symbol to ABC. It then sends the request and retrieves a GetPriceResponseDocument and displays the current price. The update method creates an UpdateDocument, updates and sets the symbol to ABC and price to 42.32, displaying 'done' when complete.

Now build and run the the project by typing ant run.client in the Axis2_HOME/samples/quickstartxmlbeans directory.

You should get the following as output:

42
done
 
Generating a client using JiBX

To build a client using JiBX, execute the following steps.

Generate the client stub by typing the following at a console in the Axis2_HOME/samples/quickstartjibx directory.

%AXIS2_HOME%/bin/wsdl2java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.clients -d jibx -s -uw -o build/client

Else, simply type "ant generate.client".

Next take a look at quickstartjibx/src/samples/quickstart/clients/JiBXClient.java, shown below in Code Listing 12.

Code Listing 12: The JiBXClient class

package samples.quickstart.clients;

import samples.quickstart.service.jibx.StockQuoteServiceStub;

public class JiBXClient{
    public static void main(java.lang.String args[]){
        try{
            StockQuoteServiceStub stub =
                new StockQuoteServiceStub
                ("http://localhost:8080/axis2/services/StockQuoteService");

            getPrice(stub);
            update(stub);

        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* fire and forget */
    public static void update(StockQuoteServiceStub stub){
        try{
            stub.update("ABC", new Double(42.35));
            System.err.println("done");
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

    /* two way call/receive */
    public static void getPrice(StockQuoteServiceStub stub){
        try{
            System.err.println(stub.getPrice("ABC"));
        } catch(Exception e){
            e.printStackTrace();
            System.err.println("\n\n\n");
        }
    }

}

This class uses the created JiBX client stub to access the getPrice and the update operations on the Web service. The getPrice method sends a request for the stock "ABC" and displays the current price. The update method setsnex the price for stock "ABC" to 42.35.

Now build and run the client by typing &q