javawebservice应用

❶ java Webservice都有哪几种方式啊，哪种方式比较好啊

webservice的应用已经越来越广泛了，下面介绍几种在Java体系中开发webservice的方式，相当于做个记录。
1.Axis2
Axis是apache下一个开源的webservice开发组件，出现的算是比较早了，也比较成熟。这里主要介绍Axis+eclipse开发webservice，当然不用eclipse也可以开发和发布webservice，只是用eclipse会比较方便。

（1）下载eclipse的Java EE版本

（2）下载axis2

（3）下载eclipse的axis2插件
Axis2_Codegen_Wizard
Axis2_Service_Archiver

推荐使用1.3的版本

（4）eclipse安装axis2插件
1）在任意目录下新建一个Axis2文件夹，在该文件夹下新建eclipse目录，在eclipse目录中新建plugins目录和features目录，例如：D:\programSoftware\eclipse-SVN\Axis2\eclipse；
2）把下载的axis2插件解压，并把解压的文件放到新建的eclipse的plugins目录下；
3）在%eclipse_home%的目录下新建links目录，并在links目录下新建axis2.link文件，内容为：path=D:\programSoftware\eclipse-SVN\Axis2;
4）重启eclipse，点击·file-new-other,如果看到Axis2 Wizards，则表明插件安装成功。

（5）安装axis2

（6）使用eclipse新建web工程，创建一个普通java类，至少包含一个方法。

（7）发布webservice
1）点击eclipse的File-New-other，打开Axis2 Wizards，选择Axis2 Service Archiver，然后Next;
2）选择Class File Location，也就是类文件存放路径，注意：只选到classes目录，不要包括包文件夹，然后Next;
3）选择Skip WSDL，然后Next
4）一路Next到Select the Service XML file to be included in the Service archive，勾选Generate theservice xml automatically；
5）Service Name-填写你的service名称，Class Name-填写类名称，要包括包名，然后点击load，然后点击Finish，这时webservice就发布成功了；
6）然后到%TOMCAT_HOME%/webapps/axis2/WEB-INF/services 看看是否多了一个.aar的文件；

注意：以上的方式是发布到axis2.war包中，你也可以把生成.aar文件到你的实际应用中，同时，你也可以使用eclipse的create webservice功能发布你的webservice，选择axis2生成你的webservice，这样webservice就会部署到你的应用中了。

2.Apche CXF
CXF开发webservice也是比较方便和简单的，它和spring的集成可以说是非常地好。举一个CXF开发webservice的例子吧。
1）在eclipse中新建一个web工程，导入依赖包，如图：

2）编写一个接口，如:

注意：CXF开发的webservice，接口中的方法的参数一定要以这种方式，否则客户端调用的时候CXF服务端会接收不到参数的值，name：参数名称，可不写（建议写上），targetNamespace：命名空间，一定要填写上，默认是包名反过来的顺序，mode：参数类型，IN表示输入。
3）编写一个实现类，实现接口的方法；
4）和spring的集成，编写一个bean文件，如：cxf-beans.xml，内容如下：

Cxf-beans.xml代码
<?xml version="1.0" encoding="UTF-8" ?>

<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="vote" implementor="com.zcl.cxf.service.VoteImpl" address="/Vote" />
</beans>
这个文件比较容易理解，就不解释了。
5）配置CXFServlet
在web.xml文件中配置CXFServlet，加载cxf-beans.xml文件，内容如下：

Web.xml代码

id="WebApp_ID" version="2.5">

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/cxf-beans.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
<servlet-name>cxf</servlet-name>
<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>
</web-app>
把工程部署到中间件，如tomcat，就可以访问该webservice了。

3.JDK开发webservice
1）编写一个Java类，如下：

Jdkwebservice.java代码
package demo;

import javax.jws.WebParam;
import javax.jws.WebService;
import javax.xml.ws.Endpoint;

@WebService
public class JdkWebService {

return "Just do it," + value + "!";
}

public static void main(String[] args) {

}
}
2）运行该java类，在浏览器上就可以访问该webservice了。
注意：开发web工程的时候，这种方法不太友好。我们可以编写一个servlet类，在servlet类的初始化方法中发布webservice，这样我们的中间件服务器启动的时候就会帮我们自动webservice了。

