BlogJava-Terry.Li-彬-随笔分类-webservice

Axis1.4 利用 deploy.wsdd 发布 server-config.wsdd文件

礼物 — Sun, 25 Nov 2007 12:31:00 GMT

配置axis环境变量

set JAVA_HOME=D:\j2sdk1.4.1_01
set CATALINA_HOME=D:\Tomcat 5.0
set classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
set Path=%Path%;%JAVA_HOME%\bin;%CATALINA_HOME%\bin

set AXIS_HOME=E:\Tomcat\webapps\axis
set AXIS_LIB=%AXIS_HOME%\WEB-INF\lib
set AXISCLASSPATH=%AXIS_LIB%\axis.jar;%AXIS_LIB%\commons-discovery.jar;%AXIS_LIB%\commons-logging.jar;%AXIS_LIB%\jaxrpc.jar;%AXIS_LIB%\saaj.jar;%AXIS_LIB%\log4j-1.2.8.jar;%AXIS_LIB%\activation.jar;%AXIS_LIB%\mail.jar;%AXIS_LIB%\wsdl4j-1.5.1.jar;%AXIS_LIB%\axis-ant.jar;%AXIS_LIB%\xmlsec.jar
set classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet.jar;

启动tomcat ，运行-cmd 到deploy.wsdd文件所在目录下使用命令
E:\Java\Tomcat 5.5\webapps\Axis1.4_samples2\WEB-INF>java -Djava.ext.dirs="e:\Jav
a\Tomcat 5.5\webapps\axis\WEB-INF\lib" org.apache.axis.client.AdminClient deploy
.wsdd

我的Tomca 5.5之间有个空格，所以需要将整个路径使用“”包含，运行这个命令后会在E:\Java\Tomcat 5.5\webapps\axis\WEB-INF 下生成一个 server-config.wsdd 这个就是我们需要的

我的qq:33614814
e-mail:libin2722@sohu.com

礼物 2007-11-25 20:31 发表评论

一个简单的WSDL文档（下）

礼物 — Sat, 24 Nov 2007 15:43:00 GMT

虽然发布的服务很简单，Axis帮我们生成的WSDL文档看起来却是比较复杂的，之所以这样的主要原因是WSDL要考虑到兼容各种实现和具有可扩展性，这就像我们使用一些框架做开发会使代码总量增加，而好处是使逻辑更加清晰。这篇帖子的上半部分介绍了WSDL里常用到的名称空间，现在就来说说WSDL里各元素的含义。

一个WSDL文档里一般包含、、、和这几个元素，其中、和可以看作抽象的接口定义，而和是具体的实现，注：有些时候也把看作接口的一部分。你也许看过一些WSDL把这两部分分开写在两个xml文件里，并在其中一个文件里引入（import）另一个的情况，这也是为什么要区分接口和实现的原因之一。在现实世界里，接口部分很可能是由某个组织（例如某行业协会）制定好的，该组织的成员在发布自己的Web服务时都要引入它，从而达到统一标准的目的。

标签用来定义Web服务里用到的，XML Schema定义的数据类型以外的自定义数据类型，对于我们自定义的类（Book），会对应到一个，其中用元素指定每个参数的类型。JAX-RPC规范中规定了Java语言的数据类型到XML Schema数据类型的映射，例如int<->xsd:int、java.lang.String<->xsd:string等等，还有数组的映射方式。

标签定义Web服务里的消息，最常见的就是请求和响应消息。中可以有元素，它对应Java类中各个方法的参数或返回值，例如addBook()方法有一个Book类型的参数，则在WSDL中会有的描述。

标签表示一个服务的类型，就是接口的意思了。WSDL里有些概念很容易混淆，比如port和service的区别，我把service理解为有一个具体URL的服务，而port代表某一地址，portType是service的抽象，不知道对不对。我们看一个WSDL文档，一般就该先找元素，看看这个WSDL代表的Web服务里都有哪些方法，它们的参数和返回值是什么。这些方法是在里用元素表示的，可以有和子元素，表示方法的输入和输出。注意，方法可以是只有输入或只有输出的。

元素将portType与具体的传输协议绑定。现在，绝大多数都是与SOAP绑定的，对每一个方法的输入和输出，都要指定SOAP的表示方法。JAX-RPC规范规定，SOAP绑定可以有rpc和document两种类型，分别表示远程过程调用和基于消息的方式。use属性可以是encoded或literal，对于前者要支持rpc的方式，对于后者要支持rpc和document的方式，它们使得SOAP消息的格式有所区别，但我还没有仔细研究，你可以参考一下JAX-RPC 1.1版本的6.3-6.4节。又想起另外一个问题，SOAP和HTTP的关系是怎样的，绑定到SOAP就等于绑定到HTTP了吗，应该不是，那么在哪里指定Web服务绑定的应用层协议（HTTP、SMTP等等）呢？（Update: 由transport属性指定应用层协议）

最后，元素通过子元素把服务联系到一个具体的URL，更确切点，应该是把一个已绑定的portType联系到某个URL，这样就知道该把SOAP消息发给哪个服务器了。

我觉得之所以应该花比较多的时间理解WSDL，因为WSDL在整个Web服务中扮演了十分核心的角色，它是对Web服务的一个比较完整的语法上的描述，同时，它还与XML、SOAP以及UDDI都有着非常密切的联系，因此对于我们更好的认识Web服务体系结构是很重要的。虽然现在的Web服务开发工具都能自动进行Java<->WSDL的转换，但理解WSDL对于Web服务的不论是设计、开发还是修改调试都是必要的。

参考资料：

礼物 2007-11-24 23:43 发表评论

一个简单的WSDL文档（上）

礼物 — Sat, 24 Nov 2007 15:42:00 GMT

现在，简单解释一下《使用Axis发布简单的Web服务》中发布的Web服务所对应WSDL文档的内容和结构。请注意，同样的Java类在不同的Web服务开发包中得到的WSDL文档不一定完全相同，这里还是以使用Axis的情况作为例子。

虽然比较长，但为了方便起见还是把完整的WSDL贴在下面，然后进行说明。由于我对Web服务的认识还很不够，所以几乎可以肯定会存在一些误解，仅作参考。

xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://localhost:8080/bookstore/services/BookSvc"
  xmlns="http://schemas.xmlsoap.org/wsdl/"
  xmlns:apachesoap="http://xml.apache.org/xml-soap"
  xmlns:impl="http://localhost:8080/bookstore/services/BookSvc"
  xmlns:intf="http://localhost:8080/bookstore/services/BookSvc"
  xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
  xmlns:tns1="http://model.bookstore.com"
  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
  xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <wsdl:types>
    <schema targetNamespace="http://model.bookstore.com" xmlns="http://www.w3.org/2001/XMLSchema">
      <import namespace="http://schemas.xmlsoap.org/soap/encoding/"/>
      <complexType name="Book">
        <sequence>
          <element name="ISDN" nillable="true" type="xsd:string"/>
          <element name="name" nillable="true" type="xsd:string"/>
          <element name="page" type="xsd:int"/>
        sequence>
      complexType>
    Schema>
  wsdl:types>
  <wsdl:message name="addBookResponse">
  wsdl:message>
  <wsdl:message name="addBookRequest">
    <wsdl:part name="book" type="tns1:Book"/>
  wsdl:message>
  <wsdl:portType name="BookSvc">
    <wsdl:operation name="addBook" parameterOrder="book">
      <wsdl:input message="intf:addBookRequest" name="addBookRequest"/>
      <wsdl:output message="intf:addBookResponse" name="addBookResponse"/>
    wsdl:operation>
  wsdl:portType>
  <wsdl:binding name="BookSvcSoapBinding" type="intf:BookSvc">
    <wsdlsoap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
    <wsdl:operation name="addBook">
      <wsdlsoap:operation soapAction=""/>
      <wsdl:input name="addBookRequest">
        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="http://bookstore.com" use="encoded"/>
      wsdl:input>
      <wsdl:output name="addBookResponse">
        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="http://localhost:8080/bookstore/services/BookSvc" use="encoded"/>
      wsdl:output>
    wsdl:operation>
  wsdl:binding>
  <wsdl:service name="BookSvcService">
    <wsdl:port binding="intf:BookSvcSoapBinding" name="BookSvc">
      <wsdlsoap:address location="http://localhost:8080/bookstore/services/BookSvc"/>
    wsdl:port>
  wsdl:service>
wsdl:definitions>

每个WSDL的根元素都是，一般都在这里定义文档中的各种名称空间。对于上面的WSDL，定义了不少名称空间，现在来说说它们的作用。

我们都知道，WSDL应该是格式正确的XML文档。进一步，还应该把它看作一个Schema，因此，元素中可以定义targetNamespace属性，表示在这个元素下的所有元素都属于这个目标名称空间。

