javawebservice方式

㈠ java如何调用webservice接口

Java调用WebService可以直接使用Apache提供的axis.jar自己编写代码，或者利用Eclipse自动生成WebService Client代码，利用其中的Proxy类进行调用。理论上是一样的，只不过用Eclipse自动生成代码省事些。
1、编写代码方式：
package com.yun.test;
import java.rmi.RemoteException;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.message.PrefixedQName;
import org.apache.axis.message.SOAPHeaderElement;
import com.cezanne.golden.user.Exception;
import com.cezanne.golden.user.UserManagerServiceProxy;
import javax.xml.namespace.QName;
import java.net.MalformedURLException;
import javax.xml.rpc.ServiceException;
import javax.xml.soap.Name;
import javax.xml.soap.SOAPException;

public class testWebService {
public static String getResult() throws ServiceException, MalformedURLException, RemoteException, SOAPException
{
//标识Web Service的具体路径
String endpoint = "WebService服务地址";
// 创建 Service实例
Service service = new Service();
// 通过Service实例创建Call的实例
Call call = (Call) service.createCall();
//将Web Service的服务路径加入到call实例之中.
call.setTargetEndpointAddress( new java.net.URL(endpoint) );//为Call设置服务的位置
// 由于需要认证，故需要设置调用的SOAP头信息。
Name headerName = new PrefixedQName( new QName("发布的wsdl里的targetNamespace里的url", "string_itemName") );
org.apache.axis.message.SOAPHeaderElement header = new SOAPHeaderElement(headerName);
header.addTextNode( "blablabla" );
call.addHeader(header);

// SOAPHeaderElement soapHeaderElement = new SOAPHeaderElement("发布的wsdl里的targetNamespace里的url", "SoapHeader");
// soapHeaderElement.setNamespaceURI("发布的wsdl里的targetNamespace里的url");
// try
// {
// soapHeaderElement.addChildElement("string_itemName").setValue("blablabla");
// }
// catch (SOAPException e)
// {
// e.printStackTrace();
// }
// call.addHeader(soapHeaderElement);
//调用Web Service的方法
org.apache.axis.description.OperationDesc oper;
org.apache.axis.description.ParameterDesc param;
oper = new org.apache.axis.description.OperationDesc();
oper.setName("opName");
param = new org.apache.axis.description.ParameterDesc(new javax.xml.namespace.QName("", "arg0"), org.apache.axis.description.ParameterDesc.IN, new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema", "string"), java.lang.String.class, false, false);
param.setOmittable(true);
oper.addParameter(param);
param = new org.apache.axis.description.ParameterDesc(new javax.xml.namespace.QName("", "arg1"), org.apache.axis.description.ParameterDesc.IN, new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema", "string"), java.lang.String.class, false, false);
param.setOmittable(true);
oper.addParameter(param);
param = new org.apache.axis.description.ParameterDesc(new javax.xml.namespace.QName("", "arg2"), org.apache.axis.description.ParameterDesc.IN, new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema", "string"), java.lang.String.class, false, false);
param.setOmittable(true);
oper.addParameter(param);
oper.setReturnType(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema", "string"));
oper.setReturnClass(java.lang.String.class);
oper.setReturnQName(new javax.xml.namespace.QName("", "return"));
oper.setStyle(org.apache.axis.constants.Style.WRAPPED);
oper.setUse(org.apache.axis.constants.Use.LITERAL);
oper.addFault(new org.apache.axis.description.FaultDesc(
new javax.xml.namespace.QName("发布的wsdl里的targetNamespace里的url", "Exception"),
"Exception",
new javax.xml.namespace.QName("发布的wsdl里的targetNamespace里的url", "Exception"),
true
));
call.setOperation( oper );
call.setOperationName(new javax.xml.namespace.QName("发布的wsdl里的targetNamespace里的url", "opName"));
//调用Web Service,传入参数
String res = ( String ) call.invoke( new Object[]("arg0","arg1"));
System.out.println("===============");
return res;
}
/**
* @param args
*/
public static void main(String[] args) {
try {
System.out.println(getResult());
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
} catch (ServiceException e) {
e.printStackTrace();
} catch (SOAPException e) {
e.printStackTrace();
}
}
}

2、利用Eclipse自动生成WebService client代码就容易多了：（由于还不会发图片，就用语言描述了，大家酬和看吧。。。）
首先，new project，选择other，在输入框中输入Web Service Client，选中搜索后的结果，点击Next，在Service definition中输入 WebService的发布地址，点击Finish
这样，WebService Client代码已经生成好了。
接下来写一个Test类，在main函数中输入如下代码：

String endpoint = "服务器的WebService的地址";
YourWebServiceNameProxy umsp = new YourWebServiceNameProxy (endpoint);
try {
String resultStr = umsp.opMethod("arg0","arg1");
System.out.println(resultStr);
} catch (Exception e) {
System.out.println("异常");
e.printStackTrace();
} catch (RemoteException e) {
System.out.println("RemoteException异常");
e.printStackTrace();
}
如果还有疑问的话还有视频，如果对你有帮助请采纳！

㈡ java webservice 通过什么传递

WebService可以有Get、 Post、Soap、Document四种方式调用，以下Java通过post方式调用WebService代码：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
/**
* 功能描述：WebService调用
*
*/
public class ClientTest {
/**
* 功能描述：HTTP-POST
*
*/
public String post() {
OutputStreamWriter out = null;
StringBuilder sTotalString = new StringBuilder();
try {
URL urlTemp = new URL(
"url..");
URLConnection connection = urlTemp.openConnection();
connection.setDoOutput(true);
out = new OutputStreamWriter(connection.getOutputStream(), "UTF-8");
StringBuffer sb = new StringBuffer();
sb.append("byProvinceName=福建");
out.write(sb.toString());
out.flush();
String sCurrentLine;
sCurrentLine = "";
InputStream l_urlStream;
l_urlStream = connection.getInputStream();// 请求
BufferedReader l_reader = new BufferedReader(new InputStreamReader(
l_urlStream));
while ((sCurrentLine = l_reader.readLine()) != null) {
sTotalString.append(sCurrentLine);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != out) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return sTotalString.toString();
}
}

㈢ 用java怎么写webservice

Web Services以XML作为数据交换的标准格式，它是跨平台的应用，允许以任何方式创建Web Services，在.NET、Java平台上访问。
在Java平台创建和访问Web Service多通过Axis完成。Axis本质上就是一个SOAP引擎，提供创建服务器端、客户端和网关SOAP操作的基本框架。Axis目前版本是为Java编写的。在使用Axis访问Web Service时，需要引入以下包（10个）：axis-ant.jar、axis.jar、commons-discovery-0.2.jar、commons-logging-1.0.4.jar、jaxrpc.jar、log4j-1.2.8.jar、saaj.jar、wsdl4j-1.5.1.jar、activation-1.1.jar和mail-1.4.jar。
（1）访问Java创建的Web Service
在当前Java客户端应用中添加相应的10个Axis包，编写客户端程序：
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class Test {
public static void main(String[] args) throws Exception {
try{
String endpoint = "http://localhost:8080/MyService/services/Hello";
Service service = new Service();
Call call = (Call)service.createCall();
call.setTargetEndpointAddress(new java.net.URL(endpoint));
call.setOperationName("getHello");
String res = (String) call.invoke(new Object[]{});
System.out.println(res);
}
catch (Exception ex){
ex.printStackTrace();
}
}
}
其中两处代码加粗，第一处表示引用Java Web Service的URL，第二处表示公共的方法名称。

㈣ java 怎样调用.net 写的webservice

一． 使用axis1.x调用webservice方法
Axis的最常用版本：1.4和2.0版本。以下为1.4版本
核心代码：
// webserviceURL
service_url = "http://vip.cxcod.com/PodApi/GetPodStr.asmx?wsdl";
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress(new java.net.URL(service_url));
// 设置要调用的方法
// http://intelink.net/是wsdl中definitions根节点的targetNamespace属性值
call.setOperationName(new QName("http://intelink.net/","GetStrByJobno"));
// 该方法需要的参数
call.addParameter("CustNo",
org.apache.axis.encoding.XMLType.XSD_STRING,
javax.xml.rpc.ParameterMode.IN);
call.addParameter("passwd",
org.apache.axis.encoding.XMLType.XSD_STRING,
javax.xml.rpc.ParameterMode.IN);
call.addParameter("Jobno",
org.apache.axis.encoding.XMLType.XSD_STRING,
javax.xml.rpc.ParameterMode.IN);
// 方法的返回值类型
call.setReturnType(org.apache.axis.encoding.XMLType.XSD_STRING);
// call.setUseSOAPAction(true); //call.setSOAPActionURI("http://intelink.net/GetStrByJobno");
// 调用该方法, new Object[] { CustNo, passwd, Jobno}为参数列表
String xmlStr = call.invoke(new Object[] { CustNo, passwd, Jobno}).toString();
} catch (Exception e) {
e.printStackTrace();
}
JAVA用这种方式调用webservice,需要注意的地方：
1. 服务器未能识别 HTTP 标头 SOAPAction 的值：
症状一：
Web Service + ASP.NET 应用程序部署到服务器默认目录中，在IE中用http://<服务器地址>/<程序目录名>/<默认启动页面名>发生“服务器未能识别 HTTP 标头 SOAPAction 的值”错误。
症状二：
在Java平台上调用.NET Web Service的服务时，出现"服务器未能识别 HTTP 标头 SOAPAction 的值"。
症状三：
在Java平台下调用.NET WEB Service，出现数据时有时无。

解决对策：

给.NET的WebService类（即.asmx文件下的类）添加属性[SoapDocumentService(RoutingStyle=SoapServiceRoutingStyle.RequestElement)]
小知识：
什么是SoapAction？它在WSDL中有何作用？
SOAPAction HTTP request header被用来标识SOAP HTTP请求的目的地，其值是个URI地址。SOAP发送并不限制格式、URI特征或其必须可解析，那么在这种情况下，发送一个HTTP SOAP请求时，其HTTP客户端必须使用/指明SOAPAction HTTP request header。

SOAPAction header的内容可以被用在服务端，诸如：防火墙适当的过滤基于HTTP的SOAP请求消息等场景。SOAPAction header的值为空串("")表示SOAP消息的目的地由HTTP请求的URI标识；无值则表示没有指定这条消息的目的地。

本人补充：
在.NET环境调用.NET WebService出现 “SOAPAction 值在 XML Web services 的所有方法中不唯一的错误”，也可以通过此法解决。

2. 为了Java能够调用WebService的方法，所以。NETP写的WebServiced的每个方法都要声明为Rpc方法，即添加"[SoapRpcMethod.....]".
例如：[WebMethod]
[SoapRpcMethod(Use=SoapBindingUse.Literal,Action= http://tempuri.org/HelloWorld", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/")]

3. 对返回值、参数的处理上：
应尽量将webservice方法的返回值、参数都写成字符串（String）不要使用复杂对象类型,这样便于在网络上传输。避免了复杂对象类型的不易转换问题。。。对于返回类型是字符串数组型的，可以设置返回类型为org.apache.axis.encoding.XMLType.SOAP_VECTOR或java.lang.String[].class.

二．利用xfire调用WebService
XFire是新一代的Java Web服务引擎，XFire使得在JavaEE应用中发布Web服务变得轻而易举。和其他Web服务引擎相比，XFire的配置非常简单，可以非常容易地和Spring集成，它使得Java开发人员终于可以获得和.Net开发人员一样的开发效率。

核心代码：
Service service = new ObjectServiceFactory().create(IWebservice.class);
XFireProxyFactory factory =
new XFireProxyFactory(XFireFactory.newInstance().getXFire());
String url= "http://localhost:8080/webservices/services/webservices";
IWebservice iw = (IWebservice) factory.create(service, url);
List list=iw.getTest();
出处：http://liyuandong.iteye.com/blog/567836

㈤ 如何在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的方法

再原始的也得先选个库啊，jdk里本身又没有访问webservice的库
比如commons-httpclient-3.1.jar里的HttpClient、xfire，axis，cxf等
比如，我一直是用cxf访问webservice的（不考虑提供方语言，就算是.net提供的webservice也一样）
CXF调用webservice步骤（我认为这个最简单，因为不需要你写代码）

1、下载CXF，并将cxf的bin目录加入到操作系统环境变量中（或者直接使用cmd命令进入CXF的bin文件夹）
2、将wsdl文件放到某个目录下（如果没有设置环境变量，则将此wsdl文件放入CXF的bin文件夹），执行命令wsdl2java -impl xxx.xml，则生成了符合wsdl要求的服务器端代码
3、在生成好的代码里寻找xxx.xml，删除或修改掉这些代码即可（构造函数的URL属性修改为http://形式的字符串，比如http://127.0.0.1/xxx?wsdl，其他部分出现的xxx.xml全部删除）

㈦ java中的webservice是什么那里有教程

真佩服不懂的人也能乱答，害人不浅！
webservice是指web上的一个服务，webservice并不是和java一定要在一起说的。java只是一种编程语言，当然也是一个运行环境（JVM）。
webservice通常是一个系统对外提供的一种服务，这个对外就是说像互联网中提供一种服务。常见的，比如你进某个网站，那网站某个角落里天气预报，那么这个天体预报小程序并非是此网站系统自己开发的，而且调用气象系统提供的服务。
通常向外提供服务的系统会提供一个url，方便其他系统调用，并且提供wsdl，就是web service descript language 。 webservice描述语言，告诉提供有哪些接口，接口哪些方法，返回什么类型等。
webservice采用SOAP协议， 就是简单对象访问协议。

㈧ 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接口有几种方式

Support for Standards
JSR Support

JAX-WS - Java API for XML-Based Web Services (JAX-WS) 2.0 - JSR-224
Web Services Metadata for the Java Platform - JSR-181
JAX-RS - The Java API for RESTful Web Services - JSR-311
SAAJ - SOAP with Attachments API for Java (SAAJ) - JSR-67

WS-* and related Specifications Support

Basic support: WS-I Basic Profile 1.1
Quality of Service: WS-Reliable Messaging
Metadata: WS-Policy, WSDL 1.1 - Web Service Definition Language
Communication Security: WS-Security, WS-SecurityPolicy, WS-SecureConversation, WS-Trust (partial support)
Messaging Support: WS-Addressing, SOAP 1.1, SOAP 1.2, Message Transmission Optimization Mechanism (MTOM)

Multiple Transports, Protocol Bindings, Data Bindings, and Formats

Transports: HTTP, Servlet, JMS, In-VM and many others via the Camel transport for CXF such as SMTP/POP3, TCP and Jabber
Protocol Bindings: SOAP, REST/HTTP, pure XML
Data bindings: JAXB 2.x, Aegis, Apache XMLBeans, Service Data Objects (SDO), JiBX
Formats: XML Textual, JSON, FastInfoset
Extensibility API allows additional bindings for CXF, enabling additional message format support such as CORBA/IIOP

http://cxf.apache.org

㈩ Java调用webservice和postmain调用的区别

区别是WebService可以有Get、Post、Soap、Document四种方式调用。
我们可以把webservice看做是web服务器上的一个应用，web服务器是webservice的一个容器。通过wximport生成代码。通过客户端编程方式。
通过URLConnection方式调用。