4) xfire
开发WebService的框架不少，每个框架都有各自的有点，最近我用xfire练习开发WebService,下面是开发WebService的小例子，希望对入门的人有些小帮助
1.新建一个java web project命名为TestWebService，将xfire相关的jar包添加到lib目录中,写接口类和实现类

Java代码
package com.lamp.service;

public interface MessageService {
public String getName(String name);
}
[java] view plainprint?
package com.lamp.service;

public interface MessageService {
public String getName(String name);
}

实现类

Java代码
package com.lamp.service.impl;

import com.lamp.service.MessageService;

public class MessageServiceImpl implements MessageService {

public String getName(String name) {
return "hellow " + name + ", welcome to WebService world";
}

}
[java] view plainprint?
package com.lamp.service.impl;

import com.lamp.service.MessageService;

public class MessageServiceImpl implements MessageService {

public String getName(String name) {
return "hellow " + name + ", welcome to WebService world";
}

}

在src目录下新建文件夹META-INF，然后再在其下新建文件夹xfire,在xfire目录下新建配置文件services.xml

Xml代码
<?xml version="1.0" encoding="UTF-8"?>

<service>
<name>MessageService</name>
<serviceClass>com.lamp.service.MessageService</serviceClass>
<implementationClass>com.lamp.service.impl.MessageServiceImpl</implementationClass>
</service>
</beans>
[xml] view plainprint?
<?xml version="1.0" encoding="UTF-8"?>

<service>
<name>MessageService</name>
<serviceClass>com.lamp.service.MessageService</serviceClass>
<implementationClass>com.lamp.service.impl.MessageServiceImpl</implementationClass>
</service>
</beans>

最后在web.xml中配置xfire的servlet

Xml代码
<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>

