JAX-WS创建和处理SOAP消息



JAX-WS创建和处理SOAP消息。

JAX-WS规范是一组XML web services的JAVA API，在 JAX-WS中，一个远程调用可以转换为一个基于XML的协议例如SOAP，在使用JAX-WS过程中，开发者不需要编写任何生成和处理SOAP消息的代码。JAX-WS的运行时实现会将这些API的调用转换成为对应的SOAP消息。

 

 JAX-WS 也提供了一组针对底层消息进行操作的API调用，你可以通过Dispatch 直接使用SOAP消息或XML消息发送请求或者使用Provider处理SOAP或XML消息。通过web service所提供的互操作环境，我们可以用JAX-WS轻松实现JAVA平台与其他编程环境（.net等）的互操作。

现在WebService的主要成熟的框架有axis、cxf等，都很好的支持了SOAP协议，而且CXF也提供了对 JAX-WS 全面的支持。可以算是JAX-WS进行封装的框架。

 

这篇文章就对处理web services的JAVA基础API JAX-WS进行介绍。

首先看如何发布web services服务。

1、编写接口，使用@WebService注解

 

  1. <span style=”font-family:SimSun;font-size:14px;”>package webservice.wh;
  3. import javax.jws.WebParam;
  4. import javax.jws.WebResult;
  5. import javax.jws.WebService;
  7. @WebService
  8. public interface IMyService {
  9.     @WebResult(name=”addResult”)
  10.         //对返回值和参数进行名字定义，否则默认为arg0，arg1…
  11.     public int add(@WebParam(name=”firstA”)int a ,@WebParam(name=”SecondB”)int b);
  12.     //与上面方法进行对比
  13.     public int minus(int a,int b);
  14. }
  15. </span>

2、编写编写实现类，标明@WebService注解

 

 

  1. <span style=”font-family:SimSun;font-size:14px;”>package webservice.wh;
  3. import javax.jws.WebResult;
  4. import javax.jws.WebService;
  6. @WebService(endpointInterface=”webservice.wh.IMyService”)
  7. public class MyServiceImpl implements IMyService {
  9.     @Override
  10.     @WebResult(name=”addResult”)
  11.     public int add(int a, int b) {
  12.         System.out.print(a+”+”+b+”=”+(a+b));
  13.         return a+b;
  14.     }
  16.     @Override
  17.     public int minus(int a, int b) {
  18.         System.out.print(a+”-”+b+”=”+(a-b));
  19.         return a-b;
  20.     }
  22. }
  23. </span>

3、编写服务类，根据url和是实现类启动服务

 

 

  1. <span style=”font-family:SimSun;font-size:14px;”>package webservice.wh;
  2. import javax.xml.ws.Endpoint;
  3. public class MyService {
  4.     public static  void main(String[] args){
  5.         String address=”http://localhost:6666/ns”;
  6.         Endpoint.publish(address, new MyServiceImpl());
  7.     }
  8. }</span>

4、运行3中代码，发布服务，在浏览器可查看

 


5、使用jax-ws封装好的服务进行客户端调用

 

  1. <span style=”font-family:SimSun;font-size:14px;”>package webservice.wh;
  3. import java.net.MalformedURLException;
  4. import java.net.URL;
  6. import javax.xml.namespace.QName;
  7. import javax.xml.ws.Service;
  9. public class TestClient {
  10.     public static void main(String[] args) {
  11.         try {
  12.             URL url = new URL(“http://localhost:7777/ns?wsdl”);
  13.             QName sname = new QName(“http://wh.webservice/”, ”MyServiceImplService”);
  14.             Service service = Service.create(url,sname);
  15.             IMyService ms = service.getPort(IMyService.class);
  16.             System.out.println(ms.add(12,33));
  17.         } catch (MalformedURLException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }
  22. </span>

这样的客户端调用直接使用封装好的service进行操作，在调用过程中将我们的代码转换为SOAP“信件”与服务进行交互，我们不需要编写任何生成和处理SOAP消息的代码。很是方便。不过既然是JAVA 底层API，它也提供了底层的SOAP操作API，我们来用易用，了解一下SOAP是怎样生成的。

 

6、创建SOAP消息

 

  1. <span style=”font-family:SimSun;font-size:14px;”>public class TestSoap {
  3.     private String ns = ”http://service.soap.org/”;
  4.     private String wsdlUrl = ”http://localhost:6666/ms?wsdl”;
  6.     /**
  7.      * 创建SOAP消息
  8.      * @author WHuan
  9.      */
  10.     @Test
  12.     public void createSoap() {
  13.         try {
  14.             // 创建消息工厂
  15.             MessageFactory factory = MessageFactory.newInstance();
  16.             // 根据消息工厂创建SoapMessage
  17.             SOAPMessage message = factory.createMessage();
  18.             // 创建SOAPPart
  19.             SOAPPart part = message.getSOAPPart();
  20.             // 获取SOAPEnvelope
  21.             SOAPEnvelope envelope = part.getEnvelope();
  22.             // 通过SoapEnvelope可以获取到相应的Body和Header等信息
  23.             SOAPBody body = envelope.getBody();
  24.             // 根据Qname创建相应的节点,Qname是一个带有命名空间的节点
  25.             QName qname = new QName(“http://java.wh/webservice/”, ”add”, ”ns”);
  26.             // <ns:add xmlns=”http://java.wh/webservice/”
  27.             SOAPBodyElement ele = body.addBodyElement(qname);
  28.             ele.addChildElement(“a”).setValue(“11″);
  29.             ele.addChildElement(“b”).setValue(“22″);
  30.             // 打印消息信息
  31.             message.writeTo(System.out);
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  36. }</span>

代码比较容易理解，首先通过消息工厂MessageFactory创建SOAPMessage，然后创建SOAPPart，我的理解相当于创建了一个邮箱，然后创建信件SOAPEnvelope，之后是SOAP的BODY和Header部分，其中Header部分可以省略。不过现在的API可以省略SOAPPart，直接创建BODY和Header，鉴于Part是经典方式，所以还是按照传统来了。

 

这里涉及到SOAP消息的格式，很形象的可以理解为一封信件，鉴于是基础知识，这里便不再赘述，不清楚的可以先补充一下SOAP格式，理解了SOAP的格式之后，上面那段代码是很容易理解的。

这样进行运行后，我们便可以得到一个完整的SOAP消息：

得到这样的SOAP消息后，怎么与我们发布的WSDL进行交互呢？

7、SOAP消息传递和处理，使用Dispatch

  1. <span style=”font-family:SimSun;font-size:14px;”>   /**
  2.      * 创建SOAP消息,并提交得到返回值
  3.      * @author WHuan
  4.      */
  5.     @Test
  6.     public void soapDispatch() {
  7.         try {
  8.             // 创建服务service
  9.             URL url = new URL(wsdlUrl);
  10.             QName sname= new QName(ns,”MyServiceImplService”);
  11.             Service service =Service.create(url,sname);
  13.             //创建DIspatch
  14.             Dispatch<SOAPMessage> dispatch=service.createDispatch(new QName(ns,”MyServiceImplPort”),
  15. SOAPMessage.class, Service.Mode.MESSAGE);
  17.             //创建SOAPMessage
  18.             SOAPMessage msg=MessageFactory.newInstance().createMessage();
  19.             SOAPEnvelope envelope =msg.getSOAPPart().getEnvelope();
  20.             SOAPBody body=envelope.getBody();
  22.             //创建QName来指定消息中传递数据
  23.             QName ename=new QName(ns,”add”,”nn”);
  24.             //<nn:add xmlns=”xx”/>
  25.             SOAPBodyElement ele=body.addBodyElement(ename);
  26.             ele.addChildElement(“firstA”).setValue(“22″);
  27.             ele.addChildElement(“SecondB”).setValue(“33″);
  28.             msg.writeTo(System.out);
  29.             System.out.println(“\n invoking….”);
  31.             //通过Dispatch传递消息,会返回相应消息
  32.             SOAPMessage response = dispatch.invoke(msg);
  33.             response.writeTo(System.out);
  34.             System.out.println();
  36.             //将相应的消息转换为doc对象
  37.             Document doc= response.getSOAPPart().getEnvelope().getBody().extractContentAsDocument();
  38.             String str=doc.getElementsByTagName(“addResult”).item(0).getTextContent();
  39.             System.out.println(str);
  41.         } catch (Exception e) {
  42.             e.printStackTrace();
  43.         }</span>

这样直接创建了SOAP消息后使用dispatch便可以进行传递，通过extractConentAsDocument方法得到Document类型的返回值，从返回值的SOAP消息中取得我们想要的标签信息。输出结果如下：

 

本文主要从使用JAVA自带API出发，介绍一些稍微底层些的SOAP消息的创建和传递处理。理解了底层，也对web Service的框架使用多一份熟悉，也当给大家复习下SOAP消息吧。