Terry.Li-彬

虚其心，可解天下之问；专其心，可治天下之学；静其心，可悟天下之理；恒其心，可成天下之业。
  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  143 随笔 :: 344 文章 :: 130 评论 :: 0 Trackbacks
Axis2快速上手指南

原文链接:http://ws.apache.org/axis2/1_1_1/quickstartguide.html
本指南的目的是让你尽可能快的创建使用Axis2的服务和客户端，我们将使用一个简单的StockQuote服务并显示给你一些创建和部署它
的不同的方式，以及快速的看看Axis2自带的一些工具，然后我们将看看创建访问这些服务的客户端。

内容

Java代码 复制代码
  1. 介绍   
  2. 做好准备   
  3. <SPAN class=hilite1>Axis2</SPAN>服务   
  4. 创建服务   
  5.     部署POJOs   
  6.     使用AXIOM构建服务   
  7.     使用ADB生成服务   
  8.     使用XMLBeans生成服务   
  9.     使用JiBX生成服务   
  10. 生成客户端   
  11.     使用AXIOM创建一个客户端   
  12.     使用ADB生成一个客户端   
  13.     使用XMLBeans生成一个客户端   
  14.     使用JiBX生成一个客户端   
  15. 总结   
  16. 进一步学习  



快速安装笔记:
文档的代码可以在解压的标准二进制发布[/url]找到，更明确的位于其中的Axis2_HOME/samples/目录－quickstart，quickstartdb，
quickstartaxiom，quickstartjibx和quickstartxmlbeans，如果你继续下去它将帮你掌握它。它包含一个Ant构建文件(build.xml)
贯穿所有的例子我们将提到它来使得编译更容易。

介绍
让我们以服务本身开始。我们将使它简单，所以你可以看到当我们构建并部署服务时会发生什么，一个StockQuoteService例子看起来
像这个，所以让我们使用下面的(参看Code Listing 1)。
Code Listing 1: StockQuoteService类

Java代码 复制代码
  1. package samples.quickstart.service.pojo;   
  2.   
  3. import java.util.HashMap;   
  4.   
  5. public class StockQuoteService {   
  6.     private HashMap map = new HashMap();   
  7.   
  8.     public double getPrice(String symbol) {   
  9.         Double price = (Double) map.get(symbol);   
  10.         if(price != null){   
  11.             return price.doubleValue();   
  12.         }   
  13.         return 42.00;   
  14.     }   
  15.   
  16.     public void update(String symbol, double price) {   
  17.         map.put(symbol, new Double(price));   
  18.     }   
  19. }  


它将为一个具有两个可能的调用的简单服务，其中一个是一个in/out消息，另一个则为一个只能in的服务，最终我们将打包服务并用
四种不同的方式部署部署它。
首先，让我们看看这个简单的Java类怎样响应一个服务。

做好准备
在我们使用Axis2构建任何东西之前，我们将需要关注一些家务事。现在你将需要准备好你使用Axis2的环境，幸运的是，它只包括一
些简单的步骤:
1，下载并安装Java(版本至少为JDK1.4)
2，下载Axis2并解压到一个目标目录
3，复制axis2.war文件到你的servlet引擎的webapps目录
4，设置AXIS2_HOME环境变量来指出目标目录，注意Axis2生成的所有脚本和构建文件依赖于这个值，所以不要遗漏了这个步骤。
大多数情况下，我们的服务也将需要一个WSDL文件，Axis2的Java2WSDL可以用来生成一个WSDL。执行以下步骤来从一个Java类生成一
个WSDL文件:
1，创建并编译Java类
2，使用该命令生成WSDL:
%AXIS2_HOME%/bin/java2wsdl -cp . -cn samples.quickstart.service.pojo.StockQuoteService -of StockQuoteService.wsdl
移动你生成WSDL文件，你可以做你需要的任何更改。例如，你可能添加自定义的过错或者改变生成的元素名。例如，该StockQuoteSer
vice.wsdl位于%AXIS2_HOME%/samples/quickstartadb/resources/META-INF文件夹，我们将在本指南的其他部分使用它，代替生成过
程创建的一般参数。

Axis2服务
在我们构建任何东西之前，理解最终产品看起来像什么是有用的。Axis2的服务器端可以被部署在任何Servlet引擎上，并且有如下的
Code Listing 2显示的结构。
Code Listing 2: axis2.war的目录结构

Java代码 复制代码
  1. <SPAN class=hilite1>axis2</SPAN>-web    
  2. META-INF   
  3. WEB-INF   
  4.     classes    
  5.     conf   
  6.         <SPAN class=hilite1>axis2</SPAN>.xml    
  7.     lib   
  8.         activation.jar   
  9.         ...   
  10.         xmlSchema.jar   
  11.     modules   
  12.         modules.list    
  13.         addressing.mar   
  14.         ...   
  15.         soapmonitor.mar   
  16.     services   
  17.         services.list   
  18.         aservice.aar   
  19.         ...   
  20.         version.aar   
  21.     web.xml  