</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/servlet/XFireServlet/*</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
[xml] view plainprint?
<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>

</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/servlet/XFireServlet/*</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>

这样服务器端开发完毕，现在开始客户端的开发
新建一个java project也将xfire相关的jar引入，我用ant在客户端生成代理对象，在项目路径下新建build.xml,代码为

Xml代码
<?xml version="1.0" encoding="UTF-8"?>

<project name="WebService" basedir="." default="gen-webservice">

<property file="build.properties">
</property>

<path id="project-classpath">
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
</fileset>
</path>

<target name="gen-webservice">
<taskdef name="wsgen" classname="org.codehaus.xfire.gen.WsGenTask" classpathref="project-classpath" />

<wsgen outputDirectory="${src.dir}"
wsdl="${wsdl.dir}" package="com.lamp.ws.client" overwrite="true"/>

</target>

</project>
[xml] view plainprint?
<?xml version="1.0" encoding="UTF-8"?>

<project name="WebService" basedir="." default="gen-webservice">

<property file="build.properties">
</property>

<path id="project-classpath">
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
</fileset>
</path>

<target name="gen-webservice">
<taskdef name="wsgen" classname="org.codehaus.xfire.gen.WsGenTask" classpathref="project-classpath" />

<wsgen outputDirectory="${src.dir}"
wsdl="${wsdl.dir}" package="com.lamp.ws.client" overwrite="true"/>

</target>

</project>

❷ java webservice实际应用多吗

多啊，现在很多业务独立的系统，相互间访问，都是通过webservise来实现的，用起来比较简单，服务端配上地址，对外暴漏接口，客户端拿到地址，看到暴漏的接口，就可以用了，所以，应用是很广泛的。

❸ 如何在Java中快速发布WebService服务

在Java中快速发布WebService服务方法：
一、通过Axis2提供的模板自动发布

这种方法非常简单，只要下载Axis包后从里面的“axis-1_4\webapps”中找到axis站点，将它拷出来放到你要部署的tomcat/webapps下，再将要发布的java类放到axis文件夹里，再将文件名的后缀改为“jws”，这样一个webservice就发布成功了。访问时按照路径“http://IP:Port/axis/类名.jws?wsdl”就可以了。
怎么样？这种方法非常是不是非常简单？对，它特别适合初学java或者是手头没有很好的SDE开发和调试工具的时候。
但很明显，这种方法不太好调试，又不能凸显您的专业水准，更不能集成到您的开发环境里。所以如果您不是很急，就可以用下面一种办法来发布：
二、通过JWS来手动发布
步骤如下：
1、在Eclipse里新建一个Dynamic Web Project，如下图所示(相信这一步您比我还熟，所以会的可以略过)：
2、在“Project Name”中输入工程名称，如“JavaWebService”：
3、一直单击“Next”按钮直到出现如下对话框：
在上面的对话框中一定要注意需要选中“Generate web.xml deployment descriptor”，否则后面再添加就比较麻烦。选中后单击“Finish”按钮即可完成工程创建。
4、引入必须的jar包：
axis.jar、commons-discovery-0.2.jar、commons-logging.jar、jaxrpc.jar、saaj.jar、wsdl4j.jar

最好将jar包拷贝到工程的WEB-INF/lib下后直接引用本工程内的jar包，这样不会导致工程文件夹或jar包所在文件夹移动后读取不到jar包的问题：
分别单击顶层对话框和“Properties”对话框的“OK”按钮完成jar包引用。

5、新建package和java文件，如下图所示：
首先说说com.test.javabean.Student.java这个类。看得出来这个类是个JavaBean，目的是为了封装一个Java的实体类，这样做的好处是万一要把很多变量返回给客户端的话，客户端不至于在方法中声明很多形参来接收，而是通过一个对象来接收。Student.java的实现如下：

[java] view plain

package com.test.javabean;
import java.io.Serializable;
public class Student implements Serializable{
private String ID;
private String Name;
private String Sex;
private int age;
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
public String getSex() {
return Sex;
}
public void setSex(String sex) {
Sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
再来看看com.test.webservice.CStudent.java这个类，定义如下：
[java] view plain

package com.test.webservice;
import javax.jws.WebService;
import com.test.javabean.Student;
@WebService
public class CStudent {
public Student getStudent(String name) throws java.rmi.RemoteException{
Student student = new Student();
student.setName(name);
student.setAge(14);
student.setID("25");
student.setSex("Male");
return student;
}
}
为了简单起见，就不涉及到更多的后台查询了，先写死返回结果吧。不知您注意到了没有，这个类跟普通类的区别是在类的顶部加了个“@WebService”声明。对，这样就是个WebService方法了，是不是也很简单？但是这样就得记着在上面引入javax.jws.WebService包。偶对了，这种方式是JDK1.7里增加的方式，所以要想使用这种特性，就得麻烦您把JDK升级到1.7，方法很简单，用绿色版的就可以啦，不用劳烦您把JDK卸了又重装。只需要把JDK放到哪个盘的根目录(这样是为了防止路径中有空格或是括号什么的，否则一旦出问题您就苦逼了)，然后把JDK的路径定义为JAVA_HOME，再在path中增加%JAVA_HOME%/bin;就可以了。这样做的好处是可以随时很方便地更换JDK的版本，而不需要卸载后再重新安装。
扯远了。有了WebService的方法体，您还需要再发布一下WebService，所以还得新建一个com.test.servlet.CStudentServlet.java类：
[java] view plain

package com.test.servlet;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Properties;
import javax.jws.WebService;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.ws.Endpoint;
import com.test.webservice.CStudent;
public class CStudentServlet extends HttpServlet{
/**
* @see Servlet#init(ServletConfig)
*/
public void init(ServletConfig config) throws ServletException {
// TODO Auto-generated method stub
super.init(config);
System.out.println("正在启动WebService服务：http://192.168.56.1:8082/JavaWebService/Student");
Endpoint.publish("http://<span style="font-family: Arial, Helvetica, sans-serif;">192.168.56.1</span><span style="font-family: Arial, Helvetica, sans-serif;">:8082/</span><span style="font-family: Arial, Helvetica, sans-serif;">JavaWebService</span><span style="font-family: Arial, Helvetica, sans-serif;">/Student", new CStudent());</span>
}
/**
* @see Servlet#getServletConfig()
*/
public ServletConfig getServletConfig() {
// TODO Auto-generated method stub
return null;
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
}
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
System.out.println("进入WSServlet的service()方法");
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
}
}

