java webservice 接口实现方式
java webservice 接口实现方式
java webservice 接口实现方式摘要:1.Java WebService 简介2.Java WebService 接口实现方式2.1 JAX-RPC2.2 JAX-WS2.3 JAX-WS RI2.4 JAXB正文:【Java WebService 简介】Java WebService 是一种基于Java 语言的Web 服务技术,它允许Java 开发人员创建可与其他应用程序进行交互的Web 服务。
Java WebService 技术可以帮助开发人员实现跨平台、跨语言的通信,从而满足不同应用程序之间的集成需求。
【Java WebService 接口实现方式】Java WebService 有多种接口实现方式,下面将详细介绍其中的四种:【2.1 JAX-RPC】Java API for XML RPC (JAX-RPC) 是Java WebService 的一种接口实现方式,它使用XML 格式来表示数据和方法调用。
JAX-RPC 通过将Java 对象编码为XML,然后将其发送到服务器进行解码和处理,从而实现客户端和服务器之间的通信。
【2.2 JAX-WS】Java API for XML Web Services (JAX-WS) 是Java WebService 的另一种接口实现方式,它基于XML 和WSDL(Web 服务描述语言)来描述Web 服务的接口和功能。
JAX-WS 允许开发人员使用类似于RPC 的方式来调用Web 服务,同时也支持更加复杂的Web 服务功能,如事务、安全和可靠的数据传输。
【2.3 JAX-WS RI】JAX-WS RI(Reference Implementation)是JAX-WS 的一个参考实现,它提供了一个用于创建和部署Web 服务的工具集。
JAX-WS RI 支持多种传输协议,如HTTP、HTTPS 和JMS,同时还支持多种数据格式,如XML、JSON 和Text。
javawebservice接口调用实例
Java Web Service 是一种轻量级的、基于标准的 Web 协议进行通讯的服务。
它允许在异构系统之间进行交互,并支持跨评台。
在本篇文章中,我们将介绍如何在 Java 中使用 Web Service 接口进行调用的实例。
1. 确定 Web Service 接口我们需要确定要调用的 Web Service 接口。
通常情况下,我们可以通过 WSDL(Web Services Description Language)文档来获取接口的相关信息,包括接口的位置区域、方法名以及参数列表等。
2. 创建 Java 项目在 Eclipse 或者其他 Java 开发环境中,我们可以创建一个新的 Java 项目。
在项目中,我们需要引入相关的 Web Service 库,以便在代码中进行调用。
3. 生成客户端代码通过 WSDL 文档,我们可以使用工具来生成客户端代码。
这些工具通常包括 wsimport(用于生成客户端代码)等。
生成的客户端代码将包含接口的相关信息,以便我们在代码中进行调用。
4. 编写调用代码在生成客户端代码之后,我们可以编写调用代码来实现对 Web Service 接口的调用。
在代码中,我们需要首先创建对应的 WebService 客户端实例,然后通过该实例来调用接口中的方法。
5. 编译和运行完成代码编写之后,我们需要对代码进行编译,并运行相应的测试。
在运行的过程中,我们可以观察接口的调用情况,以及调用结果。
6. 处理异常情况在实际的调用过程中,我们经常会遇到各种异常情况,比如网络连接失败、接口调用超时等。
我们需要在代码中添加相应的异常处理逻辑,以保证程序的稳定性和可靠性。
通过以上步骤,我们可以实现在Java 中对Web Service 接口的调用。
通过这种方式,我们可以实现不同系统之间的数据交互,实现数据共享和系统集成。
我们也可以利用 Web Service 在不同评台之间实现数据的传输和处理,为企业的信息化建设提供更多的可能性。
java 调用webservice的各种方法总结
一、利用jdk web服务api实现,这里使用基于 SOAP message 的 Web 服务1.首先建立一个Web services EndPoint:Java代码package Hello;import javax.jws.WebService;import javax.jws.WebMethod;import javax.xml.ws.Endpoint;@WebServicepublic class Hello {@WebMethodpublic String hello(String name) {return "Hello, " + name + "\n";}public static void main(String[] args) {// create and publish an endpointHello hello = new Hello();Endpoint endpoint = Endpoint.publish("http://localhost:8080/hello", hello);}}2.使用apt 编译Hello.java(例:apt -d [存放编译后的文件目录] Hello.java ) ,会生成 jaws目录3.使用java Hello.Hello运行,然后将浏览器指向http://localhost:8080/hello?wsdl就会出现下列显示4.使用wsimport 生成客户端使用如下:wsimport -p . -keep http://localhost:8080/hello?wsdl5.客户端程序:Java代码1.class HelloClient{2.3.public static void main(String args[]) {4.5. HelloService service = new HelloService();6.7. Hello helloProxy = service.getHelloPort();8.9. String hello = helloProxy.hello("你好");10.11. System.out.println(hello);12.13. }14.15.}16.二、使用xfire,我这里使用的是myeclipse集成的xfire进行测试的利用xfire开发WebService,可以有三种方法:1一种是从javabean 中生成;2 一种是从wsdl文件中生成;3 还有一种是自己建立webservice步骤如下:用myeclipse建立webservice工程,目录结构如下:首先建立webservice接口,代码如下:Java代码1.package com.myeclipse.wsExample;2.3.//Generated by MyEclipse4.5.6.7.public interface IHelloWorldService {8.9.10.11. public String example(String message);12.13.14.15.}16.Java代码1.package com.myeclipse.wsExample;2.3.//Generated by MyEclipse4.5.6.7.public class HelloWorldServiceImpl implements IHelloWorldService{8.9.10.11. public String example(String message) {12.13. return message;14.15. }16.17.18.19.}20.修改service.xml 文件,加入以下代码:Xml代码1.2.3.<service>4.5.<name>HelloWorldService</name>6.7.<serviceClass>8.9. com.myeclipse.wsExample.IHelloWorldService10.11. </serviceClass>12.13. <implementationClass>14.15. com.myeclipse.wsExample.HelloWorldServiceImpl16.17. </implementationClass>18.19. <style>wrapped</style>20.21. <use>literal</use>22.23. <scope>application</scope>24.25.</service>26.把整个项目部署到tomcat服务器中,打开浏览器,输入http://localhost:8989/HelloWorld/services/HelloWorldService?wsdl客户端实现如下:Java代码1.package com.myeclipse.wsExample.client;2.3.import .MalformedURLException;4.5.import .URL;6.7.8.9.import org.codehaus.xfire.XFireFactory;10.11.import org.codehaus.xfire.client.Client;12.13.import org.codehaus.xfire.client.XFireProxyFactory;14.15.import org.codehaus.xfire.service.Service;16.17.import org.codehaus.xfire.service.binding.ObjectServiceFactory;18.19.20.21.import com.myeclipse.wsExample.IHelloWorldService;22.23.24.25.public class HelloWorldClient {26.27.public static void main(String[] args) throws MalformedURLException, Exception {28.29.// TODO Auto-generated method stub30.31.Service s=new ObjectServiceFactory().create(IHelloWorldService.class);32.33.XFireProxyFactory xf=new XFireProxyFactory(XFireFactory.newInstance().getXFire());34.35.String url="http://localhost:8989/HelloWorld/services/HelloWorldService";36.37.38.39. try40.41. {42.43.44.45. IHelloWorldService hs=(IHelloWorldService) xf.create(s,url);46.47. String st=hs.example("zhangjin");48.49. System.out.print(st);50.51. }52.53. catch(Exception e)54.55. {56.57. e.printStackTrace();58.59. }61. }62.63.64.65.}66.这里再说点题外话,有时候我们知道一个wsdl地址,比如想用java客户端引用.net 做得webservice,使用myeclipse引用,但是却出现无法通过验证的错误,这时我们可以直接在类中引用,步骤如下:Java代码1.public static void main(String[] args) throws MalformedURLException, Exception {2.3.// TODO Auto-generated method stub4.5. Service s=new ObjectServiceFactory().create(IHelloWorldService.class);6.7. XFireProxyFactory xf=new XFireProxyFactory(XFireFactory.newInstance().getXFire());8.9.10.11.//远程调用.net开发的webservice12.13.Client c=new Client(new URL("/webservices/qqOnlineWebService.asmx?wsdl"));15. Object[] o=c.invoke("qqCheckOnline", new String[]{"531086641","591284436"});16.17.18.19.//调用.net本机开发的webservice20.21.Client c1=new Client(new URL("http://localhost/zj/Service.asmx?wsdl"));22.23.Object[] o1=c1.invoke("HelloWorld",new String[]{});24.25.26.27.}28.三、使用axis1.4调用webservice方法前提条件:下载axis1.4包和tomcat服务器,并将axis文件夹复制到tomcat服务器的webapp文件夹中这里我就说一下最简单的方法:首先建立一个任意的java类(例如:HelloWorld.java),复制到axis 文件夹下,将其扩展名改为jws,然后重新启动tomcat,在浏览器中输入http://localhost:8989/axis/HelloWorld.jws?wsdl,就会得到一个wsdl文件,其客户端调用方法如下:Java代码1.import javax.xml.rpc.Service;2.3.import javax.xml.rpc.ServiceException;4.5.import javax.xml.rpc.ServiceFactory;6.7.import .MalformedURLException;8.9.import .URL;10.11.import java.rmi.RemoteException;12.13.import space.QName;14.15.16.17.public class TestHelloWorld {18.19.20.21.22.23. public static void main(String[] args) throws MalformedURLException, ServiceException, RemoteException {24.25. // TODO Auto-generated method stub26.27.28.29. String wsdlUrl ="http://localhost:8989/axis/HelloWorld.jws?wsdl";30.31. String nameSpaceUri ="http://localhost:8989/axis/HelloWorld.jws";32.33. String serviceName = "HelloWorldService";34.35. String portName = "HelloWorld";36.37.38.39. ServiceFactory serviceFactory = ServiceFactory.newInstance();40.41. Service afService =serviceFactory.createService(new URL(wsdlUrl),new QName(nameSpaceUri, serviceName));42.43. HelloWorldInterface proxy = (HelloWorldInterface)afService.getPort(new QName(nameSpaceUri, portName),HelloWorldInterfa ce.class);44.45. System.out.println("return value is "+proxy.getName("john") ) ;46.47.48.49. }50.51.52.53.}54.四、使用axis2开发webservice(这里首先感谢李宁老师)使用axis2 需要先下载axis2-1.4.1-bin.zipaxis2-1.4.1-war.zip/axis2/同理,也需要将axis2复制到webapp目录中在axis2中部署webservice有两种方法,第一种是pojo方式,这种方式比较简单,但是有一些限制,例如部署的类不能加上包名第二种方式是利用xml发布webservice,这种方法比较灵活,不需要限制类的声明下面分别说明使用方法:1.pojo方式:在Axis2中不需要进行任何的配置,就可以直接将一个简单的POJO发布成WebService。
webservice 接口写法 java
深入了解Java中的WebService接口编写一、引言在当今的信息化社会,数据交换已经成为我们生活和工作中不可或缺的一部分。
而Web服务(WebService)作为一种基于网络的分布式计算模型,为跨平台的数据交换提供了可能。
其中,Java作为应用最广泛的编程语言之一,其对WebService的支持也十分强大。
本文将详细阐述如何在Java中编写WebService接口。
二、WebService基础WebService是一种允许不同应用程序通过HTTP进行交互的技术,使得应用程序可以使用标准的XML消息进行通信,实现数据共享和服务集成。
简单来说,WebService就是一种让两个应用程序通过互联网进行通信的方式。
三、Java中的WebServiceJava对WebService的支持主要体现在JAX-WS(Java API for XML Web Services)框架上。
JAX-WS提供了一种简单易用的API来创建和访问WebService。
下面我们就来看看如何在Java中编写一个简单的WebService接口。
四、编写WebService接口首先,我们需要创建一个Java接口,这个接口将被发布为WebService。
例如:```javaimport javax.jws.WebMethod;import javax.jws.WebService;@WebServicepublic interface HelloWorld {@WebMethodpublic String sayHello(String name);}```在这个例子中,`@WebService`注解用于指定该接口是一个WebService,`@WebMethod`注解则用于指定该方法是可以被远程调用的。
然后,我们需要创建一个实现了上述接口的类。
例如:```javaimport javax.jws.WebService;@WebService(endpointInterface = .example.HelloWorld")public class HelloWorldImpl implements HelloWorld {@Overridepublic String sayHello(String name) {return "Hello, " + name;}}```在这里,`@WebService`注解中的`endpointInterface`属性指定了实现的接口。
java发布并调用webservice接口简单示例
java发布并调⽤webservice接⼝简单⽰例如何发布⼀个webservice:1. 创建⼀个web项⽬其中主要包括webservice接⼝,实现类,发布类《接⼝》package com.yonyou.webservice;import javax.jws.WebMethod;@javax.jws.WebServicepublic interface WebService {@WebMethodString sayhello(String name);}这是WebService接⼝,其中定义了⼀个sayHello(String name)的⽅法记住⼀定要在类上加上@WebService注解@WebMethod注解声明了这个⽅法是要发布出去的⽅法《接⼝实现类》package com.yonyou.webservice;@javax.jws.WebServicepublic class WebServiceImpl implements WebService {@Overridepublic String sayhello(String name) {System.out.println("WebService begin...... "+name);return name;}}《发布类》直接执⾏main⽅法,注意需要调⽤接⼝时此main⽅法要启动package com.yonyou.webservice;import javax.xml.ws.Endpoint;public class WebServicePublish {public static void main(String[] args) {//访问地址 http://localhost:8080/WS_Server/Webservice?wsdlString address = "http://localhost:8080/WS_Server/Webservice";Endpoint.publish(address, new WebServiceImpl());System.out.println("Webservice已发布");}}浏览器访问http://localhost:8080/WS_Server/Webservice?wsdl地址显⽰如下,webservice接⼝发布成功如何调⽤发布成功的webservice:(1)可以使⽤soapUI⼯具调⽤测试(2)客户端调⽤创建⼀个客户端项⽬Win+R组合键进⼊命令⾏在cmd中输⼊wsimport -s 我们这个项⽬的src路径 -keep 我们发布的webservice地址例如:wsimport -s F:\GX\workspace\webserviceClient\src -keep http://localhost:8080/WS_Server/Webservice?wsdl编译完成会在客户端项⽬中⽣成许多类⾃⼰写的⼀个客户端的测试类WsClientpackage com.yonyou.webservice;public class WsClient {public static void main(String[] args) {WebServiceImplService factory = new WebServiceImplService();WebServiceImpl wsimpl = factory.getWebServiceImplPort();String result = wsimpl.sayhello("Webservice调⽤成功");System.out.println("测试webservice结果为: "+result);}}执⾏测试类,看是否调⽤webservice接⼝成功。
webservice java调用示例
Web服务是一种基于网络的软件系统,它使用标准化的XML消息格式来交换数据。
这篇文章将介绍如何在Java中调用Web服务的示例。
1. 准备工作在开始调用Web服务之前,我们需要确保已经安装了Java开发环境,并且已经了解了Web服务的基本概念和相关知识。
2. 创建Java项目我们需要创建一个新的Java项目。
可以使用Eclipse、IntelliJ IDEA或者其他Java集成开发环境来创建项目。
在项目中,我们需要创建一个新的Java类来进行Web服务的调用。
3. 导入Web服务接口在Java项目中,我们需要导入Web服务的接口。
这可以通过WSDL (Web服务描述语言)文件来实现。
WSDL文件定义了Web服务的接口和可用操作。
可以使用wsimport工具来生成Java代码,该工具在Java的安装目录下的bin目录中可以找到。
4. 调用Web服务一旦导入了Web服务的接口,我们就可以使用Java代码来调用Web 服务了。
我们可以通过创建代理对象来调用Web服务的操作。
以下是一个简单的示例代码:```javaimport.example.webservice.MyWebService;import.example.webservice.MyWebServiceService;public class WebServiceClient {public static void main(String[] args) {MyWebServiceService service = new MyWebServiceService();MyWebService port = service.getMyWebServicePort();// 调用Web服务的操作String result = port.sayHello("World");System.out.println(result);}}```在这个示例中,我们首先创建了Web服务的代理对象,然后调用了Web服务的sayHello操作,并打印出了返回的结果。
java实现简单的webservice方式
java实现简单的webservice⽅式本⽂实例为⼤家分享了java实现webservice⽅式的具体代码,供⼤家参考,具体内容如下经过测试 jdk1.6.10以下会出现bug 建议使⽤10以上版本1、定义接⼝package org.enson.chan;import javax.jws.WebService;import javax.jws.soap.SOAPBinding;@WebService@SOAPBinding(style=SOAPBinding.Style.RPC)public interface IMyService {public int add(int a , int b);public int max(int a , int b);}2、实现接⼝package org.enson.chan;import javax.jws.WebService;@WebService(endpointInterface="org.enson.chan.IMyService")public class MyServiceImpl implements IMyService {public int add(int a, int b) {System.out.println(a+"+"+b+"="+(a+b));return a+b;}public int max(int a, int b) {System.out.println("a与b⽐较⼤⼩,取⼤值"+((a>b)?a:b));return (a>b)?a:b;}}3、定义服务package org.enson.chan;import javax.xml.ws.Endpoint;public class MyServer {public static void main(String[] args) {String address = "http://localhost:8090/ns";Endpoint.publish(address, new MyServiceImpl());}}4、测试服务package org.enson.chan;import .MalformedURLException;import .URL;import space.QName;import javax.xml.ws.Service;public class TestClient {public static void main(String[] args) {try {URL url = new URL("http://localhost:8090/ns?wsdl");QName sname = new QName("/", "MyServiceImplService");//创建服务Service service = Service.create(url,sname);//实现接⼝IMyService ms = service.getPort(IMyService.class);System.out.println(ms.add(12,33));//以上服务有问题,依然依赖于IMyServie接⼝} catch (MalformedURLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}5、TestSoapimport java.io.IOException;import java.io.StringReader;import java.io.StringWriter;import .URL;import javax.xml.bind.JAXBContext;import javax.xml.bind.JAXBException;import javax.xml.bind.Marshaller;import space.QName;import javax.xml.soap.MessageFactory;import javax.xml.soap.SOAPBody;import javax.xml.soap.SOAPBodyElement;import javax.xml.soap.SOAPEnvelope;import javax.xml.soap.SOAPException;import javax.xml.soap.SOAPHeader;import javax.xml.soap.SOAPMessage;import javax.xml.soap.SOAPPart;import javax.xml.transform.Source;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerConfigurationException; import javax.xml.transform.TransformerException;import javax.xml.transform.TransformerFactory;import javax.xml.transform.TransformerFactoryConfigurationError; import javax.xml.transform.dom.DOMResult;import javax.xml.transform.stream.StreamSource;import javax.xml.ws.Dispatch;import javax.xml.ws.Service;import javax.xml.ws.soap.SOAPFaultException;import javax.xml.xpath.XPath;import javax.xml.xpath.XPathConstants;import javax.xml.xpath.XPathExpressionException;import javax.xml.xpath.XPathFactory;import org.junit.Test;import er;import org.w3c.dom.Document;import org.w3c.dom.Node;import org.w3c.dom.NodeList;public class TestSoap {private String ns = "/";private String wsdlUrl = "http://localhost:8989/ms?wsdl";@Testpublic void test01() {try {MessageFactory factory = MessageFactory.newInstance();SOAPMessage message = factory.createMessage();SOAPPart part = message.getSOAPPart();SOAPEnvelope envelope = part.getEnvelope();SOAPBody body = envelope.getBody();QName qname = new QName("/webservice","add","ns");//<ns:add xmlns="/webservice"/>//body.addBodyElement(qname).setValue("<a>1</a><b>2</b>");SOAPBodyElement ele = body.addBodyElement(qname);ele.addChildElement("a").setValue("22");ele.addChildElement("b").setValue("33");message.writeTo(System.out);} catch (SOAPException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}@Testpublic void test02() {try {URL url = new URL(wsdlUrl);QName sname = new QName(ns,"MyServiceImplService");Service service = Service.create(url,sname);Dispatch<SOAPMessage> dispatch = service.createDispatch(new QName(ns,"MyServiceImplPort"), SOAPMessage.class, Service.Mode.MESSAGE);SOAPMessage msg = MessageFactory.newInstance().createMessage();SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();SOAPBody body = envelope.getBody();QName ename = new QName(ns,"add","nn");//<nn:add xmlns="xx"/>SOAPBodyElement ele = body.addBodyElement(ename);ele.addChildElement("a").setValue("22");ele.addChildElement("b").setValue("33");msg.writeTo(System.out);System.out.println("\n invoking.....");SOAPMessage response = dispatch.invoke(msg);response.writeTo(System.out);System.out.println();Document doc = response.getSOAPPart().getEnvelope().getBody().extractContentAsDocument();String str = doc.getElementsByTagName("addResult").item(0).getTextContent();System.out.println(str);} catch (SOAPException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}@Testpublic void test03() {try {URL url = new URL(wsdlUrl);QName sname = new QName(ns,"MyServiceImplService");Service service = Service.create(url,sname);Dispatch<Source> dispatch = service.createDispatch(new QName(ns,"MyServiceImplPort"),Source.class, Service.Mode.PAYLOAD);User user = new User(3,"zs","张三","11111");JAXBContext ctx = JAXBContext.newInstance(User.class);Marshaller mar = ctx.createMarshaller();mar.setProperty(Marshaller.JAXB_FRAGMENT, true);StringWriter writer= new StringWriter();mar.marshal(user, writer);String payload = "<nn:addUser xmlns:nn=\""+ns+"\">"+writer.toString()+"</nn:addUser>";System.out.println(payload);StreamSource rs = new StreamSource(new StringReader(payload));Source response = (Source)dispatch.invoke(rs);Transformer tran = TransformerFactory.newInstance().newTransformer();DOMResult result = new DOMResult();tran.transform(response, result);XPath xpath = XPathFactory.newInstance().newXPath();NodeList nl = (NodeList)xpath.evaluate("//user", result.getNode(),XPathConstants.NODESET);User ru = (User)ctx.createUnmarshaller().unmarshal(nl.item(0));System.out.println(ru.getNickname());} catch (IOException e) {e.printStackTrace();} catch (JAXBException e) {e.printStackTrace();} catch (TransformerConfigurationException e) {e.printStackTrace();} catch (TransformerFactoryConfigurationError e) {e.printStackTrace();} catch (TransformerException e) {e.printStackTrace();} catch (XPathExpressionException e) {e.printStackTrace();}}@Testpublic void test04() {try {URL url = new URL(wsdlUrl);QName sname = new QName(ns,"MyServiceImplService");Service service = Service.create(url,sname);Dispatch<SOAPMessage> dispatch = service.createDispatch(new QName(ns,"MyServiceImplPort"), SOAPMessage.class, Service.Mode.MESSAGE);SOAPMessage msg = MessageFactory.newInstance().createMessage();SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();SOAPBody body = envelope.getBody();SOAPHeader header = envelope.getHeader();if(header==null) header = envelope.addHeader();QName hname = new QName(ns,"authInfo","nn");header.addHeaderElement(hname).setValue("aabbccdd");QName ename = new QName(ns,"list","nn");//<nn:add xmlns="xx"/>body.addBodyElement(ename);msg.writeTo(System.out);System.out.println("\n invoking.....");SOAPMessage response = dispatch.invoke(msg);response.writeTo(System.out);System.out.println();Document doc = response.getSOAPBody().extractContentAsDocument();NodeList nl = doc.getElementsByTagName("user");JAXBContext ctx = JAXBContext.newInstance(User.class);for(int i=0;i<nl.getLength();i++) {Node n = nl.item(i);User u = (User)ctx.createUnmarshaller().unmarshal(n);System.out.println(u.getNickname());}} catch (SOAPException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} catch (JAXBException e) {e.printStackTrace();}}@Testpublic void test05() {try {URL url = new URL(wsdlUrl);QName sname = new QName(ns,"MyServiceImplService");Service service = Service.create(url,sname);Dispatch<SOAPMessage> dispatch = service.createDispatch(new QName(ns,"MyServiceImplPort"), SOAPMessage.class, Service.Mode.MESSAGE);SOAPMessage msg = MessageFactory.newInstance().createMessage();SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();SOAPBody body = envelope.getBody();QName ename = new QName(ns,"login","nn");//<nn:add xmlns="xx"/>SOAPBodyElement ele = body.addBodyElement(ename);ele.addChildElement("username").setValue("ss");ele.addChildElement("password").setValue("dd");msg.writeTo(System.out);System.out.println("\n invoking.....");SOAPMessage response = dispatch.invoke(msg);response.writeTo(System.out);System.out.println();} catch(SOAPFaultException e){System.out.println(e.getMessage());} catch (SOAPException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
Java调用CXFWebService接口的两种方式实例
Java调⽤CXFWebService接⼝的两种⽅式实例1.静态调⽤// 创建WebService客户端代理⼯⼚JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();// 判断是否抛出异常factory.getOutInterceptors().add(new LoggingInInterceptor());// 注册webservice接⼝factory.setServiceClass(DeductionService.class);// 配置webservice地址factory.setAddress("http://localhost:7002/card/services/HelloWorld?wsdl");// 获得接⼝对象CxfService service = (CxfService) factory.create();// 调⽤接⼝⽅法String result = service.sayHello("aaaaaaaaaa");System.out.println("调⽤结果:" + result);// 关闭接⼝连接System.exit(0);2.动态调⽤:JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();org.apache.cxf.endpoint.Client client = dcf.createClient("http://localhost:7002/card/services/HelloWorld?wsdl");// url为调⽤webService的wsdl地址QName name = new QName("/", "sayHello");// namespace是命名空间,methodName是⽅法名String xmlStr = "aaaaaaaa";// paramvalue为参数值Object[] objects;try {objects = client.invoke(name, xmlStr);System.out.println(objects[0].toString());} catch (Exception e) {e.printStackTrace();}区别:静态调⽤需要依赖service类,因为客户端调⽤cxf webservice接⼝的过程中需要服务器端提供service,很不⽅便,如果同⼀个项⽬中则没有区别。
java-webservice的简单实现
java-webservice的简单实现服务端: 1.创建正常j2ee项⽬,创建service接⼝1package service;2import javax.jws.WebMethod;3import javax.jws.WebService;45/**6 * WebService27*/8 @WebService9public interface HelloService {1011 @WebMethod12 String sayHello(String name, int i);1314 }实现类:1package service.impl;23import javax.jws.WebService;45import service.HelloService;67/**8 * HelloServiceImpl9*/10 @WebService11public class HelloServiceImpl implements HelloService {1213 @Override14public String sayHello(String name, int i) {15 System.out.println("服务端的服务被调⽤了............");16return "hello" + name;17 }18192021 }发布服务:1package service;23import javax.xml.ws.Endpoint;45import service.impl.HelloServiceImpl;678/**9 * ServicePublish10*/11public class ServicePublish {1213public static void main(String[] args) {14 String address = "http://localhost:8099/hello";15 Object implementor = new HelloServiceImpl();16 Endpoint.publish(address, implementor);17 System.out.println("发布成功");18 }19 }直接运⾏main⽅法启动服务端,然后再浏览器访问: http://localhost:8099/hello?wsdl看到如下,说明发布成功客户端: 1.⽤wsimport ⼯具解析wsdl⽣成代码 wsimport -s "⽣成代码的物理路径" http://localhost:8099/hello?wsdl 2.,⽣成的代码如图(服务端类的名称不⼀样,⽣成结果也不⼀样)3.创建⼀个测试类调⽤测试1package client;23/**4 * 1.通过wsimport解析wsdl创建代码5 * 2.通过本地代码创建代理6 * 3.通过代理对象调⽤⽅法7 * WsClient8*/9public class WsClient {10public static void main(String[] args) {11 HelloServiceImplService ss = new HelloServiceImplService();12 HelloServiceImpl prosy = ss.getHelloServiceImplPort();13 String res = prosy.sayHello("佩佩", 33);14 System.out.println(res);15 }1617 }备注: 以上环境是基于jdk1.8。
webservice实现有多种方式
webservice实现有多种方式比如最常用的有axis框架,xfire框架,通过该框架可以发布wsdl接口,也可以实现webservice客户端,目前eclipse都有集成的插件,可以根据wsdl文件生成webservice客户端调用接口,但是这样部署的时候必须依赖框架的jar包,有时候可能因为环境等等原因,我们仅仅需要wsdl中的某一个接口,这时候可以通过http接口或socket接口直接发生xml 数据,来调用服务端webservice服务,其实webservice底层还是发送xml数据,只是框架封装了对xml数据进行序列化与反序列化操作,下面以两个简单的例子说明http方式和socket方式。
http实现webservice接口调用例子:[c-sharp]view plain copy1.import <a href="/base/17"class='replace_word' title="Java EE知识库" target='_blank' style='color:#df3434; font-weight:bold;'>Java</a>.io.Buffe redReader;2.import java.io.IOException;3.import java.io.InputStreamReader;4.import java.io.OutputStreamWriter;5.import java.io.UnsupportedEncodingException;6.import .MalformedURLException;7.import .URL;8.import .URLConnection;9.10.public class HttpPostTest {11.void testPost(String urlStr) {12.try {13. URL url = new URL(urlStr);14. URLConnection con = url.openConnection();15. con.setDoOutput(true);16. con.setRequestProperty("Pragma:", "no-cache");17. con.setRequestProperty("Cache-Control", "no-cache");18. con.setRequestProperty("Content-Type", "text/xml");19.20. OutputStreamWriter out = new OutputStreamWriter(con.getOutputStream());21. String xmlInfo = getXmlInfo();22.out.write(new String(xmlInfo));23.out.flush();24.out.close();25. BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));26. String line = "";27. StringBuffer buf = new StringBuffer();28.for (line = br.readLine(); line != null; line = br.readLine()) {29. buf.append(new String(line.getBytes(),"UTF-8"));30. }31. System.out.println(buf.toString());32. } catch (MalformedURLException e) {33. e.printStackTrace();34. } catch (IOException e) {35. e.printStackTrace();36. }37. }38.39.private String getXmlInfo() {40.// 通过wsdl文件可以查看接口xml格式数据,构造调用接口xml数据41. String xml = "<SOAP-ENV:Envelope xmlns:SOAP-ENV=/"http://schemas.xml/soap/envelope//" xmlns:SOAP-ENC=/"/soap/e ncoding//" xmlns:xsi=/"/2001/XMLSchema-instance/" xmlns:xsd =/"/2001/XMLSchema/">"42. + "<SOAP-ENV:Body>"43. + "<m:getItemDetailSingle xmlns:m=/"http:xxxxxxxxxxxxxxxxxx//">"44. + "<itemMo>"45. + "<category>工厂类</category>"46. + "<city>北京</city>"47. + "<flag>1</flag>"48. + "<itemId>0</itemId>"49. + "<itemIndex>1</itemIndex>"50. + "<keyword></keyword>"51. + "<mobile>2147483647</mobile>"52. + "<password>123456</password>"53. + "<userName>sohu</userName>"54. + "</itemMo>"55. + "</m:getItemDetailSingle>"56. + "</SOAP-ENV:Body>"57. + "</SOAP-ENV:Envelope>";58.return xml;59. }60.61.public static void main(String[] args) throws UnsupportedEncodingException {62. String url = "http://localhost:9003/dataService/services/Job";63.new HttpPostTest().testPost(url);64. }65.}socke方式实现例子:[c-sharp]view plain copy1.import java.io.IOException;2.import java.io.InputStream;3.import java.io.InputStreamReader;4.import java.io.OutputStream;5.import .Socket;6.import .UnknownHostException;7.8.9.public class WebServiceClient {10.11./**12. * @param args13. * @throws IOException14. * @throws UnknownHostException15. */16.public static void main(String[] args) throws UnknownHostException, IOException {17. Socket socket = new Socket("localhost",9003);18. OutputStream os = socket.getOutputStream();19. InputStream is = socket.getInputStream();20.//System.out.println(socket.isConnected());21. String httpSend = "POST /dataService/services/Job HTTP/1.1/r/n"22. + "Content-Type:text/xml/r/n"23. + "Host:localhost:9003/r/n"24. + "Content-Length:1024/r/n"25. + "/r/n"26. + "<SOAP-ENV:Envelope xmlns:SOAP-ENV=/"http://schema/soap/envelope//" xmlns:SOAP-ENC=/"/s oap/encoding//" xmlns:xsi=/"/2001/XMLSchema-instance/" xmln s:xsd=/"/2001/XMLSchema/">"27. + "<SOAP-ENV:Body>"28. + "<m:getItemDetailSingle xmlns:m=/"http://localhost//">"29. + "<itemMo>"30. + "<category>工厂类</category>"31. + "<city>北京</city>"32. + "<flag>1</flag>"33. + "<itemId>0</itemId>"34. + "<itemIndex>1</itemIndex>"35. + "<keyword>String</keyword>"36. + "<mobile>2147483647</mobile>"37. + "<password>123456</password>"38. + "<userName>sohu</userName>"39. + "</itemMo>"40. + "</m:getItemDetailSingle>"41. + "</SOAP-ENV:Body>"42. + "</SOAP-ENV:Envelope>";43. os.write(httpSend.getBytes());44. os.flush();45.46. InputStreamReader ireader = new InputStreamReader(is);47. java.io.BufferedReader breader = new java.io.BufferedReader(ireader);48.49. String responseLine = "";50.51.while((responseLine = breader.readLine()) != null)52. {53. System.out.println(new String(responseLine.getBytes(),"UTF-8"));54. }55.56. System.out.println("");57.58. }59.60.}。
java动态调用webservice方法
java动态调用webservice方法1. 引言1.1 背景介绍随着信息技术的快速发展,web服务已经成为了不可或缺的一部分。
企业级应用通常使用web服务来实现不同系统之间的数据交换和通信。
而在Java开发中,使用webservice调用远程方法是一种常见的方式。
传统的webservice调用通常需要通过生成客户端代码来调用远程方法,这种方式对开发者来说比较繁琐。
有时候,我们需要在运行时动态调用webservice方法,使得程序更加灵活和可扩展。
本文将介绍动态调用webservice方法的原理、Java中动态调用webservice方法的实现方式以及使用Apache CXF库和JAX-WS库调用webservice方法的步骤。
我们也会探讨一些常见问题及解决方法,帮助读者更好地理解和应用动态调用webservice方法的技术。
接下来,我们将详细讨论动态调用webservice方法的原理和Java 中的实现方式。
1.2 问题提出在项目开发中,我们经常会遇到需要调用外部的Web服务方法的情况。
而在Java开发中,如何动态调用Web服务方法是一个常见的问题。
在传统的开发模式中,我们通常会通过生成客户端代码来调用Web服务方法,但是这种方式存在一定的局限性,比如需要提前知道Web服务方法的信息,不能动态适应接口的变化等等。
我们需要寻找一种更加灵活和高效的方式来动态调用Web服务方法,以满足项目需求的变化和扩展。
在本文中,我们将深入探讨如何在Java中实现动态调用Web服务方法,探讨其中的原理和实现方式,以及结合Apache CXF和JAX-WS两种常见的Web服务框架,详细介绍如何使用这两种框架来实现动态调用Web服务方法的步骤。
通过对问题进行深入的探讨和研究,我们希望为Java开发者提供一种更加灵活和高效的解决方案,帮助他们更好地应对Web服务调用的需求,提升项目的开发效率和质量。
【问题提出】1.3 研究目的并不符合要求,或者内容不相关。
Java调用WebService接口
Java调⽤WebService接⼝在实际开发⼯作中,会遇到接⼝对接的场景,有直接HTTP调⽤⽅式,参数体为JSON串;还有⼀种是SOAP⽅式,即webService接⼝。
⾸先,可以在浏览器上安装⼀个插件(Wizdler),如下图。
通过这个插件,我们可以轻松的看到所有的⽅法点击⽅法,可以直接⽣成对应的请求参数,替换相关参数,可以直接调⽤⽅法;下⾯来讲⼀下如何使⽤Java代码实现接⼝的调⽤;@Testpublic void test(){try{String webServiceUrl = "http://238.62.169.140:8090/g6_venues/webservice/gtv-external-venues-service?wsdl";JaxWsDynamicClientFactory factory1 = JaxWsDynamicClientFactory.newInstance();Client client = factory1.createClient(webServiceUrl);HTTPConduit conduit = (HTTPConduit)client.getConduit();HTTPClientPolicy clientPolicy = new HTTPClientPolicy();//连接超时clientPolicy.setConnectionTimeout(2000);//取消块编码clientPolicy.setAllowChunking(false);//响应超时clientPolicy.setReceiveTimeout(12000);conduit.setClient(clientPolicy);String startDateTime = "20201018090000";String endDateTime = "20201228160000";Object[] result = client.invoke("queryFreeRoomInfo",startDateTime ,endDateTime ); //queryFreeRoomInfo为⽅法名;System.out.println("返回结果:" + result[0].toString());}catch (Exception e){e.printStackTrace();}}JaxWsDynamicClientFactory、HTTPConduit、Client、HTTPClientPolicy需要引⼊对应的依赖,。
webservice 接口写法 java
webservice 接口写法java全文共四篇示例,供读者参考第一篇示例:WebService是一种基于Web的服务架构,用于使不同的应用程序通过网络进行通信。
在Java中,编写WebService接口是一个很常见的需求,本文将介绍WebService接口的写法以及一些常见的技巧。
一、WebService接口的定义在Java中,可以使用JAX-WS(Java API for XML Web Services)来定义WebService接口。
通过JAX-WS,可以很方便地将Java类转换为Web服务,并使用SOAP(Simple Object Access Protocol)进行通信。
需要在Java类上添加@WebService注解,以标识这个类是一个WebService接口。
接着,需要在方法上添加@WebMethod注解,以标识这个方法是一个WebService操作。
```@WebServicepublic class HelloWorld {@WebMethodpublic String sayHello(String name) {return "Hello, " + name + "!";}}```上面的例子定义了一个简单的WebService接口,包含一个sayHello方法用于返回打招呼的字符串。
要发布一个WebService接口,需要使用Endpoint类来绑定WebService接口的实现类,并指定WebService的访问地址。
上面的例子使用Endpoint.publish方法发布了HelloWorld这个WebService接口,并指定了访问地址为http://localhost:8080/helloWorld。
要调用一个已发布的WebService接口,可以使用JAX-WS提供的工具来生成客户端代码。
生成客户端代码后,就可以像调用本地方法一样调用WebService方法。
javaWSDL接口webService实现方式
javaWSDL接⼝webService实现⽅式⼀、使⽤JDK⽣成WSDL的对象类1、cmd进⼊JDK的bin⽂件中 ⽐较常⽤的[options]有: 1). -d <directory> 在指定的⽬录⽣成class⽂件 2). -clientjar <jarfile> 在当前⽬录⽣成jar⽂件,结合-d <directory>可以在指定的⽬录⽣成jar⽂件 3). -s <directory> 在指定的⽬录⽣成java源⽂件 4). -p <pkg> 指定⽣成⽂件的包结构 5). -keep 在⽣成class⽂件,或者jar包时,同时保留java源⽂件2、eclipse⽣成WSDL⽂件在Eclipse中⽣成webservice客户端代码,New---->Other---->Webservice---->Webservice Client,选择之前拷贝到eclipse中的wsdl路径点击finish,这样eclipse就帮我们⾃动⽣成了webservice的客户端,接下来只需在程序中调⽤即可,在程序中调⽤ eclipse ⾃动⽣成的webservice客户端;3、MyEclipse ⽣成 WSDL ⽂件在项⽬上右键,选择New->Other->WebService->WebServiceClient->Next,会看到以下界⾯:4、WSDL Maven⽀持的jar包<dependencies><!-- ==================== WSDL 依赖⽂件 start=================== --><dependency><groupId>org.apache.axis</groupId><artifactId>axis</artifactId><version>1.4</version></dependency><dependency><groupId>commons-discovery</groupId><artifactId>commons-discovery</artifactId><version>0.5</version></dependency><dependency><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId><version>1.2</version></dependency><dependency><groupId>javax.xml</groupId><artifactId>jaxrpc</artifactId><version>1.1</version></dependency><dependency><groupId>javax.xml.soap</groupId><artifactId>saaj-api</artifactId><version>1.3.5</version></dependency><dependency><groupId>wsdl4j</groupId><artifactId>wsdl4j</artifactId><version>1.6.3</version></dependency><!-- ==================== WSDL 依赖⽂件 end====================== --></dependencies>以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
java的webservice用法
Java的WebService用法介绍W e bS er vi ce是一种基于We b标准的服务通信协议,可以在分布式系统中实现跨平台、跨语言的通信。
使用Ja v a语言开发W eb Ser v ic e具有简单易用、可靠性高的特点。
本文将介绍J av a的We bS er vi c e用法。
什么是WebS erviceW e bS er vi ce是一种基于XM L的协议,用于不同系统之间的通信。
它使用标准的H TT P协议传输X ML数据,可以在不同操作系统、编程语言、硬件设备之间互相通信。
Jav a的We bServic e实现方式在J av a中,有多种方式来实现W eb Se rv i ce,常用的有S OA P和R E ST fu l两种方式。
1.S O A PS O AP(S im pl eO bj ec t Ac ce ss Pr ot oc ol)是一种基于XM L的通信协议,它使用H TT P协议进行数据传输。
SO A P是一种严格的规范,定义了消息的格式以及如何发送和接收消息。
开发人员可以使用J ava的AP I来创建SO AP客户端和服务端。
使用Ja va实现SO AP的We bS er vi ce,需要以下步骤:1.定义服务接口:使用Ja va的接口定义需要提供的服务。
2.实现服务接口:编写J a va类来实现服务接口定义的方法。
3.发布We bS er vi ce:使用J av a提供的工具将服务发布到指定的UR L 上。
4.客户端调用:开发客户端代码来调用已发布的We bS er vic e。
2.R E S T f u lR E ST fu l(Re pr es en t at io na lS ta te Tra n sf er)是一种基于H TT P协议的架构风格,它提供了一组约束和原则来设计分布式系统。
R ES Tf ul的W eb Se rv ic e使用H TT P的GE T、POS T、P UT、D EL ET E等方法来进行资源的访问和操作。
java webservice 接口实现方式
java webservice 接口实现方式(实用版)目录一、Java WebService 简介二、Java WebService 接口实现方式1.使用 JAX-RPC2.使用 JAX-WS3.使用 Spring WebService三、实例:Java WebService 接口实现方式详解1.使用 JAX-RPC 示例2.使用 JAX-WS 示例3.使用 Spring WebService 示例四、总结正文一、Java WebService 简介Java WebService 是一种基于 Java 语言的 Web 服务技术,它可以使 Java 应用程序通过 Web 进行交互,实现跨平台、跨语言的数据交换和通信。
Java WebService 技术主要包括两个方面:Java WebService 客户端技术和 Java WebService 服务器端技术。
二、Java WebService 接口实现方式Java WebService 接口实现方式主要有以下三种:1.使用 JAX-RPCJAX-RPC(Java API for XML RPC)是 Java WebService 客户端技术的一种,它使用 Java 对象和 XML 数据结构进行通信。
JAX-RPC 可以将Java 对象转换为 XML 格式的数据,并通过 HTTP 协议传输到服务器端。
服务器端收到 XML 数据后,再将其转换为 Java 对象,完成数据交互。
2.使用 JAX-WSJAX-WS(Java API for XML Web Services)是 Java WebService 客户端和服务器端技术的统一标准,它不仅支持 RPC 风格,还支持文档风格。
JAX-WS 使用 WS-*规范来描述 Web 服务,并通过 XML 数据结构进行通信。
与 JAX-RPC 相比,JAX-WS 更加灵活,易于扩展。
3.使用 Spring WebServiceSpring WebService 是基于 Spring 框架的一种 Java WebService实现方式,它支持 JAX-RPC 和 JAX-WS。
java开发webservice的几种方式
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_WizardAxis2_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)发布webservice1)点击eclipse的File-New-other,打开Axis2 Wizards,选择Axis2 Service Archiver,然后Next;2)选择Class File Location,也就是类⽂件存放路径,注意:只选到classes⽬录,不要包括包⽂件夹,然后Next;3)选择Skip WSDL,然后Next4)⼀路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⽂件copy到你的实际应⽤中,同时,你也可以使⽤eclipse的create webservice 功能发布你的webservice,选择axis2⽣成你的webservice,这样webservice就会部署到你的应⽤中了。
webservice接口实现方式
webservice接口实现方式WebService是一种跨平台的通信技术,可以通过网络进行数据交互。
在软件开发中,WebService接口的实现方式有多种选择,本文将介绍几种常见的实现方式。
一、SOAP协议SOAP(Simple Object Access Protocol)是一种基于XML的通信协议,可以在不同的操作系统和编程语言之间进行通信。
在WebService中,SOAP协议通常用于实现接口。
通过SOAP协议,可以将数据封装成XML格式,然后在网络上进行传输。
接收方可以解析XML数据,获取其中的信息。
二、RESTful风格RESTful(Representational State Transfer)是一种基于HTTP协议的软件架构风格,常用于构建Web服务。
在RESTful风格中,每个资源都有唯一的URI(Uniform Resource Identifier),通过HTTP方法(GET、POST、PUT、DELETE)对资源进行操作。
通过RESTful风格,可以实现简洁、灵活的接口。
三、JSON-RPCJSON-RPC(JavaScript Object Notation Remote Procedure Call)是一种基于JSON格式的远程过程调用协议。
它通过HTTP 协议传输数据,并使用JSON格式进行序列化和反序列化。
JSON-RPC可以轻松实现跨平台的接口调用,支持多种编程语言。
四、XML-RPCXML-RPC是一种基于XML格式的远程过程调用协议。
它通过HTTP协议进行数据传输,使用XML格式进行数据编码和解码。
XML-RPC可以实现跨平台的接口调用,支持多种编程语言。
五、JAX-WSJAX-WS(Java API for XML Web Services)是Java EE平台中用于构建Web服务的标准API。
通过JAX-WS,可以使用Java语言轻松地创建和发布Web服务。
java写webservice接口
java写webservice接⼝有⼀个需求:要求根据设备mac和终端设备类型来查询设备库存状态。
接⼝协议是采⽤webservice协议,信息交互⽅式为xml格式信息输⼊参数存放到XML各个节点下,并转为⼀个String,作为接⼝的输⼊参数。
XML的封装格式如下所⽰:<?xml version="1.0" encoding="UTF-8"?><ROOT><MSG_CONTENT>< DEVICE_MAC></ DEVICE_MAC>< DEVICE_TYPE></ DEVICE_TYPE></MSG_CONTENT></ROOT>输出参数存放到XML各个节点下,并转为⼀个String,作为接⼝的输出参数。
XML的封装格式如下所⽰:<?xml version="1.0" encoding="UTF-8"?><ROOT>< RESULT_CODE >返回编码</ RESULT_CODE >< RESULT_MSG >失败描述</ RESULT_MSG ><STATE>终端状态</STATE><IS_EXIST>终端是否存在</IS_EXIST><OWNER_CITY>终端归属地市</OWNER_CITY></ROOT>webservice也就是web服务,是⼀种跨平台跨语⾔的服务,类似就是⼀个第三⽅的服务,你写好接⼝让别⼈来调⽤,你是提供服务的⼀⽅。
接⼝都是⽤来提供服务的,接⼝就是⼀组功能的集合。
在java中写webservice接⼝,需要在接⼝类上标注@WebService注解,表明这是⼀个webservice,@WebParam(name = "DEVICE_MAC")这个注解标注在⽅法参数上,表⽰获取的参数,注释⽤于定制从单个参数⾄ Web Service 消息部件和 XML 元素的映射。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Java WebService 接口实现方式
什么是 WebService
WebService 是一种基于 Web 的服务通信协议,通过使用标准的 HTTP 协议传输数据,使得不同平台、不同语言的应用程序能够进行互操作。
它使用 XML 格式来描
述请求和响应的数据,并使用 SOAP(简单对象访问协议)来封装和传输这些数据。
WebService 可以提供各种功能,例如数据查询、数据传输、远程过程调用等。
它
是一种跨平台、跨语言的解决方案,能够实现不同系统之间的集成和通信。
Java WebService 实现方式
Java 提供了多种方式来实现 WebService 接口,下面介绍两种常用的实现方式。
JAX-WS
JAX-WS(Java API for XML Web Services)是 Java EE 的一部分,用于开发和部署 WebService。
它提供了一种简单的方式来创建和发布 WebService 接口。
创建接口
首先,我们需要定义一个接口,用于描述我们要提供的服务。
接口中的每个方法都将成为可远程调用的操作。
import javax.jws.WebMethod;
import javax.jws.WebService;
@WebService
public interface MyWebService {
@WebMethod
String sayHello(String name);
}
在上面的例子中,我们定义了一个名为MyWebService的接口,其中有一个名为sayHello的方法,该方法接受一个字符串参数并返回一个字符串结果。
实现接口
接下来,我们需要实现上述接口。
这里我们可以使用一个普通的 Java 类来实现接口中的方法。
@WebService(endpointInterface = "com.example.MyWebService")
public class MyWebServiceImpl implements MyWebService {
@Override
public String sayHello(String name) {
return "Hello, " + name + "!";
}
}
在上面的例子中,我们创建了一个名为MyWebServiceImpl的类,并实现了MyWebService接口中的sayHello方法。
发布服务
最后,我们需要将实现的服务发布到 Web 服务器上,以便客户端可以访问和调用。
import javax.xml.ws.Endpoint;
public class WebServicePublisher {
public static void main(String[] args) {
String url = "";
Endpoint.publish(url, new MyWebServiceImpl());
System.out.println("WebService is published at: " + url);
}
}
在上面的例子中,我们使用Endpoint.publish()方法将服务发布到指定的 URL 上,并输出发布的地址。
客户端调用
使用 JAX-WS 创建的 WebService 可以通过生成客户端代码来调用。
客户端代码可以使用wsimport工具从服务的 WSDL(Web Services Description Language)文
件中生成。
wsimport -s src
在上面的例子中,我们使用wsimport命令生成客户端代码,并将生成的代码保存
到src目录中。
然后,我们可以在客户端代码中调用服务的方法。
import com.example.MyWebService;
import com.example.MyWebServiceService;
public class WebServiceClient {
public static void main(String[] args) {
MyWebServiceService service = new MyWebServiceService();
MyWebService port = service.getMyWebServicePort();
String result = port.sayHello("John");
System.out.println(result);
}
}
在上面的例子中,我们创建了一个名为WebServiceClient的类,并调用了服务的sayHello方法。
Apache CXF
Apache CXF 是一个开源的 WebService 框架,它提供了丰富的功能和灵活的配置选项。
创建接口
首先,我们需要创建一个接口来描述要提供的服务。
public interface MyWebService {
String sayHello(String name);
}
实现接口
接下来,我们需要实现上述接口。
public class MyWebServiceImpl implements MyWebService {
@Override
public String sayHello(String name) {
return "Hello, " + name + "!";
}
}
发布服务
然后,我们需要将实现的服务发布到 Web 服务器上。
import org.apache.cxf.jaxws.JaxWsServerFactoryBean;
public class WebServicePublisher {
public static void main(String[] args) {
String address = "";
JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();
factory.setAddress(address);
factory.setServiceClass(MyWebService.class);
factory.setServiceBean(new MyWebServiceImpl());
factory.create();
System.out.println("WebService is published at: " + address);
}
}
在上面的例子中,我们使用JaxWsServerFactoryBean类来创建并发布服务,并输出发布的地址。
客户端调用
使用 Apache CXF 创建的 WebService 可以通过生成客户端代码来调用。
客户端代码可以使用wsdl2java工具从服务的 WSDL 文件中生成。
wsdl2java -d src -p com.example
在上面的例子中,我们使用wsdl2java命令生成客户端代码,并将生成的代码保存到src目录中。
然后,我们可以在客户端代码中调用服务的方法。
import com.example.MyWebService;
import com.example.MyWebServiceService;
public class WebServiceClient {
public static void main(String[] args) {
MyWebServiceService service = new MyWebServiceService();
MyWebService port = service.getMyWebServicePort();
String result = port.sayHello("John");
System.out.println(result);
}
}
在上面的例子中,我们创建了一个名为WebServiceClient的类,并调用了服务的sayHello方法。
总结
本文介绍了 Java WebService 的两种常用实现方式:JAX-WS 和 Apache CXF。
通过 JAX-WS,我们可以使用注解和简单的配置来创建和发布服务;而使用 Apache CXF,我们可以使用更灵活的配置选项来创建和发布服务。
无论选择哪种方式,Java WebService 都是一种强大的跨平台、跨语言的解决方案,能够实现不同系统之间的集成和通信。