xmlns表示缺省的名称空间，请注意在上面的文档中，这个缺省名称空间的值和xmlns:wsdl的值是相同的（都是http://schemas.xmlsoap.org/wsdl/）。因此，在这个WSDL中的很多元素，例如、等等，实际上省略掉前面的“wsdl:”效果也是一样的。

名称空间xmlns:apachesoap在文档中并没有使用到，这个应该是Axis为某些情况预留的名称空间，或者是为了兼容以前的版本使用，因为Axis的前身是Apache Soap项目。

名称空间xmlns:intf和xmlns:impl分别代表接口（interface）和实现（implement），可以看出它们的值也是相同的，并且和的targetNamespace一致。这是为了在文档中引用已定义的属于该目标名称空间的元素使用的，例如“”，其中的BookSvc一定是在前面某个元素中定义的，并且属于中指定的目标名称空间。Axis把intf和impl分开是有道理的，因为在很多情况下，一个WSDL会引用另外一个WSDL，后者可能只定义了数据类型、消息和端口类型这些抽象元素，而前者中定义绑定和服务端口等和实现有关的内容。这里先不做讨论。

名称空间xmlns:soapenc在这个文档里也没有用到，所以先不解释了。

名称空间xmlns:tns1，在很多WSDL里这个名字都叫tns的，没有后面的数字1，不知道Axis为什么起这样的名字。不过没有关系，名称空间的名字本来就没有实际的意义，只是一个代号而已。tns是This NameSpace的缩写，用来对当前WSDL进行引用。由于一个WSDL映射一个包（package），所以Axis为我们生成的WSDL里，tns1的值（http://model.bookstore.com）包含java包（com.bookstore.model）的信息就是顺理成章的了。请注意，tns1的值和里的元素的targetNamespace值是相同的。

名称空间xmlns:wsdlsoap是在与soap绑定时使用的，例如、等元素会用到。

名称空间xmlns:xsd是对XML Schema中各种数据类型的引用，例如string、boolean等等。想知道XML Schema中一共都定义了哪些数据类型，只要查看该名称空间的值（http://www.w3.org/2000/10/XMLSchema）即可。

没想到只是名称空间就写了这么多，而WSDL的结构还有不少内容，所以还是分为两部分吧，下一篇说说这个WSDL中的各个元素的作用。

参考资料：

礼物 2007-11-24 23:42 发表评论

使用Axis发布简单的Web服务（补充）

礼物 — Sat, 24 Nov 2007 15:41:00 GMT

这篇帖子是对《使用Axis发布简单的Web服务》的补充。

可以看出，在Axis里书写deploy.wsdd并利用org.apache.axis.client.AdminClient发布，其主要工作就是把标签中的内容添加在server-config.wsdd里，所以一般直接编辑server-config.wsdd文件会更方便一些。不过当你还没有server-config.wsdd文件时，使用deploy.wsdd的方法会更方便些，因为AdminClient会帮你生成一些额外的xml元素（等等），而这些元素是必要的。

服务发布以后，就可以在IE浏览器里看到它的WSDL，一般是服务的URL后面加一个“?wsdl”，例如添加图书的WSDL可以通过http://localhost:8080/bookstore/services/BookSvc?wsdl看到。至于Java类是以何种规则映射到WSDL的，请参考JAX-RPC规范；WSDL本身的说明见这里；为了搞清生成的WSDL中各种URL格式的名称空间，最好对XML Schema有所了解，我觉得这篇文章还不错。

我们还可以通过IE浏览器直接调用服务，方法是在服务URL后加“method=xxx”，其中xxx是要调用的方法名称。例如可以通过http://localhost:8080/bookstore/services/BookSvc?method=addBook调用添加图书方法，按照我们的服务类，在Tomcat的控制台上应该可以看到打出了“Book has been added.”的字样。

因为添加图书方法的参数是一个自定义类型，所以在IE里调用时不能指定参数值（或者是可以以其他格式指定，但我还不知道）；如果参数是简单类型，就可以指定了。例如我们可以为BookSvc增加一个echo()方法，参数是一个java.lang.String类型的值，如下所示，然后重新编译并启动Tomcat（server-config.wsdd文件不必更改）。

public void echo(String str){
System.out.println("Hello "+str);
}

在IE里输入http://localhost:8080/bookstore/services/BookSvc?method=echo&str=Mike，就会看到Tomcat的控制台里打出了“Hello Mike”。如果有多个参数，只要把这些参数都列在URL里即可。

礼物 2007-11-24 23:41 发表评论

使用Axis发布简单的Web服务

礼物 — Sat, 24 Nov 2007 15:39:00 GMT

使用Axis，要发布一个Web服务非常简单，简直不能再简单了，尽管看起来过程和相关代码有些长。我这个帖子里用到了这些软件：Axis 1.1、Eclipse 2.1和Eclipse的Tomcat插件2.2（Sysdeo Tomcat plugin）。发布的方法如下：

我要发布的服务是一个图书商店，公布的方法有添加图书addBook、列表图书listBooks、删除图书deleteBook等等，为简单起见这里就只发布一个添加图书方法，因为其他方法的发布是类似的。

1、首先在Eclipse里新建一个名为bookstore的Tomcat工程，注意要安装了前面说的Tomcat插件才有这个选项的。如果没有安装可以建立一个java工程，然后手动建立必要的目录结构（WEB-INF等），并在Tomcat的server.xml里手动增加与项目对应的项。

2、接下来建立图书类（com.bookstore.model.Book），图书有名称、ISDN号和页数三个属性，这是一个Bean类，代码如下：

package com.bookstore.model;

public class Book {
    private String name;
    private String ISDN;
    private int page;

    public String getISDN() {
        return ISDN;
    }

    public String getName() {
        return name;
    }

    public int getPage() {
        return page;
    }

    public void setISDN(String string) {
        ISDN = string;
    }

    public void setName(String string) {
        name = string;
    }

    public void setPage(int i) {
        page = i;
    }

}

3、接下来建立用来提供服务的类（com.bookstore.BookSvc），这个类就是实际的功能类了，它里面只有一个public的addBook()方法，而它的参数只有一个就是要添加的图书。代码如下：

package com.bookstore;

import com.bookstore.model.Book;

public class BookSvc {

    public void addBook(Book book){
        //here you save a book into database
        System.out.println("Book has been added.");
    }
}

4、现在，把下载来的Axis解压缩到一个文件夹，这里假设你解到C:\axis-1_1。把C:\axis-1_1\webapps\axis\WEB-INF\lib目录下的所有.jar文件复制到你的这个web应用程序的WEB-INF\lib下，再把C:\axis-1_1\webapps\axis\WEB-INF目录下的web.xml复制到你的web应用程序的WEB-INF下。这个步骤相当于在你的web应用程序中配置了Axis。

5、为了让Axis知道你要发布哪些服务，你得在WEB-INF下建立一个名为server-config.wsdd的文件，内容如下：

xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<globalConfiguration>
  <parameter name="adminPassword" value="admin"/>
  <parameter name="attachments.Directory" value="C:\eclipse\workspace\bookstore\WEB-INF\attachments"/>
  <parameter name="attachments.implementation" value="org.apache.axis.attachments.AttachmentsImpl"/>
  <parameter name="sendXsiTypes" value="true"/>
  <parameter name="sendMultiRefs" value="true"/>
  <parameter name="sendXMLDeclaration" value="true"/>
  <parameter name="axis.sendMinimizedElements" value="true"/>
  <requestFlow>
   <handler type="java:org.apache.axis.handlers.JWSHandler">
    <parameter name="scope" value="session"/>
   handler>
   <handler type="java:org.apache.axis.handlers.JWSHandler">
    <parameter name="scope" value="request"/>
    <parameter name="extension" value=".jwr"/>
   handler>
  requestFlow>
globalConfiguration>
<handler name="LocalResponder" type="java:org.apache.axis.transport.local.LocalResponder"/>
<handler name="Authenticate" type="java:org.apache.axis.handlers.SimpleAuthenticationHandler"/>
<handler name="URLMapper" type="java:org.apache.axis.handlers.http.URLMapper"/>
<service name="Version" provider="java:RPC">
  <parameter name="allowedMethods" value="getVersion"/>
  <parameter name="className" value="org.apache.axis.Version"/>
service>
<service name="BookSvc" provider="java:RPC">
  <parameter name="allowedMethods" value="*"/>
  <parameter name="className" value="com.bookstore.BookSvc"/>
service>
<service name="AdminService" provider="java:MSG">
  <parameter name="allowedMethods" value="AdminService"/>
  <parameter name="enableRemoteAdmin" value="false"/>
  <parameter name="className" value="org.apache.axis.utils.Admin"/>
  <namespace>http://xml.apache.org/axis/wsdd/namespace>
service>
<transport name="local">
  <responseFlow>
   <handler type="LocalResponder"/>
  responseFlow>
transport>
<transport name="http">
  <requestFlow>
   <handler type="URLMapper"/>
   <handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler"/>
  requestFlow>