从最上面开始，axis2-web是组成Axis2管理程序的一些JSPs，你可以通过它来执行任何需要的动作，例如添加服务，使用模块和禁止
模块。WEB-INF包含了运行部署到服务目录的任何服务的实际上的java类和其他支持文件。
这里主要的文件是axis2.xml，它控制程序怎样与接收的消息打交道，决定Axis2是否需要使用模块目录里定义的任何模块。
这里你可以看到，服务可以被部署为*.aar文件，但是它们的内容必须以一个特殊的方式安排。例如，服务的结构将为如下:

Java代码 复制代码
  1. - StockQuoteService   
  2.    - META-INF   
  3.      - services.xml   
  4.    - samples   
  5.      - quickstart   
  6.        - service   
  7.          - pojo   
  8.            - StockQuoteService.class  


这不是太复杂，服务的名字为StockQuoteService，它在services.xml中指定，并且根据包名把任何Java类放到合适的位置。META-INF
目录包含关于Axis2需要来正确执行服务的额外信息。services.xml文件定义了服务本身并把Java类链接到它(参看Code Listing 3)。
Code Listing 3: 服务定义文件

Java代码 复制代码
  1. <service name="StockQuoteService" scope="application">   
  2.     <description>   
  3.         Stock Quote Sample Service   
  4.     </description>   
  5.     <messageReceivers>   
  6.         <messageReceiver    
  7.             mep="http://www.w3.org/2004/08/wsdl/in-only"  
  8.     class="org.apache.<SPAN class=hilite1>axis2</SPAN>.rpc.receivers.RPCInOnlyMessageReceiver"/>   
  9.         <messageReceiver   
  10.             mep="http://www.w3.org/2004/08/wsdl/in-out"  
  11.     class="org.apache.<SPAN class=hilite1>axis2</SPAN>.rpc.receivers.RPCMessageReceiver"/>   
  12.     </messageReceivers>   
  13.     <parameter name="ServiceClass">   
  14.         samples.quickstart.service.pojo.StockQuoteService   
  15.     </parameter>   
  16. </service>  


这里你看到服务本身被定义了，以及不同的消息交换模式相关的messageReceiver类型。
META-INF目录也是你打算包含在该程序中的自定义WSDL文件的位置。
你可以通过简单的采用该文件目录结构并复制到你的servlet引擎的webapps目录来部署一个服务，这是著名的"爆发"形式，但是你也
可以压缩你的文档到一个*.aar文件，类似于一个*.jar文件，并直接将*.aar文件放到servlet引擎的webapps目录。
既然你理解了我们在尝试完成什么，我们几乎准备好开始构建了。
首先，下载并解压合适版本的Axis2标准二进制发布。确认你设置了AXIS2_HOME变量的值来匹配你解压该版本内容的位置。
让我们看看一些创建客户端和服务的不同方式。

创建服务
在这个部分，我们将看看根据StockQuoteService类创建服务的五种方式:部署Plain Old Java Objects(POJO)，使用AXIOM的OMElement
构建服务，使用Axis2 Databinding Framework(ADB)生成服务，使用XMLBeans生成服务和使用JiBX生成服务。

部署POJOs
使用POJOs(Plain Old Java Objects)来部署服务，执行下面的步骤。
注意包含在<AXIS2_HOME>/samples/quickstart的目录结构(services.xml文件来自于该指南的第一个部分):

Java代码 复制代码
  1. - quickstart   
  2.    - README.txt   
  3.    - build.xml   
  4.    - resources   
  5.      - META-INF   
  6.        - services.xml   
  7.    - src   
  8.      - samples   
  9.        - quickstart   
  10.          - service   
  11.            - pojo   
  12.              - StockQuoteService.java  


注意你可以通过在quickstart目录键入ant generate.wsdl来生成WSDL。
尽管如此，创建StockQuoteService.wsdl是可选的。它可以是直接从Java类生成的版本，或者该文件的一个自定义版本，并且servi
ces.xml是本文档前面提到的同一文件。
现在通过在quickstart目录键入ant generate.service来构建工程，该目录创建了以下目录结构:

Java代码 复制代码
  1. - quickstart/build/classes   
  2.    - META-INF   
  3.      - services.xml   
  4.    - samples   
  5.      - quickstart   
  6.        - service   
  7.          - pojo   
  8.            - StockQuoteService.class  


如果你想以爆发形式部署服务，重命名classes目录为StockQuoteService，并复制它到你的servlet引擎的webapps/axis2/WEB-INF/s
ervices目录。否则，复制build/StockQuoteService.aar文件到你的servlet引擎的webapps/axis2/WEB-INF/services目录。然后通过
视察以下服务列表来确认服务被正确部署:
http://localhost:8080/axis2/services/listServices
你也可以检验以下WSDL:
http://localhost:8080/axis2/services/StockQuoteService?wsdl
以及以下结构:
http://localhost:8080/axis2/services/StockQuoteService?xsd
一旦这些urls工作，让我们快速测试一下服务。让你的浏览器访问以下URL试试:
http://localhost:8080/axis2/rest/StockQuoteService/getPrice?symbol=IBM
你将得到如下应答:

Java代码 复制代码
  1. <ns:getPriceResponse xmlns:ns="http://pojo.service.quickstart.samples/xsd"><ns:return>42</ns:return></ns:getPriceResponse>  


如果你像这样调用update方法:
http://localhost:8080/axis2/rest/StockQuoteService/update?symbol=IBM&price=100
然后调用第一个getPrice url。你可以看到price被更新了。

使用AXIOM构建服务
为了使用AXIOM"从零开始"构建一个服务，执行以下步骤。
注意包含在/samples/quickstartaxiom的目录结构:

Java代码 复制代码
  1. - quickstartaxiom   
  2.    - README.txt   
  3.    - build.xml   
  4.    - resources   
  5.      - META-INF   
  6.        - services.xml   
  7.        - StockQuoteService.wsdl   
  8.    - src   
  9.      - samples   
  10.        - quickstart   
  11.          - service   
  12.            - axiom   
  13.              - StockQuoteService.java   
  14.          - clients   
  15.            - AXIOMClient.java  


由于AXIOM有一点不同，你将需要一个与POJO所用不同的services.xml文件，在Code Listing 4中显示了它的定义。
Code Listing 4: 服务定义文件

Java代码 复制代码
  1. <service name="StockQuoteService" scope="application">   
  2.     <description>   
  3.         Stock Quote Service   
  4.     </description>   
  5.     <operation name="getPrice">   
  6.         <messageReceiver class="org.apache.<SPAN class=hilite1>axis2</SPAN>.receivers.RawXMLINOutMessageReceiver"/>   
  7.     </operation>   
  8.     <operation name="update">   
  9.         <messageReceiver class="org.apache.<SPAN class=hilite1>axis2</SPAN>.receivers.RawXMLINOnlyMessageReceiver"/>   
  10.     </operation>   
  11.     <parameter name="ServiceClass">samples.quickstart.service.axiom.StockQuoteService</parameter>   
  12. </service>  


注意，几乎是一样的，除了操作是显示地定义在service.xml文件中，而且MessageReceiver现在是RawXML。
现在，上面提到的简单的使用Axis2库的类的StockQuoteService.java类，在Code Listing 5中定义。
Code Listing 5:使用AXIOM的StockQuoteService类

Java代码 复制代码
  1. package samples.quickstart.service.axiom;   
  2.   
  3. import javax.xml.stream.XMLStreamException;   
  4. import org.apache.axiom.om.OMAbstractFactory;   
  5. import org.apache.axiom.om.OMElement;   
  6. import org.apache.axiom.om.OMFactory;   
  7. import org.apache.axiom.om.OMNamespace;   
  8.   
  9. import java.util.HashMap;   
  10. public class StockQuoteService {   
  11.     private HashMap map = new HashMap();   
  12.   
  13.     public OMElement getPrice(OMElement element) throws XMLStreamException {   
  14.         element.build();   
  15.         element.detach();   
  16.   
  17.         OMElement symbolElement = element.getFirstElement();   
  18.         String symbol = symbolElement.getText();   
  19.   
  20.         String returnText = "42";   
  21.         Double price = (Double) map.get(symbol);   
  22.         if(price != null){   
  23.             returnText  = "" + price.doubleValue();   
  24.         }   
  25.         OMFactory fac = OMAbstractFactory.getOMFactory();   
  26.         OMNamespace omNs =   
  27.             fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");   
  28.         OMElement method = fac.createOMElement("getPriceResponse", omNs);   
  29.         OMElement value = fac.createOMElement("price", omNs);   
  30.         value.addChild(fac.createOMText(value, returnText));   
  31.         method.addChild(value);   
  32.         return method;   
  33.     }   
  34.   
  35.     public void update(OMElement element) throws XMLStreamException {   
  36.         element.build();   
  37.         element.detach();   
  38.   
  39.         OMElement symbolElement = element.getFirstElement();   
  40.         String symbol = symbolElement.getText();   
  41.   
  42.         OMElement priceElement = (OMElement)symbolElement.getNextOMSibling();   
  43.         String price = priceElement.getText();   
  44.   
  45.         map.put(symbol, new Double(price));   
  46.     }   
  47. }  


