spring和maven_具有Spring和Maven教程的JAX–WS

最新推荐文章于 2024-03-15 11:01:05 发布

dnc8371

最新推荐文章于 2024-03-15 11:01:05 发布

阅读量170

点赞数

文章标签： java spring web vue maven ViewUI

原文链接：https://www.javacodegeeks.com/2010/11/jaxws-with-spring-and-maven-tutorial.html

版权

spring和maven

Spring框架通过JAX-WS提供对Web服务的远程支持，实际上，如Spring 参考文档中所述，有三种将Spring POJO服务公开为JAX-WS Web服务的方式：

公开基于Servlet的Web服务（适用于Java EE 5环境）
导出独立的Web服务（适用于使用Sun的JDK 1.6内置JAX–WS提供程序的情况）
使用JAX-WS RI的Spring支持导出Web服务（类似于独立方法，但是这次是在Servlet环境中。适用于非Java EE环境，例如Tomcat ，将JAX-WS RI嵌入为Web应用程序的一部分）

选择上述三种方法之一主要取决于您的执行环境。话虽如此，我们将向您展示如何使用上述所有方法来设置和公开一个简单的Spring服务。

我们首选的开发环境是Eclipse ，因此，必须先安装具有Maven支持的Eclipse 。用于Eclipse的Maven插件的安装不在本教程的讨论范围之内，因此不再讨论。但是，您将需要以下组件：

从这里蚀
从这里开始， Eclipse的 Maven插件

在本教程中，我们将使用Eclipse Galileo，“ m2eclipse” Maven Integration for Eclipse插件版本0.10.0和Spring版本3.0.1。

让我们开始，

创建一个新的Maven项目，转到File？项目？ Maven？ Maven项目
在向导的“选择项目名称和位置”页面中，确保未选中 “创建简单项目（跳过原型选择）”选项，单击“下一步”以继续使用默认值
在向导的“选择原型”页面中，在“目录”下拉列表中选择“ Nexus Indexer”，并在刷新原型选择区域后，从“ org.codehaus.mojo”中选择“ webapp-javaee6”原型。原型”。您可以使用“过滤器”文本框来缩小搜索结果范围。点击“下一步”继续
在向导的“输入工件ID”页面中，您可以定义项目的名称和主程序包。我们将“ Group Id”变量设置为“ com.javacodegeeks”，将“ Artifact Id”变量设置为“ jaxwsspring”。前面提到的选择组成了主项目包“ com.javacodegeeks.jaxwsspring”和项目名“ jaxwsspring”。点击“完成”退出向导并创建您的项目

让我们回顾一下有关Maven Web项目结构的一些事情

/ src / main / java文件夹包含应用程序动态内容的源文件
/ src / test / java文件夹包含用于单元测试的所有源文件
/ src / main / webapp文件夹包含用于创建有效的Web应用程序的基本文件，例如“ web.xml”
/ target文件夹包含已编译和打包的可交付成果
“ pom.xml”是项目对象模型（POM）文件。包含所有项目相关配置的单个文件。

这里要注意的一件事是，我们选择使用与Java EE6兼容的Maven项目原型。我们的选择是有目的的，以便易于演示上述所有可用方法。尽管如此，即使您使用不同的环境（例如独立的Servlet环境（例如Apache Tomcat）或Java EE 5兼容的应用程序服务器（例如JBoss Application Server）），也可以按照本教程将Spring服务作为JAX-WS服务公开。

为了在运行时正确使用Spring ，我们必须向Web应用程序提供所有必需的库。打开“ pom.xml”的图形编辑器并执行以下更改：

在POM编辑器的“概述”页面上的“属性”部分中找到并执行以下更改：

创建一个名为org.springframework.version且值为3.0.1.RELEASE的新属性。

导航到POM编辑器的“ Dependencies”页面，并创建以下依赖关系（您应在该页面的“ Dependency Details”部分的“ GroupId”，“ Artifact Id”和“ Version”字段中进行填充）：
- 组ID： org.springframework工件ID： spring-web版本： $ {org.springframework.version}
如您所见， Maven以声明方式管理库依赖关系。创建本地存储库（默认情况下，位于{user_home} /。m2文件夹下），所有必需的库都从公共存储库下载并放置在该库中。此外，库内的依赖关系会自动解决和处理。

下一步是为Web应用程序提供挂钩，以便在启动时加载Spring上下文。