transport>
deployment>

这个文件里发布了三个服务：Version、AdminService和我们的BookSvc。还有一个方法可以生成这个文件，好象Axis推荐使用这种生成的方法，就是在同样目录下写一个deploy.wsdd文件（如果不想看可以直接跳到下一步），内容如下：

<deployment xmlns="http://xml.apache.org/axis/wsdd/"
            xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<service name="BookSvc" provider="java:RPC">
  <parameter name="className" value="com.bookstore.BookSvc"/>
  <parameter name="allowedMethods" value="*"/>
service>
deployment>

也就是说deploy.wsdd里只包含关于我们的服务的描述，确认Tomcat已经启动，然后在同一目录下用下面这个命令生成server-config.wsdd文件：

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

其中bookstore是我这个web应用程序的虚拟路径。

6、重新启动Tomcat，访问路径http://localhost:8080/bookstore/services，就可以看到现在发布了三个Web服务，如下图。点击每个服务后的wsdl链接可以看到对应的WSDL描述。

用axis发布webservices（五）

礼物 — Sat, 24 Nov 2007 07:01:00 GMT

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）

    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">

xmlns:ns1="http://hellking.webservices.com/">
   5000.0

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

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

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

ValueType="wsse:X509v3" wsu:Id="wsse-ee805a80-cd95-11d8-9cf9-fd6213c0f8be"
xmlns:wsu="http://schemas.xmlsoap.org/ws/2003/06/utility">MIICUjCCAbsCBEDB0GIwDQYJKoZIhvcNAQE…VkTkPw==

ZjRVnI2g7kcX0h9r4JtiltpYQPA=

moZ0d+8mH1kfNw0VEK39V0Td9EM=

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