上面的代码中有处细节不知您注意了没有：把IP地址、端口号、站点名等信息写死到了代码里。对，不仅如此，你这里写的什么IP，就必须用什么IP访问，即便是在本机写成localhost都不可以。jws就是这么奇怪。所以在实际中可以参考一些资料动态获取IP地址和端口号。

对了，您那边代码是不是报错了？对，这是因为您还得做一步操作——添加server和对server组件包的引用，以tomcat为例，方法如下：
找到servers窗口，单击“new server wizard...”链接：

打开如下对话框：

看到了吧？选择Apache下的”Tomcat v7.0 Server“，然后单击”Next“：

在上图中单击右侧”Browse“按钮，找到Tomcat所在的目录，再在JRE中选择1.7的JDK。如果您还没有配置JDK，就请自行查找资料进行配置吧，某在这里就不讲了，不然又扯远啦。
然后进入这个窗口：

这个对话框得特别留意一下，不要着急单击”Add“按钮添加站点那，否则启动后您就找不到站点部署的位置了。所以这一步直接单击”Finish“。完毕后双击新添加的server，打开如下对话框：
在上面的窗口中，一定要先选择第二项”Use Tomcat installation (takes control of Tomcat installation)“，然后在”Deploy path“中将内容改为”webapps“，然后再按下”Ctrl+S“键保存配置，这样就可以把站点部署到您指定的tomcat的webapps下了。
然后记着给站点添加servlet-api.jar包的引用，在工程上单击右键，选择”Properties“，打开如下对话框：
看到了吧？切换到”Libraries“选项卡后先点击右侧的”Add Library“按钮，再在弹出的窗口中选择”Server Runtime“，单击”Next“-->“Finish”和父窗口的”OK“按钮就可以成功引入servlet所需的jar包了。怎么样？CStudentServlet.java中再没有错误提示了吧？
下一步需要将servlet配置为自启动，您只要在web.xml中增加如下内容就可以了：

[html] view plain
<servlet>

<servlet-name>CStudentServlet</servlet-name>
<servlet-class>com.test.servlet.CStudentServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CStudentServlet</servlet-name>
<url-pattern>/servlet/CStudentServlet</url-pattern>
</servlet-mapping>
记着把站点发布一下，在tomcat上单击邮件，选择“Add and Remove”，将JavaWebService发布到tomcat中。
下一步只要发布和启动一下站点就可以了。如果您还不会，那就在server上单击右键，选择“Publish”，然后再选择“Start”就可以了。
启动成功

❹ 如何使用java做webservice

基于AXIS的web service： 1 比如要建一个Server.java类的web service public class Server { public String printInfo(String name){ return "Hello,"+name; } } 2 把Server.java改为Server.Jws放到 …\Tomcat 5.5\webapps\axis中，重启服务器 3 访问 4 在cmd中输入 cd D:\Program Files\Apache Software Foundation\Tomcat 5.5\webapps\axis\WEB-INF 输入命令：Java -Djava.ext.dirs=lib org.apache.axis.wsdl.WSDL2Java 5 找到…\Tomcat 5.5\webapps\axis\WEB-INF下生成的localhost文件夹复制到工程中 6 建一个Client端的类进行测试： public class Client { public static void main(String arg[]) throws ServiceException, RemoteException{ ServerService ss=new ServerServiceLocator(); Server s=ss.getServer(); System.out.println("............"+s.printInfo("shiyou")); } } 蓝屏

❺ 各位大虾java 中webservice的作用完全详解!

