java动态调用webservice

Ⅰ 如何用java调用cxf webservice接口

WebService CXF客户端报 java.lang.RuntimeException: Cannot create a secure XMLInputFactory 异常，查了许多网络关于该问题的解决办法，很多都说缺少包问题，但问题是我的包都存在，我用的是apache-cxf-2.7.6，经过不懈努力终于解决了，我的服务端用的是web project，客户端用的是java project，客户端jar包是引用其它地方的，后来建一个web project客户端，把jar直接复制到project的lib目录下就行了，jdk用的是1.7，客户端依赖的接口用wsdl2java生成的。

Ⅱ java cxf动态调用服务端的webservices方法

WebService实现
1、 整个项目使用CXF来实现，在实现的过程中，在MyEclipse中对CXF下lib中的所有jar文件通过引入外部包来处理。
2、 在MyEclipse6.5中可以实现服务器端和客户端，但是客户端在使用wsdl进行动态调用的过程中总是报错，最后使用MyEclipse9.0实现了进行动态调用的实现。其中发生的错误如下：
（1）Exception in thread "main" java.lang.LinkageError: 正在从引导类加载器加载 JAXB 2.1 API, 但此 RI (来自jar:file:/D:/CXF/lib/jaxb-impl-2.2.5.jar!/com/sun/xml/bind/v2/model/impl/ModelBuilder.class) 需要 2.2 API。请使用授权目录机制将 jaxb-api.jar 放在引导类加载器中。(请参阅 http://java.sun.com/j2se/1.6.0/docs/guide/standards/)
解决办法：
通过删除引入包中的jaxb-impl-2.2.5.jar文件可以解决。
（2）java.lang.IllegalArgumentException: Can not set final com.sun.tools.internal.xjc.reader.internalizer.InternalizationLogic field

Ⅲ java 调用.net webservices

java如祥山谈果用axis开发webservice基于谨碰rpc,.net开发webservice基于doc。所以java调用.net的webservice method时唯兆，.net 的webservice method开发时method 需声明为rpc。

反之，没有什么限制。

Ⅳ java 项目怎么调用.net写的webService，求源码。

1. 发布.net webservice得到wsdl地址：（你的）http://222.92.47.171:8003/SZDataExchange/SZDataExchange.asmx?wsdl
   

2. 根据wsdl2java工具包生氏银成对应java客户端

   
   

   publicstaticvoidmain(String[]args)throwsServiceException,RemoteException{
   //TODOAuto-generatedmethodstub
   Service1_Service1=newService1Locator();
   Service1Soap_PortType_Service1Soap_PortType;
   StringresultStr=null;
   
   _Service1Soap_PortType=_Service1.getService1Soap();
   resultStr=_Service1Soap_PortType.helloWorld("zybaby");
   
   System.out.println(resultStr);
   
   }

   
   
   

Ⅳ java调用vb webservice

java作为WebServices客户端，与服务器端什么语言开发关系不大，注意在字节传输过程中尽量用Byte字节类型，防止出现中文乱码。
两个开发webservices的工具包：axis 和XFire 本人首先接触的是axis。
两者比较如下：
相对于Axis来说，目前XFire相对受欢迎，加上其提供了和Spring集成的支持，在目前的Web Service开源社区拥有众多的追随者。并且因为XFire为Spring提供的支持，使得我们可以很容易在Spring中使用XFire构建Web Service应用。
知道了这两个框架你研究起来也就不难了。
下面我就基于xfire说一下开发说明：
xfire对WebServices的开发非常方便，在Eclipse里开发就更方便了。总结起来有这么几点：
1.编写类，跟普通JAVABEAN没什么区别。
2.配置文件
如果是要深层次的去理解WebServices还需努力，下面是我给你找的一个网上的例子作为参考：

使用XFire+Spring构建Web Service
XFire是与Axis 2并列的新一代Web Service框架，通过提供简单的API支持Web Service各项标准协议，帮助你方便快速地开发Web Service应用。
相 对于Axis来说，目前XFire相对受欢迎，加上其提供了和Spring集成的支持，在目前的Web Service开源社区拥有众多的追随者。并清模含且因为XFire为Spring提供的支持，使得我们可以很容易在Spring中使用XFire构建Web Service应用。
XFire与Axis2相比具有如下特征：
l 支持一系列Web Service的新标准--JSR181、WSDL2.0 、JAXB2、WS-Security等；
l 使用Stax解释XML,性能有了质的提高。XFire采用Woodstox 作Stax实现；
l 容易上手，可以方便快速地从pojo发布服务；
l 支持Spring、Pico、Plexus、Loom等容器；
l 灵活的Binding机制，包括默认的Aegis,xmlbeans,jaxb2,castor；
l 高性能的SOAP 栈设计；
l 支持Spring、Pico、Plexus、Loom等容器。
XFire与Axis1性能的比较如下：
l XFire比Axis1.3快2-6倍；
l XFire的响应时间是Axis1.3的1/2到1/5。
XFire在WebService框架中开始较晚，它从现有的框架中借鉴了许多优秀的理念，力争将Web Service的应用开发难度降到最低。此外，还提答笑供了各种绑定技术、支持多种传输协议，对WebService体系中许多新的规范提供了支持。
下面让我们来看一个XFire于Spring集成的helloWorld的简单例子。
一．实现的功能和特点
本例具有如下功能和特点：
1） 基于J2EE平台的Web Service服务；
2） 开发方便，配置简单；
3） 与spring无缝集成。
XFire是完全基于流数据处理进行工作的系统，这意味着XFire不是将整个SOAP文档缓存在内存中，而是以管道的方式接收SOAP流数据。这种工作方式的转变带来了可观的性能回报，同时节省了内存的占用。
XFire从 管道中接收一个SOAP请求到返回一个SOAP响应，会经历一系列的阶段。在管道调用的任何一个阶段，XFire都可以添加一些额外的Handler，在 对消息进行加工处理后再传入到下一个阶段中。在SOAP请求消息对Web Service发起真正调用之前码型，分别会经过传输、预转发、转发、策略实施、用户信息处理、预调用、服务调用等阶段。
二．开发环境
笔者的开发环境描述如下：
1） jdk: 1.5版本；
2） Tomcat：5.5.20；
3） MyEclipse:5.1.1 GA。
三．开发步骤

1. 工程与环境的建立
在MyEclipse 中新建Web工程，名为webservice_helloworld。选择该工程后，点击右键选择MyEclipse->Add Web Service Capabilities，弹出Add Web Service Capabilities对话框，点击“Next”，弹出Project Library Configuration对话框，默认选择Core Libraries，点击“Finish”按钮，完成XFire核心包的添加。为了后续的客户端的测试，还需读者加入commons- httpclient.jar包到WEB-INF/lib下。
部署后可看到此时WEB-INF/lib的jar包列表如下：
activation-1.1.jar、commons -beanutils-1.7.0.jar、commons-codec-1.3.jar、commons-httpclient.jar、 commons-logging-1.0.4.jar、jaxen-1.1-beta-9.jar、jaxws-api-2.0.jar、jdom- 1.0.jar、jsr173_api-1.0.jar、mail-1.4.jar、saaj-api-1.3.jar、saaj-impl- 1.3.jar、spring-1.2.6.jar、stax-api-1.0.1.jar、wsdl4j-1.5.2.jar、wstx-asl- 3.0.1.jar、xbean-2.1.0.jar、xbean-spring-2.5.jar、xfire-aegis-1.2.2.jar、 xfire-annotations-1.2.2.jar、xfire-core-1.2.2.jar、xfire-java5-1.2.2.jar、 xfire-jaxws-1.2.2.jar、xfire-jsr181-api-1.0-M1.jar、xfire-spring- 1.2.2.jar、XmlSchema-1.1.jar
为了后续的开发和测试，在src目录下分别建立test和webservice目录，分别用于存放测试文件和webservice的相关类。
2．Web Service实现的编写
在本例中，我们只是做一个helloWorld的简单例子。Web Service服务端提供一个根据输入的名字信息回复相应的helloWorld信息的。例如，当名字为“阿蜜果”时，恢复信息为“hello，阿蜜果”。下面让我们一步一步来开始进行编码。
1）web.xml的配置
一 般情况下，我们通过HTTP作为Web Service的传输协议，这样我们只需启动一个Web服务器(如Tomcat，在本例中使用的是Tomcat5.5.20)，这样客户端就可以通过 HTTP访问到Web Service服务。为了集成Spring容器，XFire专门提供一个XFireSpringServlet，我们可以在web.xml中配置该 Servlet，将Spring容器中定义的Web Service在某个URI下发布。
为了能正确使用XFire，需在web.xml中进行相应配置，在该文件中配置XFire的servlet和servlet-mapping。同时因为本实例需要将XFire集成到Spring中，因而需要在web.xml文件中加载Spring的相应配置文件。在本实例中，我们首先在WEB-INF下建立两个配置Spring配置文件，一个为applicationContext.xml，该文件用来定义本工程的bean，一个为xfire-servlet.xml，用来配置XFire的相关bean。修改后的web.xml的内容如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>XFireService</display-name>
<!-- begin Spring配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml,/WEB-INF/xfire-servlet.xml</param-value>
</context-param>
<listener>
<listener-class> org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<listener>
<listener-class> org.springframework.web.util.IntrospectorCleanupListener
</listener-class>
</listener>
<!-- end Spring配置 -->

<!-- begin XFire 配置 -->
<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>*.ws</url-pattern>
</servlet-mapping>
<servlet>
<!-- 配合Spring容器中XFire一起工作的Servlet-->
<servlet-name>xfireServlet</servlet-name>
<servlet-class>org.codehaus.xfire.spring.XFireSpringServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfireServlet</servlet-name>
<!-- 在这个URI下开放Web Service服务 -->
<url-pattern>/service/*</url-pattern>
</servlet-mapping>
<!-- end XFire 配置 -->
</web-app>

2）Web Service的接口类HelloWorld.java和对应实现类HelloWorldImpl.java

为了用Web Service完成HelloWorld功能，我们首先在src/webservice目录下建立接口类HelloWold.java。它仅包含一个sayHelloWorld(String name)的方法，其详细内容如下：

package webservice;

/** *//**
*HelloWorld的接口类.
*/
publicinterface HelloWorld {
/** *//**
*对名字为name的人打招呼.
*@paramname名字
*@return返回打招呼的字符串
*/
String sayHelloWorld(String name);
}
我们还需要建立一个对应的实现类，来实现sayHelloWorld的功能，该实现类即为HelloWorldImpl.java。该类的详细内容如下：
package webservice;
/** *//**
*HelloWorld的实现类.
*/
publicclass HelloWorldImpl implements HelloWorld {
public String sayHelloWorld(String name) {
String helloWorld = "hello," + name;
return helloWorld;
}
}

3）Spring配置文件applicationContext.xml和xfire-servlet.xml的配置

首先我们在applicationContext.xml文件中配置对应的bean——HelloWorldBean，该xml文件的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="HelloWorldBean" class="webservice.HelloWorldImpl"/>
</beans>
这个配置文件很简单，在此不详述。

XFire为Spring 提供了方便易用的导出器XFireExporter，借助该导出器的支持，我们可以在Spring容器中将一个POJO导出为Web Service。HelloWorld是业务服务类，在此拥有一个sayHelloWorld的方法，我们希望将此方法开放为Web Service。在实际应用中，如果某个类具有众多的方法，而其中的某些方法不需要开放为Web Service的情况下，我们可以定义一个窄接口，该接口中只需定义那些开放为Web Service的业务方法。

将一个业务类所有需要开放为Web Service的方法通过一个窄接口来描述是值得推荐的作法，这让Web Service的接口显得很“干净”。其次，XFire的导出器也需要服务接口的支持，因为它采用基于接口的动态代理技术。

窄接口中的方法在真实的系统中可能需要引用其它的业务类或DAO获取数据库中的真实数据，为了简化实例，我们在此简化了实例。

下面让我们看看在xfire-servlet.xml文件中导出器的设置，该文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!-- 引入XFire预配置信息 -->
<import resource="classpath:org/codehaus/xfire/spring/xfire.xml" />
<!—定义访问的url-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="urlMap">
<map>
<entry key="/HelloWorldService.ws">
<ref bean="HelloWorldService" />
</entry>
</map>
</property>
</bean>

<!-- 使用XFire导出器 -->
<bean id="baseWebService" class="org.codehaus.xfire.spring.remoting.XFireExporter" lazy-init="false" abstract="true">
<!-- 引用xfire.xml中定义的工厂 -->
<property name="serviceFactory" ref="xfire.serviceFactory" />
<!-- 引用xfire.xml中的xfire实例 -->
<property name="xfire" ref="xfire" />
</bean>
<bean id="HelloWorldService" parent="baseWebService">
<!-- 业务服务bean -->
<property name="serviceBean" ref="HelloWorldBean" />
<!-- 业务服务bean的窄接口类 -->
<property name="serviceClass" value="webservice.HelloWorld" />
</bean>
</beans>

在 上面的配置中，我们可以看到，在该配置文件中引入了xfire.xml这个Spring配置文件。它是在XFire核心JAR包中拥有一个预定义的 Spring配置文件，它定义了XFire在Spring中必须用到的一些Bean和资源，需要引入这个预定义的配置文件。从该配置文件中可以看出，我们 通过XFireExporter将业务类导出为Web Service，对于任何导出器，我们都需要引入XFire环境，即serviceFactory和xfire，这是标准的配置。ServiceFactory是XFire的核心类，它可以将一个POJO生成为一个Web Service。

在本实例中，我们通过定义一个baseWebService，其余的webService配置都将该bean作为父bean，这样可以简化Spring的配置，不需要多次引入serviceFactory和xfire。

3. Web Service的测试

在上一步操作完成之后，我们的这个简单的Web Service已经编写完毕，下面让我们来看看自己的劳动成果吧。

在浏览器中输入地址：http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl，我们可以看到HelloWorldService对应的WSDL信息，阅读这个WSDL文档，我们可以知道HelloWorld的sayHelloWorld方法已经被成功地发布为Web Service了。只要拿到这个WSDL就可以开发相应的客户端调用程序了。

XFire为访问服务端Web Service提供了各种方便的方式：我们一般根据服务地址和窄接口类创建客户调用程序。

在不能获得服务窄接口类的情况下，XFire允许我们通过WSDL文件生成客户端调用程序，通过指定服务接口的方式调用服务。

1）通过WSDL文件生成客户端调用程序

首先我们通过http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl我们可以获得WSDL文件HelloWorldService.wsdl，并将其放在src目录下面，接着我们通过程序访问该WSDL文件，并调用需测试的方法。此时测试类WebServiceClientTest.java的内容如下所示：

package test;

import org.codehaus.xfire.client.Client;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import webservice.HelloWorld;

/** *//**
*Copyright2007GuangZhouAmigo.
*Allrightreserved.
*HelloWorld的webservice的测试类.
*@author<a href="mailto:[email protected]">AmigoXie</a>
*@version1.0
*Creationdate:2007-9-16-下午05:36:05
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;

publicstaticvoid main(String[] args) throws Exception {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}

publicvoid testClient() throws Exception {
String wsdl = "HelloWorldService.wsdl"; //对应的WSDL文件
Resource resource = new ClassPathResource(wsdl);
Client client = new Client(resource.getInputStream(), null); //根据WSDL创建客户实例

Object[] objArray = new Object[1];
objArray[0] = "阿蜜果";
//调用特定的Web Service方法
Object[] results = client.invoke("sayHelloWorld", objArray);
System.out.println("result: " + results[0]);
}
}
运行该类，可得到如下输出结果：

result: hello,阿蜜果

可看出运行结果正确。

2）根据服务地址创建客户端调用程序

接着让我们来看一个根据服务地址创建客户端调用程序的例子。我们可以通过测试类来测试Web Service的正确性，下面让我们来看一个简单的测试类，首先我们在src/test目录建立WebServiceClientTest.java文件，并在src目录下建立客户端调用的Spring配置文件client.xml。在client.xml配置文件中我们定义了一个testWebService的bean，该bean访问wsdlDocumentUrl为http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl的WSDL。该xml文件的详细内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="testWebService" class="org.codehaus.xfire.spring.remoting.XFireClientFactoryBean">
<property name="serviceClass">
<value>webservice.HelloWorld</value>
</property>
<property name="wsdlDocumentUrl">
<value>http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl</value>
</property>
</bean>
</beans>

在WebServiceClientTest.java文件中获得HelloWorld，并调用它的sayHelloWorld方法来完成测试，该类的详细内容如下所示：

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.;
import webservice.HelloWorld;

/** *//**
*HelloWorld的webservice的测试类.
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;

publicstaticvoid main(String[] args) {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}

publicvoid testClient() {
ApplicationContext ctx = new (
"client.xml");
helloWorld = (HelloWorld) ctx.getBean("testWebService");
System.out.println(helloWorld.sayHelloWorld("阿蜜果"));
}
}

在启动webservice_helloworld工程的情况下，运行WebServiceClientTest类，可看到控制台包含如下信息：

hello,阿蜜果

由此可看出调用Web Service成功。

四．总结

与Axis 相比，在实施Web Service时XFire更加简洁高效，并且XFire对Spring提供了强大的支持，可以非常方便地在Spring中使用XFire实施Web Service，因此XFire在短短的时间里成为了受Web Service开发者喜爱的框架。

XFire为客户端提供了多种访问Web Service的方式，如果可以获取客户端的窄接口类，则可以采用窄接口类调用Web Service。如果仅能获取WSDL，XFire也可以采用动态反射的机制调用Web Service。XFire为Eclipse提供了一个可以根据WSDL生成客户端存根代码的插件，相信XFire也将为其它非Java语言提供类似的插 件。

在Axis2中也开始使用Stax来处理XML，还有Xfire不支持WSDL2.0, 而Axis2支持WSDL2.0。
还可使用Xfire的后续版本，Apache CXF (相当于 Xfire2.0).

Ⅵ java调用webservice接口具体怎么调用

使用HttpClient
用到的jar文件：commons-httpclient-3.1.jar
方法：
预先定义好Soap请求数据，可以借助于XMLSpy Professional软件来做这一步生成。

String soapRequestData = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
"<soap12:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap12=\"http://www.w3.org/2003/05/soap-envelope\">" +
"<soap12:Body>" +
" <getCountryCityByIp xmlns=\"http://WebXml.com.cn/\">" +
" <theIpAddress>219.137.167.157</theIpAddress>" +
" </getCountryCityByIp>" +
" </soap12:Body>" +
"</soap12:Envelope>";

然后定义一个PostMethod，这时需要指定web服务的Url;

PostMethod postMethod = new PostMethod(“http://www.webxml.com.cn/WebServices/IpAddressSearchWebService.asmx”);

然后把Soap请求数据添加到PostMethod中

byte[] b = soapRequestData.getBytes("utf-8");
InputStream is = new ByteArrayInputStream(b,0,b.length);
RequestEntity re = new InputStreamRequestEntity(is,b.length,"application/soap+xml; charset=utf-8");
postMethod.setRequestEntity(re);

最后生成一个HttpClient对象，并发出postMethod请求

HttpClient httpClient = new HttpClient();
statusCode = httpClient.executeMethod(postMethod);
String soapRequestData = postMethod.getResponseBodyAsString();

soapRequestData就是调用web服务的Soap响应数据，是xml格式的，可以通过解析soapRequestData来获得调用web服务的返回值。

Ⅶ 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接口流程

给你看看以前写的获取电话号码归属地的代码的三种方法，然后你就懂了。

importjava.io.ByteArrayOutputStream;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.net.HttpURLConnection;
importjava.net.URL;

importorg.apache.commons.httpclient.HttpClient;
importorg.apache.commons.httpclient.HttpException;
importorg.apache.commons.httpclient.methods.PostMethod;

publicclassMobileCodeService{

publicvoidhttpGet(Stringmobile,StringuserID)throwsException
{
//http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo?mobileCode=string&userID=string
URLurl=newURL("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo?mobileCode="+mobile+"&userID="+userID);
HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");

if(conn.getResponseCode()==HttpURLConnection.HTTP_OK)//200
{
InputStreamis=conn.getInputStream();

=newByteArrayOutputStream();//

byte[]buf=newbyte[1024];
intlen=-1;
while((len=is.read(buf))!=-1)
{
//获取结果
arrayOutputStream.write(buf,0,len);
}

System.out.println("Get方式获取的数据是:"+arrayOutputStream.toString());
arrayOutputStream.close();
is.close();
}
}


publicvoidhttpPost(Stringmobile,StringuserID)throwsHttpException,IOException
{
//访问路径http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo
//HttpClient访问

HttpClienthttpClient=newHttpClient();
PostMethodpm=newPostMethod("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo");

pm.setParameter("mobileCode",mobile);
pm.setParameter("userID",userID);

intcode=httpClient.executeMethod(pm);
System.out.println("状态码:"+code);

//获取结果
Stringresult=pm.getResponseBodyAsString();
System.out.println("获取到的数据是:"+result);
}

publicvoidSOAP()throwsException
{
HttpClientclient=newHttpClient();

PostMethodmethod=newPostMethod("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx");

//设置访问方法的参数
method.setRequestBody(newFileInputStream("C:\soap.xml"));

method.setRequestHeader("Content-Type","text/xml;charset=utf-8");

intcode=client.executeMethod(method);
System.out.println("状态码:"+code);

//获取结果
Stringresult=method.getResponseBodyAsString();
System.out.println("获取到的数据是:"+result);
}

publicstaticvoidmain(String[]args)throwsException{
MobileCodeServicemcs=newMobileCodeService();
mcs.httpGet("18524012513","");
//mcs.httpPost("18524012513","");
//mcs.SOAP();
}
}

Ⅸ java axis调用webservice，接口方法中的数组型参数应该怎么传参

虽然我没用过你这个并兄开发webservice，但用过xfire,建议你把数顷告组改为string传值绝乎袭，然后那边进行split再转为数组

Ⅹ java语言使用post方式调用webService方式

WebService可以有Get、Post、Soap、Document四种方式调用，以下Java通过post方式调用WebService代码：

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.io.OutputStreamWriter;
importjava.net.URL;
importjava.net.URLConnection;
importjava.net.URLEncoder;
importorg.apache.cxf.endpoint.Client;
importorg.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
/**
*功能描述：WebService调用
*
*/
publicclassClientTest{
/**
*功能描述：HTTP-POST
*
*/
publicStringpost(){
OutputStreamWriterout=null;
StringBuildersTotalString=newStringBuilder();
try{
URLurlTemp=newURL(
"http://www.webxml.com.cn/WebServices/WeatherWebService.asmx/getSupportCity");
URLConnectionconnection=urlTemp.openConnection();
connection.setDoOutput(true);
out=newOutputStreamWriter(connection.getOutputStream(),"UTF-8");
StringBuffersb=newStringBuffer();
sb.append("byProvinceName=福建");
out.write(sb.toString());
out.flush();
StringsCurrentLine;
sCurrentLine="";
InputStreaml_urlStream;
l_urlStream=connection.getInputStream();//请求
BufferedReaderl_reader=newBufferedReader(newInputStreamReader(
l_urlStream));
while((sCurrentLine=l_reader.readLine())!=null){
sTotalString.append(sCurrentLine);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
if(null!=out){
try{
out.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
returnsTotalString.toString();
}
}