2004-07-04T08:41:23Z

    xmlns:wsu="http://schemas.xmlsoap.org/ws/2003/06/utility">
    xmlns:ns1="http://hellking.webservices.com/">
   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部署代码



                value="com.hellking.study.webservice.WSSecurityServerHandler"/>
                value="K:\\jakarta-tomcat-5.0.16\\server.keystore"/>
                value="K:\\jakarta-tomcat-5.0.16\\server.truststore"/>





                value="com.hellking.study.webservice.WSSecurityServerHandler"/>
                value="K:\\jakarta-tomcat-5.0.16\\server.keystore"/>

                value="K:\\jakarta-tomcat-5.0.16\\server.truststore"/>





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(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脚本，修改了部分环境变量参数后，才能执行。

礼物 2007-11-24 15:01 发表评论

用axis发布webservices（四）

礼物 — Sat, 24 Nov 2007 07:00:00 GMT

使用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




    type="java:org.apache.axis.handlers.SimpleAuthenticationHandler"/>




在这个部署描述符中，指定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协议。

                                 maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" debug="0" scheme="https" secure="true"
               clientAuth="true" keystoreFile="K:\jakarta-tomcat-5.0.16\server.keystore" keystorePass="changeit"
                 truststoreFile="K:\jakarta-tomcat-5.0.16\server.truststore" truststorePass="changeit"
               sslProtocol="TLS" />


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

礼物 2007-11-24 15:00 发表评论

用axis发布webservices（三）

礼物 — Sat, 24 Nov 2007 06:46:00 GMT

一、对象参数的传递

首先是我们要传输的变量对象Order，代码如下：

package samples.userguide.example5;
public class Order
{
    private String customerName;

    private String shippingAddress;

    public String getCustomerName()
    { return customerName; }
    public void setCustomerName(String name)
    { customerName = name; }
}

要发布的services的代码如下：

package samples.userguide.example5;

public class BeanService
{
    public Order getNewOrder(Order order)
    {
        order.setCustomerName("liuyujun");
        return order;
    }

}

然后我们只要在配置文件server-config.wsdd里加入下面这段就可以发布了

特别要注意多了beanMapping这部分，qname指明我们用自己命名空间里的哪个对象，xmlns：myNS则指明了我们的命名空间，后面还一个指明了用到的对象类。

客户端调用程序：

package samples.userguide.example5;

public class Client
{

private final static String targetEndpointAddress = "http://localhost:8080/axis/services/OrderProcessor";
private final static QName qn = new QName( "urn:BeanService", "Order" );

public static void main(String [] args) throws Exception
{

//创建一个参数对象
Order order = new Order();
order.setCustomerName("Glen Daniels");

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

//注册对象类型
        call.registerTypeMapping(Order.class, qn,
                                 new org.apache.axis.encoding.ser.
                                 BeanSerializerFactory(Order.class, qn),
                                 new org.apache.axis.encoding.ser.
                                 BeanDeserializerFactory(Order.class, qn));
        call.setTargetEndpointAddress(new java.net.URL(targetEndpointAddress));

        call.setOperationName(new QName("OrderProcessor", "getNewOrder"));
            call.addParameter("order", qn, ParameterMode.IN);
            call.setReturnType(qn, Order.class);
         Order   newOrder = (Order) call.invoke(new Object[] {order});
        System.out.println("new custname:"+newOrder.getCustomerName());
    }
}
这样就能看到返回的效果了；

二、获得访问者信息

MessageContext context = MessageContext.getCurrentContext();
HttpServletRequest req = (HttpServletRequest) context.getProperty(HTTPConstants.MC_HTTP_SERVLETREQUEST);

这样就可以得到ruquest对象获得相关信息了，当然request的有些功能是用不了的，比如，getSession就是无效的

礼物 2007-11-24 14:46 发表评论

用axis发布webservices（二）

礼物 — Sat, 24 Nov 2007 06:45:00 GMT

1，什么是 Web 服务？

Web 是使应用程序可以以与平台和编程语言无关的方式进行相互通信的一项技术。Web 服务是一个软件接口，它描述了一组可以在网络上通过标准化的 XML 消息传递访问的操作。它使用基于 XML 语言的协议来描述要执行的操作或者要与另一个 Web 服务交换的数据。一组以这种方式交互的 Web 服务在面向服务的体系结构（Service-Oriented Architecture，SOA）中定义了特殊的 Web 服务应用程序。

2，什么是SOAP？

SOAP（Simple Object Access Protocol ）简单对象访问协议是在分散或分布式的环境中交换信息并执行远程过程调用的轻量级协议，是一个基于XML的协议。使用SOAP，不用考虑任何特定的传输协议（最常用的还是HTTP协议），可以允许任何类型的对象或代码，在任何平台上，以任何一种语言相互通信。

SOAP包括四个部分：SOAP封装(envelop)，封装定义了一个描述消息中的内容是什么，是谁发送的，谁应当接受并处理它以及如何处理它们的框架；SOAP编码规则（encoding rules），用于表示应用程序需要使用的数据类型的实例；SOAP RPC表示(RPC representation)，表示远程过程调用和应答的协定；SOAP绑定（binding），使用底层协议交换信息。

应用中比较关注的是envelop，由一个或多个Header和一个Body组成。

3，什么是Axis?

Axis本质上就是一个SOAP引擎（Apache Axis is an implementation of the SOAP），提供创建服务器端、客户端和网关SOAP操作的基本框架。但Axis并不完全是一个SOAP引擎，它还包括：

是一个独立的SOAP服务器。
是一个嵌入Servlet引擎（例如Tomcat）的服务器。
支持WSDL。
提供转化WSDL为Java类的工具。
提供例子程序。
提供TCP/IP数据包监视工具。

4， Axis相比Soap v2的优点：

Axis是第三代Apache SOAP的实现，从2000年起，SOAP v2开发小组开始讨论如何让Axis更加灵活、可配置，以及能够处理SOAP和来自W3C的各种XML标准。通过不断地讨论和代码编写，Axis目前相比SOAP V2取得了如下成果：

速度提高。 Axis通过基于事件的SAX对XML文档进行处理，从而在速度和效率上比Apache SOAP有所提高。

灵活性提高。

稳定性提高。

提供面向组件的部署。

提供一个简洁的传输抽象框架。其核心引擎完全于传输方式独立。从而使基于何种协议传输的选择更加灵活。

支持WSDL。包括WSDL和客户端代码生成等。

5，什么是WSDL？

WSDL（Web Service Description Language）Web服务器描述语言是用XML文档来描述Web服务的标准，是Web服务的接口定义语言，由Ariba、Intel、IBM、MS等共同提出，通过WSDL，可描述Web服务的三个基本属性：

·服务做些什么——服务所提供的操作（方法）

·如何访问服务——和服务交互的数据格式以及必要协议

·服务位于何处——协议相关的地址，如URL

WSDL文档以端口集合的形式来描述Web服务，WSDL 服务描述包含对一组操作和消息的一个抽象定义，绑定到这些操作和消息的一个具体协议，和这个绑定的一个网络端点规范。

6，什么是WSDD？

WSDD就是WEB服务分布描述（Web Service Deployment Descriptor）, 它定义了WEB服务的接口，如服务名、提供的方法、方法的参数等信息。

7，什么是UDDI？

UDDI就是统一描述、发现和集成（Universal Description, Discovery, and Integration）。UDDI用于集中存放和查找WSDL描述文件，起着目录服务器的作用。

Web 服务中的角色、操作和构件：

服务提供者。从企业的角度看，这是服务的所有者。从体系结构的角度看，这是托管访问服务的平台。
服务请求者。从企业的角度看，这是要求满足特定功能的企业。从体系结构的角度看，这是寻找并调用服务，或启动与服务的交互的应用程序。服务请求者角色可以由浏览器来担当，由人或无用户界面的程序（例如，另外一个 Web 服务）来控制它。
服务注册中心。这是可搜索的服务描述注册中心，服务提供者在此发布他们的服务描述。在静态绑定开发或动态绑定执行期间，服务请求者查找服务并获得服务的绑定信息（在服务描述中）。对于静态绑定的服务请求者，服务注册中心是体系结构中的可选角色，因为服务提供者可以把描述直接发送给服务请求者。同样，服务请求者可以从服务注册中心以外的其它来源得到服务描述，例如本地文件、FTP 站点、Web 站点、广告和服务发现（Advertisement and Discovery of Services，ADS）或发现 Web 服务（Discovery of Web Services，DISCO）。

8， AXIS的几种服务类型：

AXIS有四种service styles，分别是：RPC, Document, Wrapped, 和Message。最常用的就是RPC和Message。

RPC：在AXIS中是一个默认选项。当你部署的时候使用下列两种方式：或则，它遵循SOAP RPC和编码规则。每个RPC都包括一个表示名称的外部接点和一些表示参数的内部接点。AXIS会根据规则将一个XML（WSDL文件）文件转化成一个JAVA对象，并对对想赋上在文件中描述的值。也可以根据规则将一个JAVA对象转化成XML文件。

Document

适合于老的XML schema。

Wrapped

和DOCUMENT一样，适合于老的XML schema。

在大多书情况下，你不许要担心是DOCUMENT服务还是WRAPPED服务。

Message

以这种方式部署的话，会使AXIS失去意义，它使你的代码真正的用XML形式，而不需要转化成JAVA对象。以这种方式部署的有以下四种服务方法：

public Element [] method(Element [] bodies);

public SOAPBodyElement [] method (SOAPBodyElement [] bodies);

public Document method(Document body);

public void method(SOAPEnvelope req, SOAPEnvelope resp);

几种服务类型的主要区别：

基于RPC(远程过程调用)方式，这也是Web服务最常用的方式。面向消息/文档的的类型跟RPC不同的是它提供了一个更底层的抽象，要求更多的编程工作。客户端可以传入任何的XML文档，得到的响应不一定是SOAPEnvelope，可以返回任何它所需要的东西，甚至不返回。虽然这对开发者来说非常的灵活，但是这种通讯类型在实际的应用中并不常见。面向消息/文档的Web服务主要适合于下面几种情况，比如批量处理，基于表单的数据导入，有需要返回非XML数据时，Web服务器实现中要求直接访问传输层等等

9、java类与wsdl相互生成工具：

Axis提供了”WSDL2Java”工具，可以利用wsdl描述来产生服务的Java代理和框架(proxy and skeletons)。

Axis提供了”Java2WSDL”工具，可以由java类生成wsdl文件。

礼物 2007-11-24 14:45 发表评论

用axis发布webservices（一）

礼物 — Sat, 24 Nov 2007 06:44:00 GMT

首先到apache的网站下载axis的开发包，好久没看了，现在已经开始出2.0的啦，不过好像还不是很成熟，这里，我们还是用1.x的包。最新的是1.3的包（如果是用jbuilder的话是不需要再下载的，可以用其自带的工具发布的，做起来很简单，不过下面是以比较通用的方式来介绍）。

一、服务器端开发

首先编写服务端程序，这时我们完全不用考虑他是不是当作webservcies来发布的，因为在写法上没有什么不同。比如我们写了一个很简单的java程序，代码如下：

package samples.userguide.example2;
public class Calculator {
public int add(int i1, int i2)
{
return i1 + i2;
}
public int subtract(int i1, int i2)
{
return i1 - i2;
}
}

如果我们要把他发布成为services，首先需要把axis-1_3下的lib文件复制到我们的web服务的web-inf 的lib下。然后在web.xml里增加以下内容

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

    AxisServlet
    /servlet/AxisServlet

    AxisServlet
    *.jws

    AxisServlet
    /services/*

第一个是制定AxisServlet的类是必须的，余下的是配置servlet mapping的，可根据需要进行修改，比如不需要对 *.jws做mapping的时候就可以去掉相应的部分。完成了上边的必须配置我们就有两种方式来发布了：

1、动态发布，直接把Calculator 的java文件复制到webroot下，把Calculator.java更名为Calculator.jws，然后通过http://localhost:8080/Calculator.jws 访问就可以，通过 http://localhost:8080/Calculator.jws?wsdl 就可以看到相应的wsdl。这种方式调试起来比较麻烦，而且我再测试的时候也不能带package的信息，而且一些高级的配置无法实施，不建议采用。

2、静态发布，就是通过配置文件发布，这时候我们类的编译和普通的web方式没有不同，只是在web-inf下多了一个配置文件，默认的名称为server-config.wsdd

    xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"
    xmlns:handler="http://xml.apache.org/axis/wsdd/providers/handler" xmlns="http://xml.apache.org/axis/wsdd/">





























        http://xml.apache.org/axis/wsdd/









        http://example2.userguide.samples

其中要发布的每个service都需要加上一个service的节点描述，其他多余的servie节点可以删除的，这样重启tomcat后，我们就可以以http://localhost:8080/services/Calculator 来访问这个service了，同样以http://localhost:8080/services/Calculator?wsdl 访问到它的wsdl描述文件。

二、客户端开发

在开发工具中引进lib下的jar包；然后编写客户端程序

package samples.userguide.example2;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.encoding.XMLType;
import org.apache.axis.utils.Options;

import javax.xml.rpc.ParameterMode;

public class CalcClient
{
   public static void main(String [] args) throws Exception {
       try{
           String endpoint = "https://localhost:8440/services/Calculator";
           Integer i1 = new Integer(1);
           Integer i2 = new Integer(2);

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

           call.setTargetEndpointAddress(new java.net.URL(endpoint));
           call.setOperationName("add");
           call.addParameter("i1", XMLType.XSD_INT, ParameterMode.IN);
           call.addParameter("i2", XMLType.XSD_INT, ParameterMode.IN);
           call.setReturnType(XMLType.XSD_INT);

Integer ret = (Integer) call.invoke(new Object[] {i1, i2});

           System.out.println("Got result : " + ret);
       }
       catch(Exception e){
           e.printStackTrace();
       }
   }
}

其中 setOperationName就是指定执行的方法，addParameter就是指定参数
运行一下吧

礼物 2007-11-24 14:44 发表评论

Axis序列化/反序列化器开发指南

礼物 — Sat, 24 Nov 2007 06:42:00 GMT

前言
　　
　　Axis是Apache组织推出的SOAP引擎，Axis项目是Apache组织著名的SOAP项目的后继项目。Axis为开发者提供了大量的序列化/反序列化器，能够基本满足大部分应用。但在某些情况下，对特定的对象，现有的序列化/反序列化器不能胜任，于是只有开发人员自己实现专用于此对象的序列化/反序列化器插入到Axis中来完成序列化工作。考虑到Web Service是一门新兴技术，中文资料大多是泛泛的讲解，关于序列化/反序列化器的开发鲜有较为深入的介绍，本文提供一份较为完整的开发指南，并提供了一个十分有用的实现，即序列化JDOM模型的Element,使其可以通过Web 服务在网络上传输，我想这一扩展是许多采用JDOM作为XML解析工具的开发人员都梦寐以求的功能。通过本文的介绍和实例，希望能起到抛砖引玉的作用，读者在阅读完本文之后可以轻松的实现针对于任何非符合BEAN规范的对象的序列化/反序列化器。
　　
　　本文所面对的读者需要有一定的使用Axis做Web服务开发的开发经验，因此关于如何Axis的基础知识并不在本文的介绍范围，如果读者对此感兴趣，可以参考本文最后的参考资料部分，去相应的网站进行学习。
　　
　　序列化/反序列化器简介
　　
　　序列化/反序列化器在英文中的对应翻译是Serializer/Deserializer，一个序列化器的功能是遵循一定的映射规则和编码风格，将一种类型的JAVA对象通过某种特定的机制，转换成为XML描述的形式；反序列化器的功能是序列化器所做工作的逆操作，两者相辅相成，成对出现。Axis中的序列化/反序列化器采用设计范式中的工厂模式，每一个Serializer唯一对应一个SerializerFactory；每一个Deserializer唯一对应一个DeserializerFactory。一种类型的JAVA对象具体要采用哪个序列化/反序列化器需要在提供Web服务的服务器和调用Web服务的客户端分别配置，关于这一部分如何配置，我将在本文后面的内容中进行详细介绍。Axis已经为开发者提供了丰富的序列化/反序列化器,对于java的基本数据类型，绝大部分常用的容器类(比如数组类型，Vector类型等)都提供了实现，特别是提供了对W3C的DOM对象(比如Document, Element等)和符合Bean规范的JAVA对象提供了功能完善的序列化/反序列化器，因此我们在需要的时候只要在配置文件中配置一下就可以直接使用。如果对象中包含其它类型的对象，比如Vector中包含一组Bean对象，Axis会自动叠代的调用序列化器，最终拼装成唯一的XML表述。在还原成JAVA对象时，也遵循这样的叠代操作逆向进行。关于Axis到底内置了哪些序列化/反序列化器，您可以参照Axis的API文档中包org.apache.axis.encoding.ser下的类的名称"望文生义"的了解一下，在以后的开发中做到心中有数。但对于一些特殊类型的对象(其实我们自己开发的很大一部分类都是这种特殊类型的对象，很少有绝对符合Bean规范的)，需要通过Web服务进行传递，我们不得不开发自己的序列化/反序列化器。
　　
　　开发篇
　　
　　开发自己的序列化/反序列化器是一个激动人心的工作，但是却并不复杂,需要做的事情包括实现名成为org.apache.axis.encoding的包中的SerializerFactory，Serializer，DeserializerFactory和Deserializer这四个接口。下面我将结合一个实例来讲解序列化/反序列化器的开发方法，希望读者能够一边参看本文提供的源代码一边学习。
　　
　　JDOM作为一款比较"另类"的XML解析工具(因为它不符合W3C的DOM模型，自己另立一套)默默地占领着java世界里的xml解析器的半壁江山，由于其简洁的设计和方便灵活的API调用，已经渐渐成为了许多开发人员在进行XML开发的首选。但是Axis是建立在W3C的DOM模型的基础之上，师出名们正派，自然不屑与JDOM为伍。因此当开发人员想将自己已经写好的基于JDOM的应用模块采用Web服务的方式发布的时候，不可避免的会遇到如何将JDOM模型下的对象如Document, Element等序列化的问题。在软件工程师不会自己扩展Axis的序列化/反序列化器的时候，我们只能有两个办法达到这个目的，第一个就是更改以前应用模块内的API设计,使暴露的入口参数和返回值参数都是W3C的对象类型，但这种做法并不现实，因为这一应用模块往往不是独立存在，牵一发将动全身，导致旧有系统架构的崩塌；另一种做法就是为这个模块做一个代理类，它做的工作就对外接收或返回DOM模型的对象，对内转换成JDOM模型的对象，然后转发给应用模块，繁琐且效率低下。当我们向Axis注入了针对于JDOM模型的序列化/反序列化器后，这一工作便可以由Axis代劳了。下面我们将逐个开发这四个类：
　　
　　JDomElementSerializerFactory
　　
　　JDomElementSerializerFactory是一个工厂类，需要通过某种机制注册到Axis引擎(具体方法见下面"服务器端应用篇")；Axis通过调用它，来实例化JDomElementSerializer。Axis 提供了BaseSerializerFactory,这个类是一个抽象类，并实现其中包含了一些可重用的代码。我们自己开发的工厂类只需简单继承这个类就可以。构造函数中需要调用父类的构造函数将序列器类下面是它的源代码：
　　
　　package org.apache.axis.encoding.ser;
　　
　　public class JDomElementSerializerFactory
　　extends BaseSerializerFactory {
　　
　　public JDomElementSerializerFactory()
　　}
　　
　　JDomElementSerializer
　　
　　JDomElementSerializer实现org.apache.axis.encoding.Serializer接口，其核心API是serialize()，我们需要在这个方法的内部完成对JDOM模型的Element的序列化工作,序列化的结果要保存在入口参数传入的序列化上下文对象（SerializationContext）中：
　　
　　public void serialize(QName name, Attributes attributes, Object value,
　　SerializationContext context) throws java.io.IOException {
　　
　　if (!(value instanceof Element))
　　throw new IOException(
　　Messages.getMessage("cant Serialize Object"));
　　
　　//获取符合JDOM的Element对象
　　Element root=(Element)value;
　　
　　//输出到StringWriter
　　XMLOutputter outputter=new XMLOutputter();//创建一个JDOM的XML输出器
　　StringWriter sw=new StringWriter();
　　outputter.output(root,sw);
　　
　　//用支持W3C的DOM模型的Xerces解析器解析文本流
　　DOMParser parser=new DOMParser();//创建一个DOM的XML解析器
　　try {
　　parser.parse(new org.xml.sax.InputSource(
　　new java.io.StringReader(sw.toString())));
　　}catch (Exception ex) {
　　throw new java.io.IOException("序列化时产生错误");
　　}
　　
　　//获取符合DOM模型的Element对象
　　org.w3c.dom.Element w3c_root =
　　parser.getDocument().getDocumentElement();
　　
　　//放入序列化上下文对象中
　　context.startElement(name, attributes);
　　context.writeDOMElement(w3c_root);
　　context.endElement();
　　}
　　
　　JDomElementDeserializerFactory
　　
　　反序列化器的工厂类同序列化器的工厂类一样的设计，在此不在赘述。代码：
　　
　　package org.apache.axis.encoding.ser;
　　
　　public class JDomElementDeserializerFactory
　　extends BaseDeserializerFactory {
　　
　　public JDomElementDeserializerFactory()
　　
　　}
　　
　　JDomElementDeserializer
　　
　　用过SAX解析XML的读者，对反序列化的实现比较容易理解，反序列化也采用了消息触发的机制，我们只需继承org.apache.axis.encoding.DeserializerImpl类，并覆盖其中的onEndElement方法：
　　
　　/**
　　* 在元素结束触发反序列化的方法
　　* @param namespace String 命名空间
　　* @param localName String 本地名称
　　* @param context DeserializationContext 反序列化上下文
　　* @throws SAXException
　　*/
　　public void onEndElement(String namespace, String localName,
　　DeserializationContext context) throws SAXException {
　　
　　try {
　　//从反序列化上下文对象中获取原始的消息元素
　　MessageElement msgElem = context.getCurElement();
　　if (msgElem != null) {
　　MessageContext messageContext = context.getMessageContext();
　　Boolean currentElement = (Boolean) messageContext.getProperty(
　　DESERIALIZE_CURRENT_ELEMENT);
　　
　　//如果当前的消息元素本身需要反序列化
　　if (currentElement != null && currentElement.booleanValue()) {
　　org.w3c.dom.Element element = msgElem.getAsDOM();
　　org.jdom.input.DOMBuilder db=new org.jdom.input.DOMBuilder();
　　value=db.build(element);
　　messageContext.setProperty(DESERIALIZE_CURRENT_ELEMENT,
　　Boolean.FALSE);
　　return;
　　}
　　
　　//反序列化消息元素中的消息体
　　java.util.ArrayList children = msgElem.getChildren();
　　if (children != null) {
　　
　　//取得消息体
　　msgElem = (MessageElement) children.get(0);
　　if (msgElem != null) {
　　org.w3c.dom.Element ret = msgElem.getAsDOM();
　　org.jdom.input.DOMBuilder db=new org.jdom.input.DOMBuilder();

礼物 2007-11-24 14:42 发表评论

一个服务返回一个ArrayList，如何使用Axis序列化/反序列化啊

礼物 — Sat, 24 Nov 2007 06:41:00 GMT

我的代码如下：
这是发布到服务器上面的代码：
package com;
import java.util.*;
public class ArrayListService {
public ArrayList myAL(){
ArrayList myAL = new ArrayList ();
String str=new String( "这是一个WebService Of ArrayList ! ");
myAL.add(str);
return myAL;
}}

客户端的代码：
package com;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import java.util.*;

public class ArrayListClient {
public static void main(String[] args) {
try {
String wsdlUrl = "http://127.0.0.1:8080/axis/services/ArrayListService?wsdl ";

Service service = new Service();
Call call = null;
call = (Call) service.createCall();

call.setOperationName( "myAL ");
call.setTargetEndpointAddress(new java.net.URL(wsdlUrl));
//ArrayList al=(ArrayList)call.invoke(new Object[] {});
call.invoke(new Object[] {});
System.out.println( "请求信息： ");
call.getMessageContext().getRequestMessage().writeTo(System.out);
System.out.println( " ");
System.out.println( "响应信息： ");
call.getMessageContext().getResponseMessage().writeTo(System.out);
System.out.println( " ");
}
catch (Exception ex) { ex.printStackTrace(); }}}
打印出来的请求和响应消息也正常。
可是服务器返回的是一个ArrayList，当用这一句时“ArrayList al=(ArrayList)call.invoke(new Object[] {});”就报错：
java.lang.ClassCastException: [Ljava.lang.Object;
at com.ArrayListClient.main(ArrayListClient.java:17)
这是什么原因啊，如何把响应消息里面的数据返回成ArrayList呢？

注：server-config.wsdd

这是服务响应消息：

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

这是一个WebService Of ArrayList !

问题点数：20 回复次数：3

zzmdegm
剑心
等级：

发表于：2007-01-10 17:29:401楼得分:0

arrayList ,victor,set,map传输在j2ee web service标准里是有限制的，改用数组

初步搞定：（服务如何发布就不详细说了，网上很多）
java程序用 Axis做服务时自定义类实体的传送

核心代码：
QName qn = new QName( "urn:BeanService ", "MyArryBean ");
call.registerTypeMapping(MyArryBean.class, qn,
new BeanSerializerFactory(MyArryBean.class, qn),
new BeanDeserializerFactory(MyArryBean.class, qn));
这是在客户机端的代码，用于注册服务器上面的自定义类。然后就可以在客户端实例化这个类来使用。（如果MyArryBean 与服

务类不在同一个包里面，即服务需要用 import 来引用的话，这时就要用到：包名.MyArryBean.class）

在Axis服务端，注册自定义对象的序列化/反序列化器
服务器的server-config.wsdd:
...

...

服务器上面的自定义类（这个类要被传递给客户端）：MyArryBean.java
package com;
import java.io.Serializable;

public class MyArryBean implements Serializable{
private static final long serialVersionUID = -6414428095965735488L;
private String str= " ";
public MyArryBean(){}
public void setBean(String str){this.str=str;}
public String getBean(){return this.str;}
}

服务器上面的服务类：ArrayListService.java
package com;

public class ArrayListService {
//这里返回的是一个int数组
public int[] myAL(){
int myAL[] = new int[5];
for( int i=0;i <5;i++){
myAL[i]=i;
}
return myAL;
}
//这里返回的是一个自定义对象
public MyArryBean myAB(String myStr){
MyArryBean _myArryB=new MyArryBean();
_myArryB.setBean(myStr);
return _myArryB;
}
}

客户端代码：ArrayListClient.java
package com;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.encoding.ser.BeanDeserializerFactory;
import org.apache.axis.encoding.ser.BeanSerializerFactory;
import javax.xml.namespace.QName;

public class ArrayListClient {
public static void main(String[] args) {
try {
String wsdlUrl = "http://127.0.0.1:8080/axis/services/ArrayListService?wsdl ";
String nameSpaceUri = "http://localhost:8080/axis/services/ArrayListService ";

Service service = new Service();
Call call = null;
call = (Call) service.createCall();

//注册MyArryBean的序列化类型
QName qn = new QName( "urn:BeanService ", "MyArryBean ");
call.registerTypeMapping(MyArryBean.class, qn,
new BeanSerializerFactory(MyArryBean.class, qn),
new BeanDeserializerFactory(MyArryBean.class, qn));

//这里取得的是一个服务器int数组
call.setOperationName( "myAL ");
call.setTargetEndpointAddress(new java.net.URL(wsdlUrl));
int[] _resp = (int[])call.invoke(new java.lang.Object[] {});
for (int i=0;i <5;i++){
System.out.println( "int数组: "+_resp[i]);
}

//这里取得的是一个服务器自定义对象
//这里实例化服务器上面的映射的自定义类
MyArryBean CmyAB=new MyArryBean();
CmyAB.setBean( "这是的客户端实例化服务器的类！yes ");
System.out.println( "return value is " + CmyAB.getBean());
QName getmyABQn = new QName(nameSpaceUri, "myAB ");
call.setOperationName(getmyABQn);
call.setTargetEndpointAddress(new java.net.URL(wsdlUrl));
CmyAB = (MyArryBean) call.invoke(new Object[] { "这是调用服务器的类！web " });
System.out.println( "return value is " + CmyAB.getBean());

System.out.println( "请求信息： ");
call.getMessageContext().getRequestMessage().writeTo(System.out);
System.out.println( " ");
System.out.println( "响应信息： ");
call.getMessageContext().getResponseMessage().writeTo(System.out);
System.out.println( " ");
}
catch (Exception ex) { ex.printStackTrace(); }}}

运行结果：

int数组:0
int数组:1
int数组:2
int数组:3
int数组:4
return value is 这是的客户端实例化服务器的类！yes
return value is 这是调用服务器的类！web
请求信息：

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

xmlns:ns1= "http://localhost:8080/axis/services/ArrayListService ">

这是调用服务器的类！web

响应信息：

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

xmlns:ns1= "http://localhost:8080/axis/services/ArrayListService ">

xsi:type= "ns2:MyArryBean " xmlns:soapenc= "http://schemas.xmlsoap.org/soap/encoding/ "

xmlns:ns2= "urn:BeanService ">

这是调用服务器的类！web

zzmdegm
剑心
等级：

发表于：2007-01-19 16:48:182楼得分:0

正解：
这一版没有把它写成服务\客户端的形式

package com;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.*;

public class ArrayListSerializ implements Serializable{
/**
* 此例是一个序列化/反序列化的方法：
*
* 主要思想是把一个对象写入对象输出流，然后把这个流里面的数据导入字节数组输出流
* 再把字节数组输出流导入到字节数组。这时，由于byte[]数组是从ObjectOutputStream之后得来的，
* 那么是不可以new String(buff)的，因为其中包含了不可见字符，根本不是一个字符串。
* 只能用sun.misc.BASE64Encoder把它翻译成字符串形式。
* 至此，这就完成了序列化成字符串行式的过程
*
* 再通过sun.misc.BASE64Decoder().decodeBuffer把字符串转换成一个byte[]，
* 然后通过其反思路完成反序列化过程
*/
private static final long serialVersionUID = 1L;
private static void myArrayListSerializer()
{
ArrayList myAL=new ArrayList ();
myAL.add( "This is a serial programme.author: 张正明 ");
System.out.println( "ArrayList 's content： "+myAL.get(0));
//序列化使用的输出流
ObjectOutputStream OOS=null;
//序列化后数据流给ByteArrayOutputStream 来保存。
//ByteArrayOutputStream 可转成字符串或字节数组
ByteArrayOutputStream BAOS=new ByteArrayOutputStream();
//ByteArrayInputStream 可接收一个字节数组 "byte[] "。供反序列化做参数
ByteArrayInputStream BAIS=null;
//反序列化使用的输入流
ObjectInputStream OIS=null;
try {
OOS=new ObjectOutputStream(BAOS);
OOS.writeObject(myAL);
byte[] buff=BAOS.toByteArray();

/*由于byte[]数组是从ObjectOutputStream之后得来的，
*那么是不可以new String(buff)的，因为其中包含了不可见字符，根本不是一个字符串
*/
System.out.println( "序列化成一个byte[]的字符串形式 : "+buff);
//转换成字符串
sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder();
String Sstr = encoder.encode(buff);
System.out.println( "序列化成一个字符串： "+Sstr);
System.out.println( "检查序列化成一个字符串和序列化成一个byte[]是否为同一个内容： "+
Arrays.equals(buff, new sun.misc.BASE64Decoder().decodeBuffer(Sstr)));
OOS.close();

// 把字符串转成一个byte[]
byte[] DSbuff=new sun.misc.BASE64Decoder().decodeBuffer(Sstr);
System.out.println( "反序列化成一个byte[]字符串形式 : "+DSbuff);
//实现反序列化
BAIS=new ByteArrayInputStream(DSbuff);
OIS=new ObjectInputStream(BAIS);
ArrayList c=(ArrayList)(OIS.readObject());
System.out.println( "反序列化后取提ArrayList的数据： "+c.get(0));
OIS.close();
}
catch (IOException e) {e.printStackTrace();}
catch (Exception ex) {System.out.println( "序列化时产生错误 ");}
}
public static void main(String[] args){
myArrayListSerializer();
}
}

礼物 2007-11-24 14:41 发表评论

Axis1.4 开发笔记

礼物 — Thu, 22 Nov 2007 10:59:00 GMT

摘要: 今天终于搞定，贴出来分享一下 1、在www.apache.org上下载Axis1.4，将解压后的Axis目录文件复制到%TOMCATHOME%\webapps目录下2、重新启动Tomcat，访问http://localhost:8080/axis,如果能访问，表示Axis环境安装成功 3、在eclipse下建立webproject，将axis的jar包导入写2个JavaBean，分别叫做Per... 阅读全文

礼物 2007-11-22 18:59 发表评论

server-config.wsdd配置一例

礼物 — Thu, 22 Nov 2007 10:14:00 GMT

摘要: 阅读全文

礼物 2007-11-22 18:14 发表评论

J2EE Web服务开发系列之十二: 实现安全的AXIS Web服务，第1部分

礼物 — Sun, 18 Nov 2007 02:11:00 GMT

J2EE Web服务开发系列之十二: 实现安全的AXIS Web服务，第1部分

文档选项

未显示需要 JavaScript 的文档选项

将此页作为电子邮件发送

级别：初级

陈亚强 (cyqcims@mail.tsinghua.edu.cn), 高级软件工程师

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(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/*

回页首

使用SSL作为Web服务的传输协议

Web服务也可以使用SSL作为传输协议。虽然JAX-RPC并没有强制规定是否使用SSL协议，但在tomcat下使用HTTPS协议。

应用AXIS开始Web 服务之旅

礼物 — Sun, 18 Nov 2007 02:10:00 GMT

应用AXIS开始Web 服务之旅

文档选项

未显示需要 JavaScript 的文档选项

将此页作为电子邮件发送

级别：初级

刘冬 (winter.lau@163.com), 软件工程师

2003 年 7 月 01 日

本文介绍使用AXIS作为开发环境来体会Web服务的开发过程。

一．介绍

本文并不是想介绍Web服务的原理、系统架构等，我们假设您已经了解了关于Web服务的一些基本的概念、原理等知识。本文主要是针对那些已经了解Web服务概念，但是还没有亲身体会Web服务所带来令人欢欣鼓舞的特征的开发人员。在此我们认为你已经具备了Java、XML等基础知识，如果你还有其他开发环境的经验例如VB、VC那是再好不过的了。

1．Web服务

虽然我们并不想详细讲述Web服务的体系结构，但是大概的介绍一下还是有必要的。Web服务是一种新型的Web应用程序。不同于其他Web应用程序，它是自适应、自我描述、模块化的应用程序，并可以跨越Web进行发布、定位以及调用。简单的Web服务可以提供例如天气预报或者航班信息的服务。一旦部署了Web服务，其他的应用程序就可以发现和调用所部署的服务。

2．AXIS项目

Axis框架来自 Apache 开放源代码组织，它是基于JAVA语言的最新的 SOAP 规范（SOAP 1.2）和 SOAP with Attachments 规范（来自 Apache Group ）的开放源代码实现。有很多流行的开发工具都使用AXIS作为其实现支持Web服务的功能，例如JBuilder以及著名的Eclipse J2EE插件Lomboz。AXIS的最新版本是1.1，可以从 http://ws.apache.org/axis/index.html下载。下图是AXIS核心引擎的体系结构图：

图1

整个AXIS项目包括以下几个部分：

消息流子系统
消息流子系统提供了灵活的消息传递框架，这个消息传递框架包括处理程序、链、序列化程序和反序列化程序。处理程序是一个处理请求、响应和故障流的对象。处理程序可被组合在一起成为链，而且可以使用一个灵活的部署描述符来配置这些处理程序的顺序。
传输框架子系统
提供了一个传输框架，这个传输框架可以帮助您创建自己的可插式传输发送器和传输侦听器。
数据编码子系统
AXIS完全按照 XML Schema 规范提供各种数据类型的自动序列化，并且提供功能扩展接口来使用您自己定制的序列化器和反序列化器。
其他
AXIS完全支持 WSDL 以及日志记录、出错以及故障处理机制。它同时提供一些工具用来讲WSDL文档转换成客户端的调用框架以及根据类来产生WSDL定义文档。

AXIS目前版本支持的标准是：W3C SOAP 1.1 和 1.2；WSDL 1.1；SAAJ 1.1（SUN公司：SOAP with Attachments API for Java）；JAX-RPC（SUN公司：Java API for XML-Based RPC）1.0。

除了前面介绍的AXIS外，本文中还将会用到TOMCAT，这里不再另行介绍。另外为了演示Web服务真正与开发环境无关以及AXIS产生的是标准的、符合规范的Web服务，我们还将用到微软公司的SOAP TOOLKIT以及微软的开发环境VB和VC来做为Web服务的客户端。

回页首

二. 环境搭建

由于AXIS本身是基于JAVA语言开发的项目，并且是以Web应用形式发布的，因此它运行时需要一个应用服务器作为支撑。为了方便我们这里选用的是Tomcat。由于AXIS本身需要用到处理XML信息的包，所以我们建议使用JDK1.4并安装Tomcat 4.1.24。下面是环境搭建步骤，读取根据自身情况进行安装。

安装JDK1.4.1
安装Tomcat 4.1.24到C:\Tomcat并验证安装是否成功
下载AXIS项目打包文件axis-1_1.zip解压缩后将目录中的webapps目录下的axis子目录拷贝到C:\Tomcat\webapps下。
验证AXIS的安装：重新启动Tomcat服务器后打开浏览器输入网址http://localhost:8080/axis 后应该出现如下图所示页面，点击链接"Validate"来验证Axis所需的几个JAVA包是否齐全。

图2

点击超链接Validate后，AXIS会自动检查所需的每一个JAVA组件，这协组件分为：必需组件以及可选组件，必须保证所有必需组件都存在，如下图所示即为验证成功。

图3

回页首

三． Web Service服务端开发

经过了前两步之后我们就可以开始Web服务之旅了！大多数人在学习一种编程语言的第一步都是从Hello world程序开始的，我们也不例外。我们将提供这样一个Web服务，通过给它传入姓名，服务返回：你好[姓名]，欢迎来到Web服务的世界。这就是我们的需求。我们将马上根据AXIS的要求完成我们的需求，你就会发现原来Web服务可以这么简单！

编写JAVA类Hello.java，内容如下：

public class Hello{
                        public String hello(String name){
                        if(name==null)
                        name = "";
                        return "你好"+name+"，欢迎来到Web服务的世界！";
                        }
                        }

仅此而已，无需编译，将该文件改名为Hello.jws并拷贝到AXIS应用目录C:\Tomcat\webapps\axis下。

下面我们就可以测试该Web服务了，打开浏览器并输入刚刚创建的文件名对应的URL地址 http://localhost:8080/axis/Hello.jws 浏览器显示如下结果：

There is a Web Service here
                        Click to see the WSDL

点击页面上的链接查看该Web服务对应的WSDL信息如下所示（我们将在下一小节简单介绍WSDL）

到此我们已经完成了hello的Web服务了，那我们怎么告诉用户如何来使用该服务呢？我们只需要告诉用户我们的Web服务的URL地址： http://localhost:8080/axis/Hello.jws?wsdl 就可以了！下一节我们将介绍如何通过这个地址来访问对应的Web服务。

回页首

四． Web Service客户端开发

在这一节中我们将使用三种不同的语言来访问刚刚创建的Web服务，分别是JAVA、VB、VC。为了使用VB和VC访问Web服务，我们需要安装微软公司的Soap Toolkit 开发工具包，这个工具包可以从微软公司的主页

http://download.microsoft.com/download/xml/soap/2.0/W98NT42KMe/EN-US/SoapToolkit20.exe

下载，下载该软件包并使用默认方式安装即可。

在开始客户端开发之前有两个概念我们必须先粗略的介绍一下。

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消息，它们并不包含任何随机器或语言而变的元素。这就定义了一系列服务，截然不同的网站都可以实现。

1. JAVA客户端

使用AXIS的工具将使Web服务的访问和我们之前介绍的创建一个Web服务一样的简单。我们前面安装的AXIS环境中已经包含着这样的工具，它是一个JAVA类，类名为：org.apache.axis.wsdl.WSDL2Java。打开命令行窗口，转到AXIS目录下的WEB-INF子目录。确保Tomcat服务已经处于启动状态，键入命令：

Java -Djava.ext.dirs=lib org.apache.axis.wsdl.WSDL2Java http://localhost:8080/axis/Hello.jws?wsdl

该命令执行的结果是在当前所在目录下产生一个子目录 localhost/axis/Hello_jws，该目录下有四个JAVA源文件，它们分别是：

Hello.java 定义了Web服务接口，此例中只有一个hello方法。

HelloService.java 定义了用于获取Web服务接口的方法。

HelloServiceLocator.java 接口HelloService的具体实现。

HelloSoapBindingStub.java Web服务客户端桩，通过该类与服务器交互。

这四个JAVA类帮我们处理了大部分的逻辑，我们需要的仅仅是把这些类加到我们的项目然后创建一个我们自己的类来调用它们即可。为此我们新加一个类Main.java，为了方便，让这个类与刚产生的四个类都在同一个包下。内容如下：

//Main.java
                        package localhost.axis.Hello_jws;
                        public class Main{
                        public static void main(String[] args) throws Exception{
                        HelloService service = new HelloServiceLocator();
                        Hello hello = service.getHello();
                        System.out.println("Response:"+hello.hello("罐头"));
                        }
                        }

使用以下命令进行编译：

javac -classpath lib\axis.jar;lib\jaxrpc.jar localhost\axis\Hello_jws\*.java

如果编译没有问题的话执行该测试程序：

java -Djava.ext.dirs=lib -cp . localhost.axis.Hello_jws.Main//运行结果：Response:你好罐头，欢迎来到Web服务的世界！

在WSDL2Java工具自动产生的几个类中，类HelloServiceLocator中保存这一些跟服务器相关的信息，例如URL地址等，当服务器的地址更改后但是服务并没有改动的时候直接修改该文件中的字符串定义，而无需重新生成这几个类。具体需要修改的内容，打开该文件便可一目了然。

2. VB客户端

有了微软SOAP toolkit，用VB调用Web服务也是一件令人愉快的事情。

打开VB开发环境新建一个标准EXE项目，打开工程(Project)菜单并选择引用打开组件引用对话框如下图所示：找到并选中Microsoft Soap Type Library。

图 4

新建并编辑窗体如下图所示：

图 5

编辑按钮Call的点击事件处理程序如下：（注意窗体的控件名称要与程序中的名称对应）

Private Sub callBtn_Click()
                        '这种做法需要在工程中引用Soap Type Library
                        'Dim soap As MSSOAPLib.SoapClient
                        'Set soap = New MSSOAPLib.SoapClient
                        Dim soap
                        Set soap = CreateObject("MSSOAP.SoapClient")
                        On Error Resume Next
                        'soap.mssoapinit urlText.Text
                        Call soap.mssoapinit(urlText.Text)
                        If Err <> 0 Then
                        MsgBox "初始化SOAP失败： " + Err.Description
                        urlText.SetFocus
                        Else
                        If Len(Trim(nameText.Text)) = 0 Then
                        MsgBox "请输入您的姓名！"
                        nameText.SetFocus
                        Else
                        responseText.Text = soap.hello(nameText.Text)
                        End If
                        End If
                        End Sub

保存项目并运行，输入姓名并点击按钮Call。

3. VC客户端

打开VC开发环境，新建项目HelloClient，项目类型为 Win32 Console Application的空项目。新建C++ Source File文件名为：HelloSoap.cpp，编辑文件内容如下：

//#include "stdafx.h"
                        #include 
                        #import "msxml3.dll"
                        using namespace MSXML2;
                        //根据自己机器的情况修改下面语句中指定的路径
                        #import "C:\Program Files\Common Files\MSSoap\Binaries\mssoap1.dll" \
                        exclude("IStream", "ISequentialStream", "_LARGE_INTEGER", \
                        "_ULARGE_INTEGER", "tagSTATSTG", "_FILETIME")
                        using namespace MSSOAPLib;
                        void Hello(){
                        ISoapSerializerPtr Serializer;
                        ISoapReaderPtr Reader;
                        ISoapConnectorPtr Connector;
                        // Connect to the service
                        Connector.CreateInstance(__uuidof(HttpConnector));
                        Connector->Property["EndPointURL"] = "http://localhost:8080/axis/Hello.jws?wsdl";
                        Connector->Connect();
                        // Begin message
                        Connector->BeginMessage();
                        // Create the SoapSerializer
                        Serializer.CreateInstance(__uuidof(SoapSerializer));
                        // Connect the serializer to the input stream of the connector
                        Serializer->Init(_variant_t((IUnknown*)Connector->InputStream));
                        // Build the SOAP Message
                        Serializer->startEnvelope("","","");
                        Serializer->startBody("");
                        Serializer->startElement("hello","","","");
                        Serializer->startElement("name","","","");
                        Serializer->writeString("罐头");
                        Serializer->endElement();
                        Serializer->endElement();
                        Serializer->endBody();
                        Serializer->endEnvelope();
                        // Send the message to the web service
                        Connector->EndMessage();
                        // Let us read the response
                        Reader.CreateInstance(__uuidof(SoapReader));
                        // Connect the reader to the output stream of the connector
                        Reader->Load(_variant_t((IUnknown*)Connector->OutputStream), "");
                        // Display the result
                        printf("Response: %s\n", (const char*)Reader->RPCResult->text);
                        }
                        int main()
                        {
                        CoInitialize(NULL);
                        Hello();
                        CoUninitialize();
                        return 0;
                        }

编译并运行该项目。

本节只是为了演示如果通过VC来访问使用AXIS创建的Web服务，至于Soap toolkit的具体使用请参照soap toolkit的帮助手册，其他语言的访问请查阅相关的文档。

回页首

五. AXIS集成

为了让我们的WEB应用程序支持Web服务功能，我们需要将AXIS集成到我们的应用程序中。集成AXIS很简单，首先需要拷贝AXIS用到的几个JAR包文件，这些文件都在[AXIS]\WEB-INF\lib目录下，将这些文件拷贝到我们自己的应用目录下的WEB-INF\lib。另外如果你用的不是TOMCAT服务器那就需要拷贝activation.jar，这个JAR文件可以在[TOMCAT]\common\lib目录下找到！

拷贝完JAR文件后就是web.xml的配置了，只需要把AXIS中的web.xml中的配置信息添加到我们自己应用程序中的web.xml中即可。最重要的是下面的内容：


                        AxisServlet
                        Apache-Axis Servlet
                        
                        org.apache.axis.transport.http.AxisServlet
                        
                        
                        
                        AxisServlet
                        *.jws
                        
                        
                        wsdl
                        text/xml
                        
                        
                        xsd
                        text/xml

回页首

六总结

到此文章告一段落，通过以上的演练，我相信你已经对Web服务有一个感性的认识，但是这个仅仅是开始，我们也只是很简单的介绍了Web服务的一些基本概念并演示了一个无法再简单的例子。Web服务还有很多其他高级的内容例如复杂类型、数据安全等没有涉及到，不过没有关系，万事开头难，希望本文能够促进大家理解和应用下一代的应用模式并给还没有动手试验的开发人员开一个好头。

参考资料

IBM开发者站点Web服务专区 http://www.ibm.com/developerworks/cn/xml
Apache网站AXIS项目 http://ws.apache.org/axis/
Apache Tomcat http://jakarta.apache.org/tomcat
微软公司MSDN站点 http://www.microsoft.com/china/msdn
微软公司Soap Toolkit 2.0下载地址 http://download.microsoft.com/download/xml/soap/2.0/W98NT42KMe/EN-US/SoapToolkit20.exe
AXIS打包下载地址： http://ws.apache.org/axis/dist/1_1/
W3C之Web服务 http://www.w3.org/2002/ws/

礼物 2007-11-18 10:10 发表评论

使用Axis开发WebService程序-（转载）

礼物 — Sun, 18 Nov 2007 02:08:00 GMT

今天是感恩节，差点又要在公司加班了。好在Web Service程序并不是特别难搞，下午终于在eclipse下调通过了，正确产生了服务器端和客户端的Java代码，apache的东西的确很不错。

　　说道Web Service的程序开发，八个月前我加班调试公司和中国电信的商务领航系统的接口的时候，用的就是Web Service，Web Service有很多优点，使用Web Service可以在不同编程语言间实现数据交换，而我那时对Web Service也不熟，就由同事帮我生成了一大堆Web Service的框架代码，我则只单独开发业务代码。

　　这次的另外一个项目也要用Web Service了，不过人手也少了，没有人帮做Web Service了，只好自己动手。

　　好在开发前，有个同事先给我们不熟悉Web Service的程序员进行了一些培训，我才知道原来以前的Web Service都是可以自动生成代码的，而且也不难，试了一个下午客户端和服务器端的Web Service代码就都调试通过了，真不错。

　　为了更多喜爱开发的程序员也能迅速了解Web Service的开发，我这里整理了一些通过Axis开发Web Service的一些要点，希望能让不熟悉Web Service的开发人员能够迅速掌握Web Service。

　　一、Axis环境的安装

　　1、安装环境 J2SE SDK 1.4，Tomcat 5.0，eclipse 3.2。

　　2、到 http://xml.apache.org 网站下载Axis安装包。

　　3、将Axis相关包文件放在WEB-INF\lib目录下。

　　4、Axis可选的包：activation.jar； mail.jar； xmlsec-1.4.Beta1.jar拷贝到WEB-INF目录下，生成客户端时候需要使用。

　　Axis支持三种web service的部署和开发，分别为：

　　1、Dynamic Invocation Interface （DII）

　　2、Dynamic Proxy方式

　　3、Stubs方式

　　前两种方式我就不介绍了，同事告诉我他们自己都不使用前两种方式，他们建议我们使用Stubs方式，因此我就主要就介绍一下第三种方式。注意，我自己的Java源代码是放在D：\workspace\test\目录下，Axis相关包文件放在D：\workspace\test\WEB-INF目录下。

　　二、编写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、编写wsdd文件

　　deploy.wsdd文件内容如下：

　　3、发布服务：

　　编辑一个deploy.bat，Axis_Lib为axis.jar路径。内容如下：

set Axis_Lib=D:\workspace\test\WEB-INF\lib
set Java_Cmd=java -Djava.ext.dirs=%Axis_Lib%
set Axis_Servlet=http://localhost:8080/test/servlet/AxisServlet

礼物 2007-11-18 10:08 发表评论