当前，WebService是一个热门话题。但是，WebService究竟是什么？什么情况下应该用WebService？什么情况下不应该用WebService？是需要我们正确认识的。
Web Service 是一种新的web应用程序分支，他们是自包含、自描述、模块化的应用，可以发布、定位、通过web调用。Web Service可以执行从简单的请求到复杂商务处理的任何功能。一旦部署以后，其他Web Service应用程序可以发现并调用它部署的服务。
实际上，WebService的主要目标是跨平台的可互操作性。为了达到这一目标，WebService完全基于XML（可扩展标记语言）、XSD（XMLSchema）等独立于平台、独立于软件供应商的标准，是创建可互操作的、分布式应用程序的新平台。由此可以看出，在以下三种情况下，使用WebService会带来极大的好处。
长项一：跨防火墙的通信
如果应用程序有成千上万的用户，而且分布在世界各地，那么客户端和服务器之间的通信将是一个棘手的问题。因为客户端和服务器之间通常会有防火墙或者代理服务器。在这种情况下，使用DCOM就不是那么简单，通常也不便于把客户端程序发布到数量如此庞大的每一个用户手中。传统的做法是，选择用浏览器作为客户端，写下一大堆ASP页面，把应用程序的中间层暴露给最终用户。这样做的结果是开发难度大，程序很难维护。
长项二：应用程序集成
企业级的应用程序开发者都知道，企业里经常都要把用不同语言写成的、在不同平台上运行的各种程序集成起来，而这种集成将花费很大的开发力量。应用程序经常需要从运行在IBM主机上的程序中获取数据；或者把数据发送到主机或UNIX应用程序中去。即使在同一个平台上，不同软件厂商生产的各种软件也常常需要集成起来。通过WebService，应用程序可以用标准的方法把功能和数据“暴露”出来，供其它应用程序使用。
例如，有一个订单登录程序，用于登录从客户来的新订单，包括客户信息、发货地址、数量、价格和付款方式等内容；还有一个订单执行程序，用于实际货物发送的管理。这两个程序来自不同软件厂商。一份新订单进来之后，订单登录程序需要通知订单执行程序发送货物。通过在订单执行程序上面增加一层WebService，订单执行程序可以把“AddOrder”函数“暴露”出来。这样，每当有新订单到来时，订单登录程序就可以调用这个函数来发送货物了。
长项三：B2B的集成
用WebService集成应用程序，可以使公司内部的商务处理更加自动化。但当交易跨越供应商和客户、突破公司的界限时会怎么样呢？跨公司的商务交易集成通常叫做B2B集成。
WebService是B2B集成成功的关键。通过WebService，公司可以把关键的商务应用“暴露”给指定的供应商和客户。例如，把电子下单系统和电子发票系统“暴露”出来，客户就可以以电子的方式发送订单，供应商则可以以电子的方式发送原料采购发票。当然，这并不是一个新的概念，EDI(电子文档交换)早就是这样了。但是，WebService的实现要比EDI简单得多，而且WebService运行在Internet上，在世界任何地方都可轻易实现，其运行成本就相对较低。不过，WebService并不像EDI那样，是文档交换或B2B集成的完整解决方案。WebService只是B2B集成的一个关键部分，还需要许多其它的部分才能实现集成。
用WebService来实现B2B集成的最大好处在于可以轻易实现互操作性。只要把商务逻辑“暴露”出来，成为WebService，就可以让任何指定的合作伙伴调用这些商务逻辑，而不管他们的系统在什么平台上运行，使用什么开发语言。这样就大大减少了花在B2B集成上的时间和成本，让许多原本无法承受EDI的中小企业也能实现B2B集成。
短处一：单机应用程序
目前，企业和个人还使用着很多桌面应用程序。其中一些只需要与本机上的其它程序通信。在这种情况下，最好就不要用WebService，只要用本地的API就可以了。
短处二：局域网的同构应用程序
在许多应用中，所有的程序都是用VB或VC开发的，都在Windows平台下使用COM，都运行在同一个局域网上。例如，有两个服务器应用程序需要相互通信，或者有一个Win32或WinForm的客户程序要连接局域网上另一个服务器的程序。在这些程序里，使用DCOM会比SOAP/HTTP有效得多。
总之，只要从应用程序结构的角度看，有别的方法比WebService更有效、更可行，那就不要用WebService

❻ java开发webservice的几种方式

webservice的应用已经越来越广泛了，下面介绍几种在Java体系中开发webservice的方式，相当于做个记录。专摘自 中华考试网属 http://www.examw.com/java/jichu/190181/index.html
1.Axis2
Axis是apache下一个开源的webservice开发组件，出现的算是比较早了，也比较成熟。这里主要介绍Axis+eclipse开发webservice，当然不用eclipse也可以开发和发布webservice，只是用eclipse会比较方便。
2.Apche CXF
CXF开发webservice也是比较方便和简单的，它和spring的集成可以说是非常地好。
3.JDK开发webservice（jdk自带的jaxws）