Axis2使用AXIOM，或者AXIs Object Model，一个基于StAX API(Streaming API for XML)的DOM(Document Object Model)类似的结构
作为服务的方法必须使用OMElement作为它们的参数，OMElement表示一个XML元素，在这里它则为进来的SOAP消息的有效载荷。这里，
你提取有效载荷元素的第一个孩子，添加文本给它，并使用它作为返回的OMElement的内容。除非这是一个"只有in"的服务，这些方法
必须返回一个OMElement，因为它成为返回的SOAP消息的有效载荷。
现在通过在Axis2_HOME/samples/quickstartaxiom目录键入ant generate.service来构建工程。
把StockQuoteService.aar文件放在servlet引擎的webapps/axis2/WEB-INF/services目录，通过视察下面的服务列表来确认服务正确
部署:
http://localhost:8080/axis2/services/listServices
你也可以检验以下WSDL:
http://localhost:8080/axis2/services/StockQuoteService?wsdl
以及以下结构:
http://localhost:8080/axis2/services/StockQuoteService?xsd

使用ADB生成服务
执行以下步骤来使用Axis2 Databinding Framework(ADB)生成和部署服务。
通过在Axis2_HOME/samples/quickstartadb目录键入以下内容来使用WSDL2Java工具生成骨架:
%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.adb -d adb -s -ss
-sd -ssi -o build/service
或者在Axis2_HOME/samples/quickstartadb目录简单的键入ant generate.service
选项-d adb指定了Axis Data Binding(ADB)。-s转换指定同步或者只模块化调用。-ss转换创建服务器端代码(骨架和相关文件)。-sd
转换创建一个服务描述符(services.xml文件)。-ssi转换为服务骨架创建一个接口。服务文件现在应该定位于build/service。
如果你通过使用WSDL2Java直接生成代码，下一步你需要修改生成的骨架来实现服务(如果你使用"ant generate.service"，一个完全
的骨架会自动复制并覆盖生成的那个)。
打开build/service/src/samples/quickstart/adb/service/StockQuoteServiceSkeleton.java文件并修改它来添加你的服务的功能性
到生成的方法，下面的Code Listing 6显示了。
Code Listing 6:定义服务骨架文件

Java代码 复制代码
  1. package samples.quickstart.service.adb;   
  2.   
  3. import samples.quickstart.service.adb.xsd.GetPriceResponse;   
  4. import samples.quickstart.service.adb.xsd.Update;   
  5. import samples.quickstart.service.adb.xsd.GetPrice;   
  6.   
  7. import java.util.HashMap;   
  8.   
  9. public class StockQuoteServiceSkeleton {   
  10.   
  11.     private static HashMap map;   
  12.   
  13.     static{ map = new HashMap(); }   
  14.   
  15.     public void update(Update param0) {   
  16.         map.put(param0.getSymbol(), new Double(param0.getPrice()));   
  17.     }   
  18.   
  19.     public GetPriceResponse getPrice(GetPrice param1) {   
  20.         Double price = (Double) map.get(param1.getSymbol());   
  21.         double ret = 42;   
  22.         if(price != null){   
  23.             ret = price.doubleValue();   
  24.         }   
  25.         GetPriceResponse res =   
  26.                 new GetPriceResponse();   
  27.         res.set_return(ret);   
  28.         return res;   
  29.     }   
  30. }  


现在你可以通过在build/service目录键入以下命令构建工程:ant jar.server
如果一切进展顺利，你应该在你的窗口看到BUILD SUCCESSFUL消息，而且StockQuoteService.aar文件在build/service/build/lib
目录中。复制该文件到servlet引擎的webapps/axis2/WEB-INF/services目录。
你可以通过视察下面的服务列表来确认服务正确部署:
http://localhost:8080/axis2/services/listServices
你也可以检验以下WSDL:
http://localhost:8080/axis2/services/StockQuoteService?wsdl
以及以下结构:
http://localhost:8080/axis2/services/StockQuoteService?xsd

使用XMLBeans生成服务
执行以下步骤来使用XMLBeans生成服务。
通过在Axis2_HOME/samples/quickstartxmlbeans目录键入以下命令来使用WSDL2Java工具生成骨架:
%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.xmlbeans
-d xmlbeans -s -ss -sd -ssi -o build/service
或者在Axis2_HOME/sampels/quickstartxmlbeans目录简单的键入ant generate.service
选项-d xmlbeans指定XMLBeans数据绑定。-s转换指定同步或者只是模块化调用。-ss转换创建服务器端代码(骨架和相关文件)。-sd
转换创建一个服务描述符(services.xml文件)。-ssi转换创建一个服务骨架的接口。现在服务文件应该位于build/service。
如果你通过使用WSDL2Java直接生成代码，下一步你需要修改生成的骨架来实现服务(如果你使用"ant generate.service"，一个完全
的骨架将被自动复制并覆盖生成的那个)。
下一步打开build/service/src/samples/quickstart/service/xmlbeans/StockQuoteServiceSkeleton.java文件并修改它来添加你的
服务的功能性到生成的方法(参看Code Listing 7)。
Code Listing 7:定义服务骨架