在/ src / main / webapp文件夹下创建一个“ WEB-INF /web.xml”文件，并添加以下内容：
```
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
 <display-name>jaxwsspring</display-name>
 <session-config>
  <session-timeout>30</session-timeout>
 </session-config>
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 <welcome-file-list>
  <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>
</web-app>
```
现在让我们创建将驱动Spring容器的applicationContext.xml文件。在/ src / main / webapp / WEB-INF目录下创建文件。下面是一个示例“ applicationContext.xml”：
```
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:task="http://www.springframework.org/schema/task"
 xsi:schemaLocation="
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   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
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

 <context:component-scan base-package="com.javacodegeeks.jaxwsspring" />

</beans>
```
这里要注意的事情：
1. 将context：component-scan元素的base-package属性更改为项目的基本包，以扫描Spring组件
现在让我们创建一个“问候” Spring服务。在主程序包下创建一个名为“服务”的子程序包，并将“ GreetingService”类放在此处。下面是一个示例“问候”服务：
```
package com.javacodegeeks.jaxwsspring.services;

import org.springframework.stereotype.Service;

@Service("greetingService")
public class GreetingService {

 public String sayHello() {
  return "Hello from Greeting Service";
 }
 
}
```
JAX–WS需要使用专用的端点类。如果需要导出现有服务，则包装器类是最简单的JAX–WS兼容方式。现在创建一个“问候”端点类。在主程序包下创建一个名为“ endpoints”的子程序包，并将“ GreetingServiceEndpoint”类放在此处。下面是一个示例“问候”端点类：
```
package com.javacodegeeks.jaxwsspring.endpoints;

import javax.jws.WebMethod;
import javax.jws.WebService;

import org.springframework.beans.factory.annotation.Autowired;

import com.javacodegeeks.jaxwsspring.services.GreetingService;

@WebService(serviceName="GreetingService")
public class GreetingServiceEndpoint {

 @Autowired
 private GreetingService greetingService;
 
 @WebMethod
 public String sayHello() {
  return greetingService.sayHello();
 }
 
}
```
如您所见，这是一个与JAX–WS兼容的“ greeting”服务实现，仅委托给“ GreetingService”实现。这是将在JAX-WS引擎中注册的类。对于Java EE 5服务器（基于Servlet的Web服务方法），Web服务引擎管理端点类实例的生命周期。在其他两种情况下，端点实例是作为Spring Bean本身定义和管理的，因此它们的生命周期将取决于Spring应用程序上下文。

Spring为JAX-WS Servlet端点实现提供了一个方便的基类-“ SpringBeanAutowiringSupport”。要将我们的“ GreetingService”公开为基于Servlet的Web服务，我们必须执行以下操作：
1. 修改我们的“ GreetingServiceEndpoint”类以扩展Spring的“ SpringBeanAutowiringSupport”类。这样，将使用@Autowired批注，Spring的IoC容器将能够将实际的“ greeting”服务实例注入到我们的终结点类中，以正确地委派调用。
2. 我们的“ GreetingServiceEndpoint”需要在与Spring上下文相同的Web应用程序中运行，以允许访问Spring的设施。在Java EE 5环境中，默认情况下就是这种情况，它使用JAX-WS Servlet端点部署的标准协定。
3. 端点是在服务器端JAX-WS实现中注册的类。对于Java EE 5服务器，可以简单地将其定义为“ web.xml”中的Servlet ，并且服务器会检测到这是一个JAX–WS端点并做出相应的React。 Servlet名称通常需要与指定的Web服务服务名称匹配。
请牢记以上几点，如下所示更改端点类：
```
package com.javacodegeeks.jaxwsspring.endpoints;

import javax.jws.WebMethod;
import javax.jws.WebService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.support.SpringBeanAutowiringSupport;

import com.javacodegeeks.jaxwsspring.services.GreetingService;

@WebService(serviceName="GreetingService")
public class GreetingServiceEndpoint extends SpringBeanAutowiringSupport {

 @Autowired
 private GreetingService greetingService;
 
 @WebMethod
 public String sayHello() {
  return greetingService.sayHello();
 }
 
}
```
最后，将以下Servlet声明添加到“ web.xml”中：
```
<servlet>  
   <servlet-name>GreetingService</servlet-name>  
   <servlet-class>  
      com.javacodegeeks.jaxwsspring.endpoints.GreetingServiceEndpoint
   </servlet-class>  
</servlet>  
  
<servlet-mapping>  
   <servlet-name>GreetingService</servlet-name>  
   <url-pattern>/GreetingService</url-pattern>  
</servlet-mapping>
```
要构建应用程序，请右键单击您的项目？运行为？ Maven包

要部署Web应用程序，只需将“ .war”文件从“ target”目录复制到Java EE 5服务器Web应用程序部署文件夹。在本教程中，我们将Web应用程序部署到JBoss 5.1.0 Application Server。

要启动该应用程序，请将您的浏览器指向以下地址

http：// localhost：8080 / jaxwsspring /

如果一切顺利，您应该会在主页上看到以下内容：

“你好，世界！”

我们的Web服务地址应该位于：

http：// localhost：8080 / jaxwsspring / GreetingService

如果将浏览器指向以下位置，则可以查看我们的Web服务WSDL：

http：// localhost：8080 / jaxwsspring / GreetingService？wsdl

结果应如下所示：
```
<definitions name="GreetingService" targetNamespace="http://endpoints.jaxwsspring.javacodegeeks.com/">
 <types>
  <xs:schema targetNamespace="http://endpoints.jaxwsspring.javacodegeeks.com/" version="1.0">
   <xs:element name="sayHello" type="tns:sayHello"/>
   <xs:element name="sayHelloResponse" type="tns:sayHelloResponse"/>
   <xs:complexType name="sayHello">
    <xs:sequence/>
   </xs:complexType>
   <xs:complexType name="sayHelloResponse">
    <xs:sequence>
     <xs:element minOccurs="0" name="return" type="xs:string"/>
    </xs:sequence>
   </xs:complexType>
  </xs:schema>
 </types>

 <message name="GreetingServiceEndpoint_sayHello">
  <part element="tns:sayHello" name="sayHello"/>
 </message>

 <message name="GreetingServiceEndpoint_sayHelloResponse">
  <part element="tns:sayHelloResponse" name="sayHelloResponse"/>
 </message>

 <portType name="GreetingServiceEndpoint">
  <operation name="sayHello" parameterOrder="sayHello">
   <input message="tns:GreetingServiceEndpoint_sayHello"/>
   <output message="tns:GreetingServiceEndpoint_sayHelloResponse"/>
  </operation>
 </portType>

 <binding name="GreetingServiceEndpointBinding" type="tns:GreetingServiceEndpoint">
  <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
  <operation name="sayHello">
  <soap:operation soapAction=""/>
   <input>
    <soap:body use="literal"/>
   </input>
   <output>
    <soap:body use="literal"/>
   </output>
  </operation>
 </binding>

 <service name="GreetingService">
  <port binding="tns:GreetingServiceEndpointBinding" name="GreetingServiceEndpointPort">
   <soap:address location="http://127.0.0.1:8080/jaxwsspring/GreetingService"/>
  </port>
 </service>
</definitions>
```
现在我们有了Web服务定义，我们可以使用我们最喜欢的SOAP客户端（生成或实现一个）来调用“问候” Web服务的操作。访问Web服务不在本教程的讨论范围内，因此我们将不再对其进行讨论。不过，我们将提供一个示例请求–使用我们首选的Web服务测试工具soapUI调用“ GreetingService”的“ sayHello”操作时的响应对话框

soapUI工具发布的SOAP请求：
```
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:end="http://endpoints.jaxwsspring.javacodegeeks.com/">
   <soapenv:Header/>
   <soapenv:Body>
      <end:sayHello/>
   </soapenv:Body>
</soapenv:Envelope>
```
从“ greeting” Web服务接收到的相关SOAP响应：
```
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
   <env:Header/>
   <env:Body>
      <ns2:sayHelloResponse xmlns:ns2="http://endpoints.jaxwsspring.javacodegeeks.com/">
         <return>Hello from Greeting Service</return>
      </ns2:sayHelloResponse>
   </env:Body>
</env:Envelope>
```
如上所述，Sun的JDK 1.6附带的内置JAX-WS提供程序也使用JDK 1.6附带的内置HTTP服务器来支持Web服务公开。 Spring的“ SimpleJaxWsServiceExporter”在Spring应用程序上下文中检测所有带@WebService注释的bean，并通过默认的JAX–WS服务器（JDK 1.6 HTTP服务器）将其导出。

在这种情况下，端点实例被定义和管理为Spring bean本身。它们将在JAX-WS引擎中注册，但是它们的生命周期将取决于Spring应用程序上下文。这意味着诸如显式依赖项注入之类的Spring功能可以应用于端点实例。当然，通过@Autowired注解驱动的注入也将起作用。

要利用这种方法，我们要做的就是通过使用@Service注释对端点类声明为Spring bean。另外，我们必须在应用程序上下文文件中添加“ SimpleJaxWsServiceExporter” bean声明，如下所示：
```
package com.javacodegeeks.jaxwsspring.endpoints;

import javax.jws.WebMethod;
import javax.jws.WebService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.javacodegeeks.jaxwsspring.services.GreetingService;

@Service("greetingServiceEndpoint")
@WebService(serviceName="GreetingService")
public class GreetingServiceEndpoint {

 @Autowired
 private GreetingService greetingService;
 
 @WebMethod
 public String sayHello() {
  return greetingService.sayHello();
 }
 
}
```
这里要注意的事情：
1. GreetingServiceEndpoint可以从Spring的“ SpringBeanAutowiringSupport”派生而来，但不必这样做，因为该端点是完全由Spring管理的bean
```
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:task="http://www.springframework.org/schema/task"
 xsi:schemaLocation="
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   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
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

 <context:component-scan base-package="com.javacodegeeks.jaxwsspring" />

 <bean class="org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter">
  <property name="baseAddress" value="http://localhost:9999/" />
 </bean>

</beans>
```
这里要注意的事情：
1. 将context：component-scan元素的base-package属性更改为项目的基本包，以扫描Spring组件
2. 您可以更改“ SimpleJaxWsServiceExporter”的“ baseAddress”属性以适合您的需求。 “ baseAddress”是将导出所有检测到的Web服务的地址。默认的“ baseAddress”是“ http：// localhost：8080 /”
要构建应用程序，请右键单击您的项目？运行为？ Maven包

为了测试特定的方法，我们将Web应用程序部署到Apache Tomcat 6服务器。不要忘记，我们将利用Sun的JDK 1.6内置JAX-WS提供程序。即使我们在Servlet容器中进行操作。在这种特定情况下，我们仅将Servlet容器用于启动Spring应用程序。另外，您可以实现Main类并以编程方式启动Spring应用程序。

要启动该应用程序，请将您的浏览器指向以下地址

http：// localhost：8080 / jaxwsspring /

如果一切顺利，您应该会在主页上看到以下内容：

“你好，世界！”

我们的Web服务地址应该位于：

http：// localhost：9999 / GreetingService

如果将浏览器指向以下位置，则可以查看我们的Web服务WSDL：

http：// localhost：9999 / GreetingService？wsdl

我们可以再次使用Web服务定义来生成和/或实现SOAP客户端，以调用“问候” Web服务的操作。

作为GlassFish项目的一部分开发的Sun的JAX–WS RI，将Spring支持作为其JAX–WS Commons项目的一部分。这允许将JAX-WS端点定义为Spring管理的Bean，类似于上一节中讨论的独立模式-但这次是在Servlet环境中。请注意，这在Java EE 5环境中不可移植。它主要用于Tomcat之类的非EE环境，并将JAX–WS RI嵌入为Web应用程序的一部分。

与导出基于Servlet的端点的标准样式的不同之处在于，这里将由Spring管理端点实例本身的生命周期，并且在“ web.xml”中将仅定义一个JAX-WS Servlet 。使用标准的Java EE 5样式（如上所示），每个服务端点都有一个Servlet定义，每个端点通常都委派给Spring Bean。

最后一种方法是特定于Spring 2.0的 ，因此在更改任何代码之前，我们应该稍微更改项目配置。特别是，我们必须删除Spring 3库的依赖关系，并向jaxws-spring库添加一个新的依赖项。打开“ pom.xml”的图形编辑器并执行以下更改：
1. 在POM编辑器的“概述”页面上的“属性”部分中找到，并删除名称为org.springframework.version的属性（如果存在的话）–以防您从头开始遵循本教程
2. 导航到POM编辑器的“ Dependencies”页面，并创建以下依赖关系（您应在该页面的“ Dependency Details”部分的“ GroupId”，“ Artifact Id”和“ Version”字段中进行填充）：
- 组ID： org.jvnet.jax-ws-commons.spring工件ID： jaxws-spring版本： 1.8
自撰写本文以来， jaxws-spring库的最新版本（ 1.8 ）的“ pom”文件中存在依赖项声明缺陷。特别是对于jaxb-impl的2.1.2版本，不必要的依赖声明会导致代码中断。要解决此问题，必须为jaxb-impl库的特定版本配置排除项。为此，选择新创建的依赖项，找到编辑器页面的“排除项”部分，然后如下所示创建排除项：
- 组ID： com.sun.xml.bind工件ID： jaxb-impl
另外，为jaxb-impl库的2.1.6版本创建另一个显式依赖项，如下所示：
- 组ID： com.sun.xml.bind工件ID： jaxb-impl版本： 2.1.6
最后但并非最不重要的一点是，我们必须配置两个新的存储库，以便Maven能够下载项目依赖项。导航到POM编辑器的“存储库”页面，并创建以下存储库：
- ID： download.java.net存储库1 URL： http ： //download.java.net/maven/1/布局：旧版
- ID： download.java.net回购2 URL： http ： //download.java.net/maven/2/
要使用这种方法，我们必须遵循以下步骤：

找到“ web.xml”文件并通过定义主JAX-WS Servlet以及我们要作为Web服务公开的服务所需的尽可能多的Servlet映射来对其进行更改；每个服务一个Servlet映射。因此，对于我们的特定测试用例，我们应该添加以下声明：
```
<servlet>
    <servlet-name>jaxws-servlet</servlet-name>
    <servlet-class>com.sun.xml.ws.transport.http.servlet.WSSpringServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>jaxws-servlet</servlet-name>
    <url-pattern>/GreetingService</url-pattern>
  </servlet-mapping>
```
更改“ applicationContext.xml”文件，如下所示：
```
<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"
  xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://jax-ws.dev.java.net/spring/core
    http://jax-ws.dev.java.net/spring/core.xsd
    http://jax-ws.dev.java.net/spring/servlet
    http://jax-ws.dev.java.net/spring/servlet.xsd">

  <wss:binding url="/GreetingService">
    <wss:service>
      <ws:service bean="#greetingService" />
    </wss:service>
  </wss:binding>

  <bean id="greetingService" class="com.javacodegeeks.jaxwsspring.services.GreetingService" />

</beans>
```
这里要注意的事情：
1. 这种方法是特定于Spring 2.0的 ，因此已创建了与Spring 2.0兼容的“ applicationContext.xml”文件。请注意，由于@Service注释在Spring 2.0中不可用，因此我们直接在“ applicationContext.xml”文件中声明了“问候” Spring服务bean。
2. wss：binding定义定义将哪些服务公开到URL空间的哪一部分。在上面的代码中，它在/ GreetingService URL上部署了“ GreetingService”
3. ws：service定义实现一个Web服务实例。最简单的形式应该配置bean属性，以便将所有调用委托给指定的Spring bean。如您所见，使用这种方法，我们可以省略创建“端点”类来代理我们的Spring服务。
最后，我们实现“ GreetingService”，如下所示：
```
package com.javacodegeeks.jaxwsspring.services;

import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import javax.jws.soap.SOAPBinding.Use;

@WebService(serviceName="GreetingService")
@SOAPBinding(style = Style.RPC, use = Use.LITERAL)
public class GreetingService {

 @WebMethod
 public String sayHello() {
  return "Hello from Greeting Service";
 }
 
}
```
这里要注意的事情：
1. 如果使用的是“ Style.DOCUMENT ”，则应运行“ wsgen ”工具。 “ Style.RPC ”仅用于演示目的。
2. @Service批注在Spring 2.0中不可用，因此我们直接在“ applicationContext.xml”文件中声明
要构建应用程序，请右键单击您的项目？运行为？ Maven包

为了测试特定的方法，我们将Web应用程序部署到Apache Tomcat 6服务器。

要启动该应用程序，请将您的浏览器指向以下地址

http：// localhost：8080 / jaxwsspring /

如果一切顺利，您应该会在主页上看到以下内容：

“你好，世界！”

我们的Web服务地址应该位于：

http：// localhost：8080 / jaxwsspring / GreetingService

如果将浏览器指向以下位置，则可以查看我们的Web服务WSDL：

http：// localhost：8080 / jaxwsspring / GreetingService？wsdl

我们可以再次使用Web服务定义来生成和/或实现SOAP客户端，以调用“问候” Web服务的操作。

快乐编码

贾斯汀

相关文章：
翻译自: https://www.javacodegeeks.com/2010/11/jaxws-with-spring-and-maven-tutorial.html

spring和maven

dnc8371

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring和maven_具有Spring和Maven教程的JAX–WS

spring和maven Spring框架通过JAX-WS提供对Web服务的远程支持，实际上，如Spring 参考文档中所述，有三种将Spring POJO服务公开为JAX-WS Web服务的方式：公开基于Servlet的Web服务（适用于Java EE 5环境）导出独立的Web服务（适用于使用Sun的JDK 1.6内置JAX–WS提供程序的情况）使用JAX-WS RI的...
复制链接

扫一扫