❼ java 如何实现webservice 怎么调用接口

一、利用jdkweb服务api实现，这里使用基于SOAPmessage的Web服务

①.首先建立一个WebservicesEndPoint：packageHello;
importjavax.jws.WebService;
importjavax.jws.WebMethod;
importjavax.xml.ws.Endpoint;
@
publicclassHello{
@WebMethod
publicStringhello(Stringname){
return"Hello,"+name+"
";
}
publicstaticvoidmain(String[]args){
//createandpublishanendpoint
Hellohello=newHello();
Endpointendpoint=Endpoint.publish("


,hello);
}
}
②.使用apt编译Hello.java(例：apt-d[存放编译后的文件目录]Hello.java),
会生成jaws目录
③.使用javaHello.Hello运行，然后将浏览器指向


就会出现下列显示
④.使用wsimport生成客户端使用如下：
wsimport-p.-keep


这时，会在当前目录中生成如下文件：
⑤.客户端程序：
1classHelloClient{
2publicstaticvoidmain(Stringargs[]){
3HelloServiceservice=newHelloService();
4HellohelloProxy=service.getHelloPort();
5Stringhello=helloProxy.hello("你好");
6System.out.println(hello);
7}
8}

以上方法还稍显繁琐，还有更加简单的方法

二、使用xfire，我这里使用的是myeclipse集成的xfire进行测试的利用xfire开发WebService，可以有三种方法：

1. 一种是从javabean中生成；

2.一种是从wsdl文件中生成；

3. 还有一种是自己建立webservice

步骤如下：

用myeclipse建立webservice工程，目录结构如下：首先建立webservice接口，

代码如下：

1packagecom.myeclipse.wsExample;
2//GeneratedbyMyEclipse
3
{
5
6publicStringexample(Stringmessage);
7
8}
接着实现这个借口：
1packagecom.myeclipse.wsExample;
2//GeneratedbyMyEclipse
3
{
5
6publicStringexample(Stringmessage){
7returnmessage;
8}
9
10}

修改service.xml文件，加入以下代码：

1<service>
2<name>HelloWorldService</name>
3<serviceClass>
4com.myeclipse.wsExample.IHelloWorldService
5</serviceClass>
6<implementationClass>
7com.myeclipse.wsExample.HelloWorldServiceImpl
8</implementationClass>
9<style>wrapped</style>
10<use>literal</use>
11<scope>application</scope>
12</service>

把整个项目部署到tomcat服务器中打开浏览器，输入http://localhost:8989/HelloWorld/services/HelloWorldService?wsdl,可以看到如下：

然后再展开HelloWorldService后面的wsdl可以看到：

客户端实现如下：

1packagecom.myeclipse.wsExample.client;
2
3importjava.net.MalformedURLException;
4importjava.net.URL;
5
6importorg.codehaus.xfire.XFireFactory;
7importorg.codehaus.xfire.client.Client;
8importorg.codehaus.xfire.client.XFireProxyFactory;
9importorg.codehaus.xfire.service.Service;
10importorg.codehaus.xfire.service.binding.ObjectServiceFactory;
11
12importcom.myeclipse.wsExample.IHelloWorldService;
13
14publicclassHelloWorldClient{
15publicstaticvoidmain(String[]args)throwsMalformedURLException,Exception{
16//TODOAuto-generatedmethodstub
17Services=newObjectServiceFactory().create(IHelloWorldService.class);
18XFireProxyFactoryxf=newXFireProxyFactory(XFireFactory.newInstance().getXFire());
19Stringurl="

20
21try
22{
23
24IHelloWorldServicehs=(IHelloWorldService)xf.create(s,url);
25Stringst=hs.example("zhangjin");
26System.out.print(st);
27}
28catch(Exceptione)
29{
30e.printStackTrace();
31}
32}
33
34}

有时候我们知道一个wsdl地址，比如想用java客户端引用net做得webservice，使用myeclipse引用，但是却出现无法通过验证的错误，这时我们可以直接在类中引用，步骤如下：

1.publicstaticvoidmain(String[]args)throwsMalformedURLException,Exception{
2.//TODOAuto-generatedmethodstub