Java代码 复制代码
  1. package samples.quickstart.service.xmlbeans;   
  2.   
  3. import samples.quickstart.service.xmlbeans.xsd.GetPriceDocument;   
  4. import samples.quickstart.service.xmlbeans.xsd.GetPriceResponseDocument;   
  5. import samples.quickstart.service.xmlbeans.xsd.UpdateDocument;   
  6.   
  7. import java.util.HashMap;   
  8.   
  9. public class StockQuoteServiceSkeleton implements StockQuoteServiceSkeletonInterface {   
  10.   
  11.     private static HashMap map;   
  12.   
  13.     static{ map = new HashMap(); }   
  14.   
  15.     public void update(UpdateDocument param0) {   
  16.     }   
  17.   
  18.     public GetPriceResponseDocument getPrice(GetPriceDocument param1) {   
  19.     }   
  20. }  


通过在build/service目录键入命令ant jar.server构建项目，该目录包含build.xml文件。
如果一切进展顺利，你应该在你的窗口看到BUILD SUCCESSFUL消息，而且StockQuoteService.aar文件位于新创建的build/service/
build/lib目录。复制该文件到servlet引擎的webapps/axis2/WEB-INF/services目录。
你可以通过视察下面的服务列表来确认服务正确部署:
http://localhost:8080/axis2/services/listServices
你也可以检验以下WSDL:
http://localhost:8080/axis2/services/StockQuoteService?wsdl
以及以下结构:
http://localhost:8080/axis2/services/StockQuoteService?xsd

使用JiBX生成服务
执行以下步骤来使用JiBX数据绑定生成和部署服务。
通过在Axis2_HOME/samples/quickstartjibx目录的控制台键入以下内容来使用WSDL2Java工具生成骨架:
%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
或者在Axis2_HOME/samples/quickstartjibx目录简单的键入"ant generate.service"
选项-d jibx指定了JiBX数据绑定。-s转换指定同步或者只是模块化调用。-ss转换创建服务器端代码(骨架和相关文件)。-sd转换创建
一个服务描述符(services.xml文件)。-ssi转换创建服务骨架的接口。-uw转换解开传递给服务操作和从服务操作传递出去的参数，来
创建一个更自然的编程接口。
在运行WSDL2Java后，服务文件应该位于build/service。如果你通过使用WSDL2Java直接生成代码，下一步你需要修改生成的骨架来
实现服务(如果你使用"ant generate.service"则一个完全的骨架将自动被复制并覆盖生成的那个)。打开build/service/src/samples
/quickstart/service/jibx/StockQuoteServiceSkeleton.java文件并修改它来添加你的服务的功能性到生成的方法，在Code Listing
8中显示了。
Code Listing 8:定义服务骨架文件

Java代码 复制代码
  1. package samples.quickstart.service.jibx;   
  2.   
  3. import java.util.HashMap;   
  4.   
  5. public class StockQuoteServiceSkeleton implements StockQuoteServiceSkeletonInterface {   
  6.     private HashMap map = new HashMap();   
  7.   
  8.     public void update(String symbol, Double price) {   
  9.         map.put(symbol, price);   
  10.     }   
  11.   
  12.     public Double getPrice(String symbol) {   
  13.         Double ret = (Double) map.get(symbol);   
  14.         if (ret == null) {   
  15.             ret = new Double(42.0);   
  16.         }   
  17.         return ret;   
  18.     }   
  19. }  


