- 浏览: 135389 次
- 性别:
- 来自: 上海
-
文章分类
最新评论
-
兰博基尼：
...
缓冲和缓存的区别是什么？Cache 和 Buffer 都是缓存，主要区别是什么 -
jiaer0910：
为什么会出现类型转换的错
Java导出Word文档(可设置字体) -
苍天百合：
引用[u][/u] ...
Java导出Word文档(可设置字体) -
xujijun11：
怎么是excel,晕了
Java导出Excel文档 -
xujijun11：
很好，学习了
Java导出Excel文档
操作系统：本教程使用的为 Windows Vista Enterprise, 如果您的系统是 Linux 的，请选择下载对应版本的其他工具，包括开发工具、Java EE 服务器、Apache Ant、SoapUI。
开发工具：Eclipse IDE for SOA Developers 版本，请到 http://www.eclipse.org/downloads/网站下载，这个版本的 Eclipse 工具集成了一些 Web Services 插件，对于开发 Web Services 提供了一些便利。
Java EE 服务器：Apache-Tomcat-6.0.18，可以到 http://tomcat.apache.org/download-60.cgi下载，使用 5.0 以上的任何版本都可以的，当然，您也可以使用 Jboss 等其他 Java EE 服务器。
Jdk:到 http://java.sun.com 下载 1.5.0_17 版本，下载后安装即可。
其他工具：Apache Ant vsersion “1.6.5”用于代码打包，到 http://ant.apache.org/下载；SoapUI 3.5 用于 Web Services 的测试，到 http://www.soapui.org/下载，任何版本都可以，对于本教程没有影响。
Web Services 是建立可交互操作的分布式应用程序的新平台 ; Web Services 平台是一套标准，它定义了应用程序如何在 Web 上进行交互操作 , 你可以用任何你喜欢的语言，在任何你喜欢的平台上写 Web Services, 只要我们可以通过 Web Services 标准对这些服务进行查询和访问。简单的说 Web Service 就是一些模块化的应用程序，这些应用程序能在 Web 上描述、发布、定位和调用。实现 Web Services 的方式也有很多种，本文也不一一介绍了，找几个我认为最常用的几种实现方式来与大家分享，首先介绍用 Axis 来实现 Web Services 的开发，然后介绍用 CXF 来开发 Web Services。对于每一种实现方式，我都以一种 step by step 的方式给大家用实例来讲解，从工程的建立一直到 Services 的交付使用，大家也可到网上搜索下这方面的相关教程，很多，但是大部分都是单单教你怎么来开发一个 Service，怎样来测试？怎样来验证是否可以交付给用户使用了？讲的很少，更不用说项目后期的自动化测试了，闲话少说，下面我们就进入 Service 的具体开发实例讲解，每一个实例都配以详细的分析过程。
- Apache Axis2 1.5 build (30-04-2009) 到 http://ws.apache.org/axis2下载；
- 将 axis2.war 复制到 apache-tomcat-6.0.18 的 webapps 下；
axis2.war 这个包为我们提供了 Service 运行的基本环境，包括 Service 依赖的 jar 包，Service 的解析等，我们只需要将开发好的 Service 打包成 aar 包然后按照它的目录结构放进去就可以了，语言有时候是平白的，下面我们还是通过一个具体实例来讲解下。
新建一个 Java project, 命名为 ws_axis_example
然后新建一个 AxisService 类，我们下面就是将这个类发布成 Web Services，类的代码列表如清单 1 所示：
package org.ibm.axis.service;
public class AxisService {
public String sayHello(String EmpName){
return "Hello "+EmpName;
}
}
|
可以看到，这个AxisService 类就是一个普通的 Java Bean, 没有什么特殊的，就是这么简单。
接下来我们要新建一个 service.xml 文件，这个文件是最重要的，因为它定义了所有要发布出去的 service，文件内容如清单 2 所示：
<service name="AxisService" scope="application">
<description>AxisService</description>
<messageReceivers>
<messageReceiver
mep="http://www.w3.org/2004/08/wsdl/in-only"
class="org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver"/>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out"
class="org.apache.axis2.rpc.receivers.RPCMessageReceiver"/>
</messageReceivers>
<parametername="ServiceClass">
org.ibm.axis.service.AxisService</parameter>
</service>
然后再新建一个 build 文件，命名为 build.xml, 内容如清单 3 所示：
|
<project name="service" basedir="." default="makeService">
<property name="dist.dir" value="dist" />
<property name="dist.dir.classes" value="${dist.dir}/classes" />
<property name="AXIS2_HOME"
value="E:\gdcc\tools\axis2-1.5-bin\axis2-1.5"/>
<path id="build.class.path">
<fileset dir="${AXIS2_HOME}/lib">
<include name="*.jar" />
</fileset>
</path>
<target name="makeService" depends="">
<copy file="src/services.xml" tofile="${dist.dir.classes}/META-INF/services.xml"
overwrite="true" />
<javac srcdir="src" destdir="${dist.dir.classes}"
includes="org/ibm/axis/service/*">
<classpath refid="build.class.path" />
</javac>
<jar basedir="${dist.dir.classes}" destfile="${dist.dir}/AxisService.aar" />
</target>
</project>
熟悉 ant 的开发人员对于上面的脚本应该很容易看明白，这里就不详细解释了，主要功能就是根据 Axis 的标准打成 aar 包。
到目前为止 ws_axis_example 的目录结构如图 2 所示：
|
运行 ant 脚本， E:\gdcc\tools\apache-ant-1.6.5\bin\ant -f E:\ws_IBM\ws_axis_example\build.xml 注：ant 放在了 E:\gdcc\tools\apache-ant-1.6.5 目录下。执行结果如下：
Buildfile: E:\ws_IBM\ws_axis_example\build.xml
makeService:
[copy] Copying 1 file to E:\ws_IBM\ws_axis_example\dist\classes\META-INF
[jar] Building jar: E:\ws_IBM\ws_axis_example\dist\AxisService.aar
BUILD SUCCESSFUL
Total time: 3 seconds
|
然后我们将 AxisService.aar 压到axis2.war 的 WEB-INF\services 目录下，结果如图 3 所示：
图 3. 加入 AxisService.aar 后 axis2.war 的 services 包含的文件
接下来，启动 Tomcat，待启动完成后在浏览器中输入 http://localhost:8080/axis2/services/AxisService?wsdl，如果显示结构如清单 4 所示，则表示我们的 Service 发布成功了，否则按照以上步骤仔细检查下。
<?xml version="1.0" encoding="UTF-8" ?> - <wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" xmlns:ns1="http://org.apache.axis2/xsd" xmlns:wsaw="http://www.w3.org/2006/05/addressing/wsdl" xmlns:ns="http://service.axis.ibm.org" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" targetNamespace="http://service.axis.ibm.org"> <wsdl:documentation>AxisService</wsdl:documentation> - <wsdl:types> - <xs:schema attributeFormDefault="qualified" elementFormDefault="qualified" targetNamespace="http://service.axis.ibm.org"> - <xs:element name="sayHello"> - <xs:complexType> - <xs:sequence> <xs:element minOccurs="0" name="args0" nillable="true" type="xs:string" /> </xs:sequence> </xs:complexType> </xs:element> - <xs:element name="sayHelloResponse"> - <xs:complexType> - <xs:sequence> <xs:element minOccurs="0" name="return" nillable="true" type="xs:string" /> </xs:sequence> </xs:complexType> </xs:element> </xs:schema> </wsdl:types> - <wsdl:message name="sayHelloRequest"> <wsdl:part name="parameters" element="ns:sayHello" /> </wsdl:message> - <wsdl:message name="sayHelloResponse"> <wsdl:part name="parameters" element="ns:sayHelloResponse" /> </wsdl:message> - <wsdl:portType name="AxisServicePortType"> - <wsdl:operation name="sayHello"> <wsdl:input message="ns:sayHelloRequest" wsaw:Action="urn:sayHello" /> <wsdl:output message="ns:sayHelloResponse" wsaw:Action="urn:sayHelloResponse" /> </wsdl:operation> </wsdl:portType> . . . . . . </wsdl:definitions> |
因为 WSDL 文件太长，我们只截取其中一部分内容，我们主要看一下 <wsdl:types>、sayHelloRequest 和 sayHelloResponse 的内容，从中我们可以知道这个 service 的 Namespace 是http://service.axis.ibm.org, 暴露的 operation 是sayHello,request 需要的是一个字符串参数，response 是一个字符串类型。下面我们来测试下这个 service 是否可用。
现在比较流行 TDD 开发模式，虽然我们不是按照这个模式开发的，但是单元测试也应是必不可少的。Web Services 的单元测试究竟怎么来写呢？其实他和普通 bean 的单元测试没什么区别，下面我们就用 JUnit 来测试下上面的 service。
新建一个 Java Project, ws_client, 然后新建 AxisServiceTest 类，AxisServiceTest 代码如清单 5 所示：
package org.ibm.axis.service.client;
import javax.xml.namespace.QName;
import junit.framework.Assert;
import org.apache.axis2.AxisFault;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.rpc.client.RPCServiceClient;
import org.junit.Test;
public class AxisServiceTest {
private static Object[] initAxisTest(QName testMethod, Object[] opArgs,
Class[] returnTypes) throws AxisFault {
RPCServiceClient serviceClient = new RPCServiceClient();
Options options = serviceClient.getOptions();
EndpointReference targetEPR = new EndpointReference(
"http://localhost:8080/axis2/services/AxisService");
options.setTo(targetEPR);
Object[] response = serviceClient.invokeBlocking(testMethod, opArgs,
returnTypes);
return response;
}
@Test
public void testSayHello() throws AxisFault {
Object[] opSayHelloArgs = new Object[] { "Mr Jack" };
Class[] returnTypes = new Class[] { String.class };
QName opSayHello = new QName("http://service.axis.ibm.org", "sayHello");
Object[] response = initAxisTest(opSayHello, opSayHelloArgs,returnTypes);
String result = (String) response[0];
Assert.assertEquals("Hello Mr Jack", result);
}
}
|
对于 EndpointReference 和 QName 我们都可以从 WSDL 中得到，我们在上面也简单介绍了。输入参数是"Mr Jack"，输出是 String 类型，期望结果与"Hello Mr Jack"相同，运行 JUnit. 结果如图 4 所示：令人兴奋的绿色长条，测试成功。
下面我们简单介绍下用 SoapUI 来测试 AxisService。 新建一个 soapUI Project,Project 名字为 WS_IBM, 在 Initial WSDL/WADL: 中输入 http://localhost:8080/axis2/services/AxisService?wsdl 完成后的界面如图 5 所示：
SOAP request 如清单 6 所示：
<soap:Body>
<ser:sayHello>
<!--Optional:-->
<ser:args0>Mr Jack</ser:args0>
</ser:sayHello>
</soap:Body>
点击运行后 SOAP response 如清单 7 所示：
|
<soapenv:Body>
<ns:sayHelloResponse xmlns:ns="http://service.axis.ibm.org">
<ns:return>Hello Mr Jack</ns:return>
</ns:sayHelloResponse>
</soapenv:Body>
|
不知道您发现没有，我们在用 JUnit 测试和用 soapUI 测试时输入的参数值是一样的，得到的结果也完全一样，至此 AxisService 的开发与测试就完成了，是不是很简单？至于复杂的 Service 也都是按照这几步开发的，第一步，开发 Services；第二步，完成 service.xml 文件；第三步，发布 Service；关键的三步，但是我们也不能忘记最后一步，就是 Service 的测试，这是检查 Service 是否可用的最基本测试。以上的测试过程我们在讲自动化测试时，大部分都会用到的。上面我们提到 WSDL 文件，除了通过上面这个方式可以生成 WSDL 文件外，我们还可以通过命令行方式来生成 WSDL 文件，如下所示： E:\gdcc\tools\axis2-1.5-bin\axis2-1.5\bin\java2wsdl -cp . -cn org.ibm.axis.service.AxisService -o E:/ -of AxisService.wsdl 生成的 WSDL 文件放在了 E 盘下，名称为 AxisService.wsdl。下面我们在学习下用 CXF 怎样来开发 service 的。
新建一个 Java project 工程，命名为 ws_cxf_example, 创建 service 类，CXFService.java 和 CXFServiceImpl.java, 代码分别见清单 8 和清单 9 所示：
package org.ibm.cxf.service;
public interface CXFService {
public String sayHello(String name);
}
|
package org.ibm.cxf.service.impl;
import org.ibm.cxf.service.CXFService;
public class CXFServiceImpl implements CXFService{
public String sayHello(String name) {
return "Hello "+name;
}
}
|
接下来，我们要新建一个 cxf-servlet.xml 和 web.xml 文件，文件内容分别如清单 10 和清单 11 所示：
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:simple="http://cxf.apache.org/simple" xmlns:soap="http://cxf.apache.org/bindings/soap" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://cxf.apache.org/bindings/soap http://cxf.apache.org/schemas/configuration/soap.xsd http://cxf.apache.org/simple http://cxf.apache.org/schemas/simple.xsd"> <simple:server id="CXFservice" serviceClass="org.ibm.cxf.service.CXFService" address="/CXFService"> <simple:serviceBean> <bean class="org.ibm.cxf.service.impl.CXFServiceImpl" /> </simple:serviceBean> </simple:server> </beans> |
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.// DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-app> <display-name>cxf</display-name> <description>cxf</description> <servlet> <servlet-name>cxf</servlet-name> <display-name>cxf</display-name> <description>Apache CXF Endpoint</description> <servlet-class>org.apache.cxf.transport.servlet.CXFServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>cxf</servlet-name> <url-pattern>/services/*</url-pattern> </servlet-mapping> <session-config> <session-timeout>30</session-timeout> </session-config> </web-app> |
最后我们还是需要新建一个 ant 脚本来打包，build.xml，其脚本如清单 12 所示：
清单 12. build.xml for CXFService
<project name="service" basedir="." default="war">
<property name="dist.dir" value="${basedir}/WEB-INF" />
<property name="dist.dir.classes" value="${dist.dir}/classes" />
<path id="build.class.path">
<fileset dir="${basedir}/lib">
<include name="*.jar" />
</fileset>
</path>
<target name="war" depends="">
<javac srcdir="src" destdir="${dist.dir.classes}"
includes="org/ibm/cxf/service/*/*">
<classpath refid="build.class.path" />
</javac>
<war destfile="${dist.dir}/cxf.war" webxml="${dist.dir}/web.xml">
<classes dir="${dist.dir.classes}" />
<lib dir="${basedir}/lib" />
<webinf dir="${dist.dir}">
<include name="cxf-servlet.xml" />
</webinf>
</war>
</target>
</project>
|
运行 ant 脚本，将生成的 cxf.war 包放到 tomcat 的部署目录下，启动 tomcat，待启动完成后，我们在浏览器中输入 http://localhost:8080/cxf/services/CXFService?wsdl 将显示如下信息：
<?xml version="1.0" encoding="UTF-8" ?> - <wsdl:definitions name="CXFService" targetNamespace="http://service.cxf.ibm.org/" xmlns:ns1="http://schemas.xmlsoap.org/wsdl/soap/http" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://service.cxf.ibm.org/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> - <wsdl:types> - <xsd:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="http://service.cxf.ibm.org/" xmlns:tns="http://service.cxf.ibm.org/" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <xsd:element name="sayHello" type="tns:sayHello" /> …… </wsdl:definitions> |
</wsdl:definitions>
出现如上信息表示 service 发布成功了，关于 service 的详细信息在这个 WSDL 文件中都有定义，如出现问题请仔细检查以上步骤。
下面我们测试下 service 是否可用。
新建一个 JUnit 测试类 CXFServiceTest，代码如清单 13 所示：
package org.ibm.axis.service.client;
import junit.framework.Assert;
import org.apache.cxf.frontend.ClientProxyFactoryBean;
import org.ibm.cxf.service.CXFService;
import org.junit.Test;
public class CXFServiceTest {
@Test
public void testSayHello(){
ClientProxyFactoryBean factory = new ClientProxyFactoryBean();
factory.setServiceClass(CXFService.class);
factory.setAddress("http://localhost:8080/cxf/services/CXFService");
CXFService client = (CXFService) factory.create();
String response = client.sayHello("jack");
Assert.assertEquals("Hello jack", response);
}
}
|
其中 Address 可以从上面的 WSDL 文件中得到。
运行 JUnit test, 结果如图 6 所示：
SoapUI 的测试和 Axis 的是一样的。右击 WS_IBM 选择 Add WSDL，在 WSDL Location 输入框中输入 http://localhost:8080/cxf/services/CXFService?wsdl 输入参数 jack, 点击运行，如果看到 response 信息是 Hello jack, 恭喜你，成功了。
<soapenv:Body>
<ser:sayHello>
<!--Optional:-->
<ser:arg0>jack</ser:arg0>
</ser:sayHello>
</soapenv:Body>
|
清单 14. CXFService response
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<ns1:sayHelloResponse xmlns:ns1="http://service.cxf.ibm.org/">
<return xmlns="http://service.cxf.ibm.org/">Hello jack</return>
</ns1:sayHelloResponse>
</soap:Body>
</soap:Envelope>
|
使用 spring 框架来集成 Web Services 开发
Sping 框架是当今比较流行的，讲 Web Services 不能不提一下它，那么 Web Services 又是怎样与 Spring 框架集成开发的呢？下面我们通过一个例子来具体讲解下。
新建 ws_cxf_with_spring 工程 , 然后新建 service 类 SpringService.java 和SpringServiceImpl.java, 一个是接口类，一个是实现类，类代码详见清单 15 和清单 16.
package org.ibm.spring.service;
import javax.jws.WebService;
@WebService
public interface SpringService {
String sayHello(String name);
}
|
清单 16. SpringServiceImpl.java 代码
package org.ibm.spring.service.impl;
import javax.jws.WebService;
import org.ibm.spring.service.SpringService;
@WebService(endpointInterface = "org.ibm.spring.service.SpringService")
public class SpringServiceImpl implements SpringService {
public String sayHello(String name) {
return "Hello " + name;
}
}
|
注意，这里我们使用了 annotation 来开发 Web Services 而不是通过在 cxf-servlet.xml 增加 service 的定义来实现的。两种实现方式各有利弊，选择自己熟悉的，感觉舒服的就可以了。 接下来就是编写两个我们比较熟悉的文件 beans.xml 和 web.xml, 代码见清单 17 和清单 18.
<?xml version="1.0" encoding="UTF-8"?> <!-- START SNIPPET: beans --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd"> <import resource="classpath:META-INF/cxf/cxf.xml" /> <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" /> <import resource="classpath:META-INF/cxf/cxf-servlet.xml" /> <jaxws:endpoint id="springService" implementor="org.ibm.spring.service.impl.SpringServiceImpl" address="/SpringService" /> </beans> |
这个 beans.xml 文件是 spring 必须的，注意其中的 address="/SpringService"，我们就是通过这个地址访问 service 的，通过 implementor 指定具体的实现 Bean, 是不是很简单。
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/beans.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>CXFServlet</servlet-name>
<display-name>CXF Servlet</display-name>
<servlet-class>
org.apache.cxf.transport.servlet.CXFServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
|
最后编写一个 build.xml 文件，用于打包，脚本见清单 19.
<project name="service" basedir="." default="war">
<property name="dist.dir" value="${basedir}/WEB-INF" />
<property name="dist.dir.classes" value="${dist.dir}/classes" />
<path id="build.class.path">
<fileset dir="${basedir}/lib">
<include name="*.jar" />
</fileset>
</path>
<target name="war" depends="">
<javac srcdir="src" destdir="${dist.dir.classes}"
includes="org/ibm/spring/service/*/*">
<classpath refid="build.class.path" />
</javac>
<war destfile="${dist.dir}/cxfWithSpring.war"
webxml="${dist.dir}/web.xml">
<classes dir="${dist.dir.classes}" />
<lib dir="${basedir}/lib" />
<webinf dir="${dist.dir}">
<include name="beans.xml" />
</webinf>
</war>
</target>
</project>
|
运行 ant 脚本，然后将 cxfWithSpring.war 放到 Tomcat 的部署目录下，运行 Tomcat, 待 server 启动完成后，输入 http://localhost:8080/cxfWithSpring/SpringService?wsdl，将会看到 WSDL 文件 , 这里就不列出来了。
这里我们只用 SoapUI 来看下，发布的 service 是否可以正常访问，是否可以得到期望的结果，至于开发客户端的单元测试请读者自行按照上面的代码来完成。
将 http://localhost:8080/cxfWithSpring/SpringService?wsdl 加入到 WS_IBM 这个 soapUI 工程，然后在 request 的参数处输入 Jack, 如果 response 是 Hello Jack, 表示 SpringService 一切正常，可以使用了。
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:ser="http://service.spring.ibm.org/">
<soapenv:Header/>
<soapenv:Body>
<ser:sayHello>
<arg0>Jack</arg0>
</ser:sayHello>
</soapenv:Body>
</soapenv:Envelope>
|
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<ns2:sayHelloResponse xmlns:ns2="http://service.spring.ibm.org/">
<return>Hello Jack</return>
</ns2:sayHelloResponse>
</soap:Body>
</soap:Envelope>
|
现在有这么个场景，假如我们开发完了几十个 services，然后要交给 QA Team 来进行测试，大家应该很熟悉一个项目的测试过程吧，alpha 之前就要出好几个 build 的，然后还要 beta，最后才 GA，每一阶段要出的 build 都不少的，为了保证 build 的质量，每次出 build 前，基本都要求开发人员将 service 先测试下，然后才能提交给 QA 进行系统测试，我想这时候开发人员一定会有一种抱怨，我的 service 也没有修改呀，怎么也要测试呀？每次都要重复的做这种没有什么意义的工作，其实这个工作是有意义的，你没有修改，也许其他人修改了，说不定你的代码和其他人修改的代码间有一定关联的，所以说测试还是必要的，这里面值得考虑的是，是不是每一次都需要开发人员手工那样一个一个 service 来测试呢？当然不用的，下面我就同大家来分享下 web Services 的自动化测试方法。
Web Services 要实现自动化测试我们要依赖 SoapUI 这个强大的工具，还记得我们建的 Soap
Project WS_IBM 吧，在完成上面的测试后，WS_IBM 的目录结构如图 6 所示：
接下来，在 WS_IBM 工程上右击，选择 New TestSuite, 在 Specify name of TestSuite 下输入 WebService_TestSuite，然后再 WebService_TestSuite 上右击，选择 New TestCase, 输入 Axis_sayHello, 然后再 Axis_sayHello 上右击，选择 Add Step, 然后选择 Test Request, 输入 sayHello, 随后会弹出一个界面供你选择，如图 6 所示：我们选择 AxisServiceSoap12Binding->sayHello
我们按照上面的步骤将 CXFServiceSoapBinding->sayHellot 添加到 WebService_TestSuite，Test Case 名称为 CXF_sayHello。
接下来我们编写一个 ant 脚本名称为 build_ws.xml, 脚本内容如清单 22 所示：
清单 22. build_ws.xml
<?xml version="1.0"?>
<!-- *************************************************************** -->
<!-- Ant build script for web Services -->
<!-- *************************************************************** -->
<project name="smartdm" default="ws-test" basedir=".">
<property file="build.properties"/>
<target name="ws-test">
<exec dir="${soapui.dir}\\bin" executable="cmd.exe" >
<arg line="/c testrunner.bat -j -f${junit.reports} ${soapui.project.file} "
/>
</exec>
<!-- Generate the JUnit reports -->
<junitreport todir="${junit.reports}">
<fileset dir="${junit.reports}" includes="TEST-*.xml"/>
<report todir="${junit.reports}" format="frames"/>
</junitreport>
</target>
</project>
Ant 脚本用到的 properties 文件 build.properties 内容如清单 23 所示：
|
清单 23. build.properties
soapui.dir=E:/tools/soapUI-3.5 soapui.project.file=E:/ws_soapUI/WS-IBM-soapui-project.xml junit.reports=E:/ws_soapUI/reports |
ok，大功告成了，以上三个 service 的测试，我们就可以用 build_ws.xml 这个文件来完成了，每次只需要简单的一行命令，是不是很简单，再也不用一个一个 service 点了，各位有没有什么感慨，这只是三个 service，如果 service 数量大的话，你会更加爱上这种方法的。感慨的同时我想一定还伴随着一些疑惑，文章开始我们说是自动化测试，而现在还是需要一行命令，名不符实呀。其实我已经将 xml 脚本告诉大家了，只需要大家来调用这个脚本就可以了，至于调用方式，你可以用一行命令，也可以通过一些软件来自动调用，比如通过 Hudson 等，我们可以在这些软件中设置一些场景，如有代码变动，就自动调用 build_ws.xml 文件。Hudson 是一种 CI 服务器，这种 CI 服务器的工作过程如下所示：首先开发者检查新增和修改到源代码仓库后的代码。然后 CI 服务器会为每一个项目创建了一个单独的工作区。当预设或请求一次新的构建时，它将把源代码仓库的源码存放到对应的工作区，哪里构建就执行哪里。接着 CI 服务器会在新近创建或者更新的工作区内执行构建过程。然后一旦构建完成，CI 服务器就会在一个新的构件中选择性地执行原先定义的一套测试。如果构建失败，相关责任人将会通过电子邮件、即时短信或者其他的方式获取到 ( 失败 ) 通知。如果构建成功，这个构件会被打包并转移到一个部署目标 ( 如应用服务器 ) 上。最后 CI 服务器通常会用某种控制台来进行项目的和调试，并且根据请求发起相应的操作，诸如即时构建、生成报告，或者检索一些构建好的构件。
学习
-
Web Services Architecture：介绍 Web Services 的结构体系。
-
了解 Axis2：讲解 Axis 的基础文章，包括其体系机构、主要特征等。
-
WSDL : 描述你的Web服务：介绍 WSDL 的意义和作用，并对 WSDL 的结构和工作模式进行了概要的讲解。
-
developerWorks SOA and Web services 专区：让您了解更多和 SOA 以及 Web 服务相关的内容，包括技术文章、教程以及特殊专题等。
发表评论
-
java中HelloWorld的执行流程
2017-03-12 23:23 576HelloWorld.java是我们学习java的第一个程 ... -
单例模式的好处？
2016-11-14 19:28 549单例的好处？啥时候不能用单例？ 优点：单例模式保 ... -
lombok精简代码
2016-03-16 16:29 807最近项目组在重构目前的工程，将H5的后台服务和PC上的服务合 ... -
java中的Vector类
2014-10-19 21:08 755这两天看书两遇到这个类，索性把这个类整理一下来研究研究。看看 ... -
java事务的原理和应用
2014-09-27 10:52 676深入Java事务的原理与 ... -
java简单工厂模式解释
2014-09-25 11:23 664简单工厂模式解释： ... -
java多线程和线程池
2014-09-24 14:39 6891. 引言 合理利用线程池能够带来三个好处。第 ... -
IBM MQ的java实现例子
2012-09-26 19:27 6587第一次接触MQ(Message Query ... -
windows7在java1.5输出当前时间问题解决方法 .
2012-09-26 19:24 1199Windows7在稳定性和可靠性上确实做的比较成功，但是搞 ... -
java中File的delete()方法删除文件失败的原因
2011-11-18 21:14 24328一般来说 java file.delete失败 有以下几个 ... -
svn Locked的几种解决方法
2011-09-15 20:20 1058SVN错误：Attempted to lock an ... -
Java导出PDF文档
2011-01-13 16:41 1256package tj; import java.awt. ... -
Java导出Excel文档
2011-01-13 16:40 1219package tj; import java.io ... -
Java导出Word文档(可设置字体)
2010-12-20 11:01 12415前天由于新需求需要从java中导出word，然后就从网上开始搜 ... -
oracle函数
2010-12-02 11:21 798PL/SQL单行函数和组函数 ... -
Tomcat：IOException while loading persisted sessions: java.io
2010-10-30 10:44 843Tomcat在启动时出现如下异常问题： 严重: IOExce ... -
oracle中创建Sequence和Trigger的SQL语句
2010-10-26 15:11 2731//建Sequence create sequence ST ... -
关于y--==6的程序分析
2010-09-19 16:22 892int x= 1, y = 6; while (y- ... -
判断整数是否为质数的原理
2010-09-19 11:00 1813关于判断是否为质数，有个简单的方法就是：用2到[根号N]（中括 ... -
Singleton和Prototype区别
2010-09-17 20:20 1567默认情况下，从bean工厂所取得的实例为Singleton（b ...
相关推荐
在Web Services的开发过程中，主要涉及到以下几个关键步骤和知识点： 1. **创建Web Service**： - 使用工具如Eclipse与WTP（Web Tools Platform）可以简化Web Service的创建过程。Eclipse提供了对Web Service开发...
《应用Java API开发Web Services》是一本面向Java开发者，旨在深入理解并实践Web服务开发的电子书。在当今互联网时代，Web服务已经成为企业级应用间交互的重要方式，Java API为开发这些服务提供了强大的支持。本...
总的来说，本开发文档将帮助读者掌握Web Services开发的基本步骤，包括使用Axis2生成和部署服务，通过Tomcat服务器托管服务，以及利用Eclipse进行开发和调试。通过深入学习这些材料，开发者能够熟练地运用这些工具...
**Java Web Services 实现步骤** 1. **定义服务接口**：使用 JAX-WS 的 @WebService 注解定义服务接口和方法。 2. **实现服务**：创建服务类实现接口，提供具体的功能。 3. **部署服务**：将服务打包成 WAR 文件并...
在开发Web服务时，Java API提供了强大的工具和框架，使得开发者可以轻松地创建、发布和消费Web服务。本文将深入探讨使用Java API开发Web服务的关键知识点，特别关注图像文件的处理。 首先，让我们理解Web服务的基本...
Web Services系列教程四 利用UDDI发布和查询Web Services 基于WSE 3.0 的 Web Services开发(安全的Web Services 开发,Web Services路由,Web Services 附件) 下一代的Web Services 框架－Indigo
WebServices是一种基于...总之，"WebServices 天气预报"项目是一个实用的学习工具，它结合了WebServices与WinForm应用开发，可以帮助初学者深入理解这两种技术的结合使用，为今后的跨平台、分布式系统开发奠定基础。
### MyEclipse+XFire开发Web Services #### 实验背景与目标 随着互联网技术的发展，Web Services作为一种重要的软件架构模式，在分布式系统中的应用越来越广泛。它允许不同平台、语言的应用程序通过标准协议（如...
本篇文章将详细解析如何使用Apache Axis来部署Web Services，这是一款广泛使用的开源工具，用于生成和消费Web Services。 首先，我们需要了解Web Services的基本概念。Web Services通过WSDL（Web Service ...
在Java平台上开发Web Services，我们可以利用一系列的技术和标准，以实现跨平台的互操作性。 首先，Web Services的核心标准是WSDL（Web Services Description Language），这是一种XML格式的规范，用于定义服务接口...
在java开发services中，会用到: 1.webservices-api.jar 2.webservices-extra.jar 3.webservices-rt.jar 4.webservices-tools.jar 5.webservices-extra-api.jar 此压缩文件里就是这五个jar文件。
Web Services 应用开发 Web 服务是一个基于 internet 的分布式计算的基本构造块，它允许在不同平台上、以不同语言编写的各种程序以基于标准的方式相互通信。Web 服务的定义尚未统一，但它通常是指在 internet 上...
Spring Web Services 官网 Spring Web Services API。 Spring Web Services 开发文档。
近年来，RESTful Web Services 成为了主流，它采用了更为简单的 HTTP 方法来传输数据，使得 Web Services 的开发和维护变得更加便捷。 #### 三、无刷新数据交换的研究 在基于 Web 的实时监控系统中，如何实现数据...
在这个“delphi开发webservices接口实例”中，我们将深入探讨如何使用Delphi来创建和消费WebServices。 首先，我们要理解WebServices的基本概念。WebServices是一种基于标准（如SOAP、WSDL和UDDI）的应用程序接口，...
这是一本全面介绍使用JSWDP来开发Web服务的实用参考书。Java Web服务开发人员包（Java Web Services Developer Pack ,JWSDP）是一个工具和库的集合，设计这些工具和库使得用Java开发Web服务尽可能地简单。
例如，你可以使用`webservices-api`和`webservices-extra-api`来定义服务接口和数据模型，`webservices-rt`来处理服务的运行时逻辑，而`webservices-tools`则帮助你在开发过程中进行验证和调试。 总的来说，"web...