Spring Jax-Ws. Build and consume Web Services – part 1

最新推荐文章于 2024-07-15 22:27:18 发布
最新推荐文章于 2024-07-15 22:27:18 发布
阅读量105 收藏
点赞数
分类专栏： spring webservice 文章标签： java web.xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_8208/article/details/82677414
版权

Spring Jax-Ws. Build and consume Web Services – part 1

Posted on  July 12, 2012  by Marco

Following the official guide, at the chapter 19 we’ll find the Spring support about web service (honestly, could it miss?).

In this article I’ll describe the use of it with Jax-WS standard (introduced in Java EE 5 and Java 6) and we’ll see how build and consume the web service.

 

First of all, you have to notice that there are a huge variety of methods about build and consume web service. I think I’ve never used two times the same method for building web services. I don’t know why, probably that is the evidence about the large number of technologies for building web services.

My personal opinion is to use technologies which implements java standard, like Jax-WS.

In this first part we’ll take a look about build web service. I’m an old style developer and I’m not able to start from the WSDL definition. So, my approach is to define the interface with methods exposed rather than define the WSDL definition.

1
2
3
4
5
6
7
8
9
10
package it.springjaxws;
public interface OrderService {
  
  public void Check(Order order) throws Exception;
 
  public Order Process(Order order);
 
  public Order Shipping(Order order);
 
}

And its implementation:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package it.springjaxws;
import java.util.Date;
 
public class OrderServiceImpl implements OrderService{
 
  @Override
  public void Check(Order order) throws Exception{
   if (order.getItemNumber()== 0 )
   {
    throw new Exception( "Quantity cannot be 0!!" );
   }  
  }
 
  @Override
  public Order Process(Order order) {
   order.setInvoice(order.getItemNumber() * 1.3 );
   return order;
  }
 
  @Override
  public Order Shipping(Order order) {
   order.setShippingDate( new Date());
   return order;
  }
 
}

The Order bean:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package it.springjaxws;
import java.io.Serializable;
import java.util.Date;
 
import javax.xml.bind.annotation.XmlRootElement;
 
@XmlRootElement (name= "Order" )
public class Order implements Serializable {
 
  /**
   *
   */
  private static final long serialVersionUID = 1L;
  
  
  private String orderId;
  
  private double invoice;
  
  private int itemNumber;
 
  private Date shippingDate;
  
  public Order()
  {}
  
  public Order(String orderId, double invoice, int itemNumber)
  {
   this .orderId = orderId;
   this .invoice = invoice;
   this .itemNumber = itemNumber;    
  }
  
  public String getOrderId() {
   return orderId;
  }
  public void setOrderId(String orderId) {
   this .orderId = orderId;
  }
  public double getInvoice() {
   return invoice;
  }
  public void setInvoice( double invoice) {
   this .invoice = invoice;
  }
  
  public int getItemNumber() {
   return itemNumber;
  }
  public void setItemNumber( int itemNumber) {
   this .itemNumber = itemNumber;
  }
 
  public Date getShippingDate() {
   return shippingDate;
  }
 
  public void setShippingDate(Date shippingDate) {
   this .shippingDate = shippingDate;
  }
  
  @Override
  public String toString()
  {
   return " orderId:" + orderId +
     " itemNumber:" + itemNumber +
     " invoice:" + invoice +
     " shippingDate:" + shippingDate;
  }
  
}

Now we have to expose the class “OrderService” by an endpoint. For this achieve we need to use a class which extends SpringBeanAutowiringSupport spring’s class. Take a look at the code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package it.springjaxws;
 
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.support.SpringBeanAutowiringSupport;
 
@WebService (serviceName= "OrderService" )
public class OrderServiceEndpoint extends SpringBeanAutowiringSupport{
 
  @Autowired
  private OrderService orderService;
  
  @WebMethod
  public void Check( @WebParam (name = "order" ) Order order) throws Exception
  {
   orderService.Check(order);
  }
  
  @WebMethod
  public Order Process( @WebParam (name = "order" ) Order order)
  {
   return orderService.Process(order);
  }
 
  @WebMethod
  public Order Shipping( @WebParam (name = "order" ) Order order)
  {
   return orderService.Shipping(order);
  }
}

Briefly, we’ve mapped the orderService methods with the WebMethod.

The spring configuration file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<? xml version = "1.0" encoding = "UTF-8" ?>
< beans xmlns = "http://www.springframework.org/schema/beans"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns:context = "http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
     <!-- Use @Component annotations for bean definitions -->
     < context:component-scan base-package = "it.springjaxws" />
 
     < bean id = "orderService" class = "it.springjaxws.OrderServiceImpl" />
 
     < bean class = "org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter" >
         < property name = "baseAddress" value = "http://localhost:8081/" />
     </ bean >
 
     < bean id = "orderServiceEndpoint" class = "it.springjaxws.OrderServiceEndpoint" />
 
</ beans >

We expose the web service at port 8081 of localhost.

Deploy it to your tomcat and run. You’ll see something like above code when you’ll browse /OrderServiceEndpoint?WSDL

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
<? xml version = "1.0" encoding = "UTF-8" ?> <!-- Published by JAX-WS RI at http://jax-ws.dev.java.net.
     RI's version is JAX-WS RI 2.1.6 in JDK 6. --> <!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net.
     RI's version is JAX-WS RI 2.1.6 in JDK 6. -->
< definitions xmlns:soap = "http://schemas.xmlsoap.org/wsdl/soap/"
     xmlns:tns = "http://springjaxws.it/" xmlns:xsd = "http://www.w3.org/2001/XMLSchema"
     xmlns = "http://schemas.xmlsoap.org/wsdl/" targetNamespace = "http://springjaxws.it/"
     name = "OrderService" >
     < types >
         < xsd:schema >
             < xsd:import namespace = "http://springjaxws.it/"
                 schemaLocation = "http://localhost:8081/OrderServiceEndpoint?xsd=1" ></ xsd:import >
         </ xsd:schema >
     </ types >
     < message name = "Check" >
         < part name = "parameters" element = "tns:Check" ></ part >
     </ message >
     < message name = "CheckResponse" >
         < part name = "parameters" element = "tns:CheckResponse" ></ part >
     </ message >
     < message name = "Exception" >
         < part name = "fault" element = "tns:Exception" ></ part >
     </ message >
     < message name = "Process" >
         < part name = "parameters" element = "tns:Process" ></ part >
     </ message >
     < message name = "ProcessResponse" >
         < part name = "parameters" element = "tns:ProcessResponse" ></ part >
     </ message >
     < message name = "Shipping" >
         < part name = "parameters" element = "tns:Shipping" ></ part >
     </ message >
     < message name = "ShippingResponse" >
         < part name = "parameters" element = "tns:ShippingResponse" ></ part >
     </ message >
     < portType name = "OrderServiceEndpoint" >
         < operation name = "Check" >
             < input message = "tns:Check" ></ input >
             < output message = "tns:CheckResponse" ></ output >
             < fault message = "tns:Exception" name = "Exception" ></ fault >
         </ operation >
         < operation name = "Process" >
             < input message = "tns:Process" ></ input >
             < output message = "tns:ProcessResponse" ></ output >
         </ operation >
         < operation name = "Shipping" >
             < input message = "tns:Shipping" ></ input >
             < output message = "tns:ShippingResponse" ></ output >
         </ operation >
     </ portType >
     < binding name = "OrderServiceEndpointPortBinding" type = "tns:OrderServiceEndpoint" >
         < soap:binding transport = "http://schemas.xmlsoap.org/soap/http"
             style = "document" ></ soap:binding >
         < operation name = "Check" >
             < soap:operation soapAction = "" ></ soap:operation >
             < input >
                 < soap:body use = "literal" ></ soap:body >
             </ input >
             < output >
                 < soap:body use = "literal" ></ soap:body >
             </ output >
             < fault name = "Exception" >
                 < soap:fault name = "Exception" use = "literal" ></ soap:fault >
             </ fault >
         </ operation >
         < operation name = "Process" >
             < soap:operation soapAction = "" ></ soap:operation >
             < input >
                 < soap:body use = "literal" ></ soap:body >
             </ input >
             < output >
                 < soap:body use = "literal" ></ soap:body >
             </ output >
         </ operation >
         < operation name = "Shipping" >
             < soap:operation soapAction = "" ></ soap:operation >
             < input >
                 < soap:body use = "literal" ></ soap:body >
             </ input >
             < output >
                 < soap:body use = "literal" ></ soap:body >
             </ output >
         </ operation >
     </ binding >
     < service name = "OrderService" >
         < port name = "OrderServiceEndpointPort" binding = "tns:OrderServiceEndpointPortBinding" >
             < soap:address location = "http://localhost:8081/OrderServiceEndpoint" ></ soap:address >
         </ port >
     </ service >
</ definitions >

In the next part I describe how consume it.

UPDATE

You can find very useful to host the web services in the same web server port (the 8080 for tomcat). For this purpose you have to use JAX-WS commons from Metro project of glassfish. More info are available at this url http://jax-ws-commons.java.net/spring/

To apply this technology at the previous example, we need to change and update some files.

First, in web.xml, we put the servlet definition

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
< web-app id = "WebApp_ID" version = "2.4"
     xmlns = "http://java.sun.com/xml/ns/j2ee"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
     http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
     < display-name >SpringJaxWsEmbedded</ display-name >
 
     < servlet >
         < servlet-name >jaxwsembedded</ servlet-name >
         < servlet-class >
             com.sun.xml.ws.transport.http.servlet.WSSpringServlet
         </ servlet-class >
     </ servlet >
 
     < servlet-mapping >
         < servlet-name >jaxwsembedded</ servlet-name >
         < url-pattern >/order</ url-pattern >
     </ servlet-mapping >
 
     <!-- Register Spring Listener -->
     < listener >
         < listener-class >
             org.springframework.web.context.ContextLoaderListener
         </ listener-class >
     </ listener >
 
</ web-app >

After this, we edit the applicationContext.xml file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<? xml version = "1.0" encoding = "UTF-8" ?>
< beans xmlns = "http://www.springframework.org/schema/beans"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns:ws = "http://jax-ws.dev.java.net/spring/core"
     xmlns:wss = "http://jax-ws.dev.java.net/spring/servlet"
     xmlns:context = "http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://jax-ws.dev.java.net/spring/core http://jax-ws.java.net/spring/core.xsd
         http://jax-ws.dev.java.net/spring/servlet http://jax-ws.java.net/spring/servlet.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
<!-- Use @Component annotations for bean definitions -->
     < context:component-scan base-package = "it.springjaxwsembedded" />
 
     < bean id = "orderService" class = "it.springjaxws.OrderServiceImpl" />
 
     < wss:binding url = "/order" >
         < wss:service >
             < ws:service bean = "#orderWs" />
         </ wss:service >
     </ wss:binding >
 
     <!-- Web service methods -->
     < bean id = "orderWs" class = "it.springjaxws.OrderServiceEndpoint" />
 
</ beans >

Last point is OrderServiceEndpoint definition

1
2
3
public class OrderServiceEndpoint {
...
}

We’ve removed the SpringBeanAutowiringSupport extension.

iteye_8208
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAX-WS.zip
06-04
Java Architecture for XML Binding (JAX-WS) 是Java平台上的一个标准组件，用于处理Web服务。它提供了在Java应用程序和Web服务之间交换XML数据的能力。JAX-WS允许开发者创建符合WS-I Basic Profile的Web服务，确保...
JAX-WS 2.2 完整jar包
06-23
FastInoset.jar gmbal-api-only.jar ha-api.jar javax.annotation.jar javax.mail_1.4.jar jaxb-api.jar jaxb-impl.jar jaxb-xjc.jar jaxws-api.jar jaxws-rt.jar jaxws-rt-javadoc.jar ...
Spring Jax-Ws. Build and consume Web Services – part 2
jaesonchen
12-20 106
Spring Jax-Ws. Build and consume Web Services – part 2 Posted on July 12, 2012 by Marco In the previous article we’ve seen how build a Jax Web Services with spring. Now it’s time to see how cons...
apache cxf在线阅读（http://cxf.apache.org/docs/jax-rs.html）
fcxx182的博客
04-11 354
Apache CXF Apache CXF Documentation > Index > RESTful Services > JAX-RS Download | Documentation Overview How-Tos Frontends DataBindings Transports Configura...
Spring in action--Part4-Integrating Spring
10-28 2391
Chapter15.Working with remote servicesSeveral remoting technologies are available to you as a Java developer, including these:1.Remote Method Invocation (RMI) 2.Caucho’s Hessian and Burlap 3.Spring’s
maven创建项目的模版类型（基于3.3.9版本）
爱的叹息的专栏
05-21 5024
1: remote -&gt; am.ik.archetype:maven-reactjs-blank-archetype (Blank Project for React.js) 2: remote -&gt; am.ik.archetype:msgpack-rpc-jersey-blank-archetype (Blank Project for Spring Boot + Jersey) 3...
jaxb-api.jar.jaxws-api.zip_ jaxb-api.jar_cxf_jax-ws.jar_jaxb-api
09-22
它支持基于标准的服务实现，如JAX-WS（Java API for XML Web Services）和JAX-RS（Java API for RESTful Web Services）。CXF不仅提供了服务端的实现，还支持客户端调用，使得开发者可以方便地创建、发布和管理Web...
jax-0.4.13.tar.gz
09-15
`jax-0.4.13.tar.gz` 是一个开源库 JAX 的特定版本，即版本 0.4.13 的压缩包文件。JAX 是一个由 Google Brain 团队开发的高性能计算库，专为科学计算和深度学习任务设计，尤其在机器学习研究领域广泛应用。JAX 提供...
jax-ws2.1.zip
04-26
1. **webservices-api.jar** - 这个JAR文件包含了JAX-WS的API接口定义，它定义了开发者用来创建和消费Web服务的类和接口。这些接口包括`javax.jws.WebService`注解，用于标记服务端点，以及`javax.xml.ws.Service`，...
配置Java开发环境
Broken_x的博客
07-10 1614
Java开发环境配置
java集合工具类
药的博客
07-12 464
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 573
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 310
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 552
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 312
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 401
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 345
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 622
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
jax-ws web services是什么
03-16
JAX-WS Web Services是一种基于Java语言的Web服务技术，它提供了一种简单的方式来创建和部署Web服务。JAX-WS是Java API for XML Web Services的缩写，它允许开发人员使用Java编程语言来创建和访问Web服务。JAX-WS ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值