现在你可以通过在build/service目录键入命令ant jar.server构建工程
如果一切进展顺利，你应该在你的窗口看到BUILD SUCCESSFUL消息，并且StockQuoteService.aar文件位于build/service/build/lib
目录。复制该文件到servlet引擎的webapps/axis2/WEB-INF/services目录。
你可以通过视察下面的服务列表来确认服务正确部署:
http://localhost:8080/axis2/services/listServices
你也可以检验以下WSDL:
http://localhost:8080/axis2/services/StockQuoteService?wsdl
以及以下结构:
http://localhost:8080/axis2/services/StockQuoteService?xsd
对于和Axis2使用JiBX的更多信息，参考[urlhttp://ws.apache.org/axis2/1_1_1/jibx/jibx-quotegen-integration.html]JiBX代码生成集成[/url]。你也可以检查JiBX Axis2 Wiki页面得到更多同Axis2使用
JiBX的更新信息。

创建客户端
在这个部分，我们将看看基于StockQuoteService类创建客户端的四种方式:构建基于AXIOM的客户端，使用Axis2 Databinding Frame
work(ADB)生成客户端，使用XMLBeans生成客户端，使用JiBX生成客户端。

使用AXIOM创建一个客户端
执行以下步骤来使用AXIOM构建一个客户端。
也注意在使用AXIOM创建服务部分显示的目录结构，为了完整性下面的重复了。

Java代码 复制代码
  1. - quickstartaxiom   
  2.    - README.txt   
  3.    - build.xml   
  4.    - resources   
  5.      - META-INF   
  6.        - services.xml   
  7.        - StockQuoteService.wsdl   
  8.    - src   
  9.      - samples   
  10.        - quickstart   
  11.          - service   
  12.            - axiom   
  13.              - StockQuoteService.java   
  14.          - clients   
  15.            - AXIOMClient.java  


上面提到的AXIOMClient.java类的定义显示在下面的Code Listing 9。
Code Listing 9:使用AXIOM的AXIOMClient类

Java代码 复制代码
  1. package samples.quickstart.clients;   
  2.   
  3. import org.apache.axiom.om.OMAbstractFactory;   
  4. import org.apache.axiom.om.OMElement;   
  5. import org.apache.axiom.om.OMFactory;   
  6. import org.apache.axiom.om.OMNamespace;   
  7. import org.apache.<SPAN class=hilite1>axis2</SPAN>.Constants;   
  8. import org.apache.<SPAN class=hilite1>axis2</SPAN>.addressing.EndpointReference;   
  9. import org.apache.<SPAN class=hilite1>axis2</SPAN>.client.Options;   
  10. import org.apache.<SPAN class=hilite1>axis2</SPAN>.client.ServiceClient;   
  11.   
  12. public class AXIOMClient {   
  13.   
  14.     private static EndpointReference targetEPR =    
  15.         new EndpointReference("http://localhost:8080/<SPAN class=hilite1>axis2</SPAN>/services/StockQuoteService");   
  16.   
  17.     public static OMElement getPricePayload(String symbol) {   
  18.         OMFactory fac = OMAbstractFactory.getOMFactory();   
  19.         OMNamespace omNs = fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");   
  20.   
  21.         OMElement method = fac.createOMElement("getPrice", omNs);   
  22.         OMElement value = fac.createOMElement("symbol", omNs);   
  23.         value.addChild(fac.createOMText(value, symbol));   
  24.         method.addChild(value);   
  25.         return method;   
  26.     }   
  27.   
  28.     public static OMElement updatePayload(String symbol, double price) {   
  29.         OMFactory fac = OMAbstractFactory.getOMFactory();   
  30.         OMNamespace omNs = fac.createOMNamespace("http://axiom.service.quickstart.samples/xsd", "tns");   
  31.   
  32.         OMElement method = fac.createOMElement("update", omNs);   
  33.   
  34.         OMElement value1 = fac.createOMElement("symbol", omNs);   
  35.         value1.addChild(fac.createOMText(value1, symbol));   
  36.         method.addChild(value1);   
  37.   
  38.         OMElement value2 = fac.createOMElement("price", omNs);   
  39.         value2.addChild(fac.createOMText(value2,   
  40.                                          Double.toString(price)));   
  41.         method.addChild(value2);   
  42.         return method;   
  43.     }   
  44.   
  45.     public static void main(String[] args) {   
  46.         try {   
  47.             OMElement getPricePayload = getPricePayload("WSO");   
  48.             OMElement updatePayload = updatePayload("WSO", 123.42);   
  49.             Options options = new Options();   
  50.             options.setTo(targetEPR);   
  51.             options.setTransportInProtocol(Constants.TRANSPORT_HTTP);   
  52.   
  53.             ServiceClient sender = new ServiceClient();   
  54.             sender.setOptions(options);   
  55.   
  56.             sender.fireAndForget(updatePayload);   
  57.             System.err.println("done");   
  58.             OMElement result = sender.sendReceive(getPricePayload);   
  59.   
  60.             String response = result.getFirstElement().getText();   
  61.             System.err.println("Current price of WSO: " + response);   
  62.   
  63.         } catch (Exception e) {   
  64.             e.printStackTrace();   
  65.         }   
  66.     }   
  67.        
  68. }  


Axis2使用AXIOM，或者AXIs Object Model，一个基于StAX API(Streaming API for XML)的DOM(Document Object Model)类似的结构
这里你为服务的update和getPrice方法建立有效载荷。有效载荷的创建类似于你为AXIOM服务创建getPriceResponse有效载荷。然后
你创建Options类，并创建用来与服务交流的ServiceClient。首先你调用update方法，一个什么也不返回的fireAndForget方法。最后
你调用getPrice方法，并从服务得到当前价格并显示它。
现在你可以通过在Axis2_HOME/samples/quickstartaxiom目录键入ant run.client构建并运行AXIOM客户端。
你应该得到以下输出:

Java代码 复制代码
  1. done   
  2. Current price of WSO: 123.42  



使用ADB生成一个客户端
执行以下步骤来使用Axis Data Binding(ADB)构建一个客户端。
通过在Axis2_HOME/samples/quickstartadb目录键入以下命令来生成客户端数据绑定:
%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.clients -d adb -s
-o build/client
或者在Axis2_HOME/samples/quickstartadb目录简单的键入ant generate.client。
下一步看看quickstartadb/src/samples/quickstart/clients/ADBClient.java，并看看它在Code Listing 10中是怎样定义的。
Code Listing 10:ADBClient类

Java代码 复制代码
  1. package samples.quickstart.clients;   
  2.   
  3. import samples.quickstart.service.adb.StockQuoteServiceStub;   
  4.   
  5. public class ADBClient{   
  6.     public static void main(java.lang.String args[]){   
  7.         try{   
  8.             StockQuoteServiceStub stub =   
  9.                 new StockQuoteServiceStub   
  10.                 ("http://localhost:8080/<SPAN class=hilite1>axis2</SPAN>/services/StockQuoteService");   
  11.   
  12.             getPrice(stub);   
  13.             update(stub);   
  14.   
  15.         } catch(Exception e){   
  16.             e.printStackTrace();   
  17.             System.err.println("\n\n\n");   
  18.         }   
  19.     }   
  20.   
  21.     /* fire and forget */  
  22.     public static void update(StockQuoteServiceStub stub){   
  23.         try{   
  24.             StockQuoteServiceStub.Update req = new StockQuoteServiceStub.Update();   
  25.             req.setSymbol ("ABC");   
  26.             req.setPrice (42.35);   
  27.   
  28.             stub.update(req);   
  29.             System.err.println("done");   
  30.         } catch(Exception e){   
  31.             e.printStackTrace();   
  32.             System.err.println("\n\n\n");   
  33.         }   
  34.     }   
  35.   
  36.     /* two way call/receive */  
  37.     public static void getPrice(StockQuoteServiceStub stub){   
  38.         try{   
  39.             StockQuoteServiceStub.GetPrice req = new StockQuoteServiceStub.GetPrice();   
  40.   
  41.             req.setSymbol("ABC");   
  42.   
  43.             StockQuoteServiceStub.GetPriceResponse res =   
  44.                 stub.getPrice(req);   
  45.   
  46.             System.err.println(res.get_return());   
  47.         } catch(Exception e){   
  48.             e.printStackTrace();   
  49.             System.err.println("\n\n\n");   
  50.         }   
  51.     }   
  52.   
  53. }  


该类使用你创建的Axis Data Bindings创建一个客户端存根。然后它在Web服务上调用getPrice和update操作。getPrice方法操作创建
GetPrice有效载荷并设置symbol为ABC。然后它发送请求并显示当前价格。update方法创建一个Update有效载荷，设置symbol为ABC及
price为42.35。
现在通过在Axis2_HOME/samples/quickstartadb目录键入ant run.client来构建并运行客户端。
你应该得到以下输出:

Java代码 复制代码
  1. 42  
  2. done  



使用XMLBeans生成一个客户端
执行以下步骤来使用XMLBeans数据绑定来构建一个客户端。
通过在xmlbeansClient目录键入以下命令来生成数据绑定:
%AXIS2_HOME%/bin/WSDL2Java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.service.xmlbeans -d
xmlbeans -s -o build/client
或者简单的在Axis2_HOME/samples/quickstartxmlbeans目录下键入ant generate.client。
注意这只会创建客户端存根代码而不会创建服务器端代码。
下一步看看quickstartxmlbeans/src/samples/quickstart/clients/XMLBEANSClient.java，并在Code Listing 11看看它怎样定义的
Code Listing 11:XMLBEANSClient类

Java代码 复制代码
  1. package samples.quickstart.clients;   
  2.   
  3. import samples.quickstart.service.xmlbeans.StockQuoteServiceStub;   
  4. import samples.quickstart.service.xmlbeans.xsd.GetPriceDocument;   
  5. import samples.quickstart.service.xmlbeans.xsd.GetPriceResponseDocument;   
  6. import samples.quickstart.service.xmlbeans.xsd.UpdateDocument;   
  7.   
  8. public class XMLBEANSClient{   
  9.   
  10.     public static void main(java.lang.String args[]){   
  11.         try{   
  12.             StockQuoteServiceStub stub =   
  13.                 new StockQuoteServiceStub   
  14.                 ("http://localhost:8080/<SPAN class=hilite1>axis2</SPAN>/services/StockQuoteService");   
  15.   
  16.             getPrice(stub);   
  17.             update(stub);   
  18.   
  19.         } catch(Exception e){   
  20.             e.printStackTrace();   
  21.             System.err.println("\n\n\n");   
  22.         }   
  23.     }   
  24.   
  25.     /* fire and forget */  
  26.     public static void update(StockQuoteServiceStub stub){   
  27.         try{   
  28.             UpdateDocument reqDoc = UpdateDocument.Factory.newInstance();   
  29.             UpdateDocument.Update req = reqDoc.addNewUpdate();   
  30.             req.setSymbol ("ABC");   
  31.             req.setPrice (42.32);   
  32.   
  33.             stub.update(reqDoc);   
  34.             System.err.println("done");   
  35.         } catch(Exception e){   
  36.             e.printStackTrace();   
  37.             System.err.println("\n\n\n");   
  38.         }   
  39.     }   
  40.   
  41.     /* two way call/receive */  
  42.     public static void getPrice(StockQuoteServiceStub stub){   
  43.         try{   
  44.             GetPriceDocument reqDoc = GetPriceDocument.Factory.newInstance();   
  45.             GetPriceDocument.GetPrice req = reqDoc.addNewGetPrice();   
  46.             req.setSymbol("ABC");   
  47.   
  48.             GetPriceResponseDocument res =   
  49.                 stub.getPrice(reqDoc);   
  50.   
  51.             System.err.println(res.getGetPriceResponse().getReturn());   
  52.         } catch(Exception e){   
  53.             e.printStackTrace();   
  54.             System.err.println("\n\n\n");   
  55.         }   
  56.     }   
  57. }  


该类使用你创建的XMLBeans数据绑定创建一个客户端存根，然后它在Web服务上调用getPrice和update操作。getPrice方法操作创建
GetPriceDocument，它内部的GetPrice类，并设置symbol为ABC。然后它发送请求并得到GetPriceResponseDocument并显示当前price
update方法创建一个UpdateDocument和Update并设置symbol为ABC及price为42.32，当完成时显示done。
现在通过在Axis2_HOME/samples/quickstartxmlbeans目录键入ant run.client构建并运行工程。
你应该得到下列输出:

Java代码 复制代码
  1. 42  
  2. done  



使用JiBX生成一个客户端
执行以下步骤来使用JiBX构建一个客户端。
通过在Axis2_HOME/samples/quickstartjibx目录的控制台键入以下命令来生成客户端存根:

Java代码 复制代码
  1. %<SPAN class=hilite1>AXIS2</SPAN>_HOME%/bin/wsdl2java -uri resources/META-INF/StockQuoteService.wsdl -p samples.quickstart.clients -d jibx -s   
  2. -uw -o build/client  


或者简单的键入"ant generate.client"。
下一步看看quickstartjibx/src/samples/quickstart/clients/JiBXClient.java，在Code Listing 12显示了。
Code Listing 12:JiBXClient类

Java代码 复制代码
  1. package samples.quickstart.clients;   
  2.   
  3. import samples.quickstart.service.jibx.StockQuoteServiceStub;   
  4.   
  5. public class JiBXClient{   
  6.     public static void main(java.lang.String args[]){   
  7.         try{   
  8.             StockQuoteServiceStub stub =   
  9.                 new StockQuoteServiceStub   
  10.                 ("http://localhost:8080/<SPAN class=hilite1>axis2</SPAN>/services/StockQuoteService");   
  11.   
  12.             getPrice(stub);   
  13.             update(stub);   
  14.   
  15.         } catch(Exception e){   
  16.             e.printStackTrace();   
  17.             System.err.println("\n\n\n");   
  18.         }   
  19.     }   
  20.   
  21.     /* fire and forget */  
  22.     public static void update(StockQuoteServiceStub stub){   
  23.         try{   
  24.             stub.update("ABC", new Double(42.35));   
  25.             System.err.println("done");   
  26.         } catch(Exception e){   
  27.             e.printStackTrace();   
  28.             System.err.println("\n\n\n");   
  29.         }   
  30.     }   
  31.   
  32.     /* two way call/receive */  
  33.     public static void getPrice(StockQuoteServiceStub stub){   
  34.         try{   
  35.             System.err.println(stub.getPrice("ABC"));   
  36.         } catch(Exception e){   
  37.             e.printStackTrace();   
  38.             System.err.println("\n\n\n");   
  39.         }   
  40.     }   
  41.   
  42. }  


该类使用创建的JiBX客户端存根在Web服务上访问getPrice和update操作。getPrice方法为股票"ABC"发送请求并显示当前price。
update方法为股票"ABC"设置价格为42.35。
现在通过在Axis2_HOME/samples/quickstartjibx目录的控制台键入"ant run.client[b]"来构建并运行客户端。
你应该得到以下输出:

Java代码 复制代码
  1. 42  
  2. done  


参考JiBX代码生成集成来得到更多关于同Axis2使用JiBX的信息细节。

[b]总结
Axis2是一个立刻让web服务运行起来的灵活和健壮的方式。本指南呈现了创建一个可以在Axis2上部署的服务的五种方法。现在你拥有
了使用多种不同技术来创建Web服务的灵活性。

进一步学习
Apache Axis2-http://ws.apache.org/axis2/
Axis2 Architecture-http://ws.apache.org/axis2/1_0/Axis2ArchitectureGuide.html
Introduction to Apache Axis2-http://www.redhat.com/magazine/021jul06/features/apache_axis2/
Working With Apache Axis2-http://www.wso2.net/articles/axis2/java/2006/09/13/working-with-axis2

posted on 2008-07-10 17:22 礼物 阅读(1156) 评论(0)  编辑  收藏 所属分类: web service 、Axis

只有注册用户登录后才能发表评论。
网站导航: