读书笔记《advanced-java-ee-development-with-wildfly》开发JAX-WS 2.2 Web服务

Chapter 6. Developing a JAX-WS 2.2 Web Service

用于基于 XML 的 Web 服务的 Java API，称为为 JAX-WS (http://jcp.org/aboutJava/communityprocess/mrel/jsr224/index2.html)，是一种基于W3C标准的技术用于通过 HTTP 协议使用 XML 在服务和客户端之间进行通信。 JAX-WS Web 服务支持的一些 W3C 标准是 HTTP (http://www.w3.org/Protocols/)、SOAP (http://www.w3.org/TR/soap/) 和 Web 服务描述语言 (WSDL) (http://www.w3.org/TR/wsdl）。 JAX-WS 是一个独立于平台的标准； JAX-WS Web 服务可以与非 Java 客户端（例如 .NET 客户端）通信，而 JAX-WS 客户端可以与非 Java Web 通信服务，例如 .NET Web 服务。 JAX-WS 在以下工件中使用 XML：

WSDL 是一个 XML 文档，将网络服务描述为一组对消息进行操作的端点；端点是表示 Web 服务的 URL 位置
客户端和 Web 服务使用 XML 格式的 SOAP 消息进行通信

JAX-WS Web 服务由下列组件组成：

使用 javax.jws.WebService 注释的非最终、非抽象 Java 类。 Web 服务端点，Java 类由业务方法组成。 Web 服务客户端创建 Web 服务的代理以调用其方法（操作）。 Web 服务可选择返回响应。 Web 服务请求和响应是 HTTP 上的 SOAP 消息。
一个可选的 Java 接口，它定义了在 Web 服务实现类中实现的方法。

本章包含以下部分：

设置环境
创建 Java EE Web 项目
创建 Web 描述符
创建 JAX-WS Web 服务
创建 Web 服务客户端
使用 Maven 部署 JAX-WS 应用程序
运行 JAX-WS 应用程序

Setting up the environment

我们需要下载并安装以下软件：

WildFly 8.1.0.Final：从 wildfly-8.1.0.Final.zip 下载 <一个类="ulink" href="http://wildfly.org/downloads/" target="_blank">http://wildfly.org/downloads/。
MySQL 5.6 数据库社区版：从 http://dev.mysql.com/downloads/mysql/。安装 MySQL 时，请同时安装 Connector/J。
面向 Java EE 开发人员的 Eclipse IDE：从 https://www.eclipse.org/downloads/packages/release/Luna/SR1。
JBoss Tools (Luna) 4.2.0.Final（或最新版本）：将此作为插件从 Eclipse Marketplace 安装到 Eclipse（http://tools.jboss.org/downloads/installation.html) .
Apache Maven：从 http://maven.apache.org/download.cgi。
Java 7：从 http://www.oracle.com/technetwork/java/javase/downloads/index.html?ssSourceSiteId=ocomcn。

设置环境变量JAVA_HOME、JBOSS_HOME和MAVEN_HOME。添加%JAVA_HOME%/bin、%MAVEN_HOME%/bin和%JBOSS_HOME%/ bin 到 PATH 环境变量。

创建一个 WildFly 8.1.0 运行时，如第 1 章，EJB 3.x 入门。

Creating a Java EE web project

在此部分中，我们将为 JAX-WS Web 服务创建一个 Java EE Web 项目。选择文件 | 新。在 New 中，选择 JBoss Central | Java EE Web 项目，如以下屏幕截图所示。现在点击下一步。

读书笔记《advanced-java-ee-development-with-wildfly》开发JAX-WS 2.2 Web服务

针对要求运行测试，其中包括 m2e 和 m2eclipse-wtp 插件和 JBoss Maven 工具插件。选中复选框并创建一个空白项目；为 Target Runtime 选择 WildFly 8.x Runtime，如图在下面的屏幕截图中。现在点击下一步。

指定项目名称 (jboss- jaxws) 和 Package (org.jboss.jaxws)，如图以下屏幕截图。现在点击下一步。

将 Group Id 指定为 org。 jboss.jaxws, Artifact Id (jboss-jaxws), 版本（1.0.0）和包 strong> (org.jboss.jaxws)，如下图所示。然后点击完成。

生成一个基于 Maven 的 Java EE Web 项目 jboss-jaxws，如 Project Explorer 在以下屏幕截图中。删除 jboss-jaxws/src/main/resources/META-INF/persistence.xml 配置文件：

Creating a web descriptor

JAX-WS Web 服务需要 Web 描述符。在本节中，我们将创建一个 Web 描述符。选择文件 | 新 | 其他。在 New 中，选择 JBoss Tools Web | Web Descriptor点击Next，如下图截屏：

点击 Browse 获取< strong>Folder 字段以选择 webapp/WEB-INF 文件夹.指定Name为web.xml，选择版本为3.1，然后点击Finish ，如下图所示：

Creating a JAX-WS web service

在这个部分中，我们将在 Java EE Web 项目中创建一个 JAX-WS Web 服务。选择文件 | 新 | 其他。在 New 中，选择 JBoss Tools | 创建示例 Web 服务，如以下屏幕截图所示。现在点击下一步。

在 Generate a Sample Web Service 中，指定项目和 Web 服务名称。选择 jboss-jaxws web 项目并指定 Name Web Service 的为 HelloWorld。对于 Sample Web Service Class，将 Package 指定为 org.jboss.jaxws.service 和 Class 作为 HelloWorld，如下图所示。现在点击完成。

HelloWorld 类被创建。使用 @WebService 注解对该类进行注解，这表明该类实现了一个 Web 服务。在 @WebService 中添加以下元素 注释：

元素	描述	价值
`端口名称`	这是 Web 服务的端口名称。这也是 Web 服务 WSDL 中的 `wsdl:portname`。	`HelloWorldPort`
`服务名称`	这是 Web 服务的服务名称。这也是 WSDL 中的 `ws:servicename`。	`HelloWorldService`
`目标命名空间`	此是 WSDL 中 `wsdl:service` 的目标命名空间。	`http://org.jboss.jaxws.service/`
`endpointInterface`	这是定义 Web 服务方法的服务端点接口的名称。	`org.jboss.jaxws.service.HelloWS`

HelloWorld 实现类实现 HelloWS 接口。添加一个业务方法 sayHello(String) 以 String 名称作为参数并返回一个 字符串消息。业务方法使用 @WebMethod 注释进行注释。业务方法不能是 static 或 final。业务方法作为 Web 服务操作向客户端公开。 Web 服务端点 Java 类在此处列出：

package org.jboss.jaxws.service;

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

@WebService(portName = "HelloWorldPort",     serviceName = "HelloWorldService", targetNamespace = "http://org.jboss.jaxws.service/", endpointInterface = "org.jboss.jaxws.service.HelloWS")
public class HelloWorld implements HelloWS{

  @WebMethod ()
  public String sayHello(String name) {
     
      return "Hello "+name +" Welcome to Web Services!";
      
  }
}

当端点实现端点接口时，创建一个 Java 接口。选择文件 | 新 | 其他。在 New 中，选择界面，点击Next，如下图所示：

在 New Java Interface 中，选择源文件夹为src/main/java，指定包< /span> 为 org.jboss.jaxws.service，并指定 Name 为 HelloWS，如此处所示。然后点击完成。

org.jboss.jaxws.HelloWS 接口被添加到 乔布斯-jaxws 项目。用@WebService注解HelloWS接口，表示Java接口是Web服务接口。 @WebService的name元素指定web服务名称，作为wsdl:portType。 targetNamespace 指定 Web 服务的目标命名空间。端点接口定义了一个用 @WebMethod 注释的 sayHello 方法，其 operationName 元素设置为 hello。端点接口在此处列出：

package org.jboss.jaxws.service;

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

@WebService(name = "HelloWS",   targetNamespace = "http://org.jboss.jaxws.service/")
public interface HelloWS {
  @WebMethod(operationName = "hello")
  public String sayHello(String name);

}

可以使用 JSR-109 编程模型发布 JAX-WS Web 服务，以便在 Java 中实现 Web 服务。 WildFly 8.1 支持 JSR-109 部署模型，其中 Web 服务可以配置为 web.xml 中的 servlet 类。我们将使用 JSR-109 部署模型；我们需要将 Web 服务配置为 web.xml 中的 servlet。将端点类 org.jboss.jaxws.service.HelloWorld 指定为 web.xml 中的 servlet，并带有相应的 servlet 映射 URL作为 /HelloWorld。 web.xml 文件在此处列出：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <servlet>
    <display-name>HelloWorld</display-name>
    <servlet-name>HelloWorld</servlet-name>
    <servlet-class>org.jboss.jaxws.service.HelloWorld</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>HelloWorld</servlet-name>
    <url-pattern>/HelloWorld</url-pattern>
  </servlet-mapping>
</web-app>

HelloWorld Web 服务类和服务端点接口 HelloWS 在 Eclipse 中显示在以下屏幕截图中：

Creating a web service client

在本节中，我们将为 HelloWorld Web 服务创建一个 JSP Web 服务客户端。要创建 JSP，请选择文件 | 新 | 其他。在 New 中，选择 Web | JSP File点击下一步，如下图截屏：

在 New JSP File 向导中，选择 webapp 文件夹，指定文件名为JAXWSClient.jsp，然后点击下一步，如下图所示：

选择New JSP file (html)模板并点击完成。 JAXWSClient.jsp 文件被添加到 webapp 文件夹中。在客户端 JSP 中，我们将调用带有名称的 Web 服务并在浏览器中显示 Web 服务响应。首先，为 WSDL 创建一个 URL 对象。 Web 服务的 URL 由上下文根 + 端点构成：

URL wsdlLocation = new URL("http://localhost:8080/jboss-jaxws/HelloWorld?WSDL");

中的 jboss-jaxws 是上下文根，而 /HelloWorld 是 web.xml 中指定的 Web 服务端点的 servlet 映射 URL。接下来，为服务名称创建一个 QName 对象。 QName 代表一个限定名。将 QName 构造函数的参数指定为目标命名空间 http://org.jboss.jaxws.service/ 和服务名称HelloWorldService：

QName serviceName = new QName("http://org.jboss.jaxws.service/","HelloWorldService");

Web 服务的客户端视图由 javax.xml.ws.Service 对象提供。从 WSDL 位置 URL 创建 javax.xml.ws.Service 并为服务名称创建 QName：

Service service = Service.create(wsdlLocation, serviceName);

使用 getPort(Class endpointInterface) 方法获取 Web 服务的代理。将端点接口类指定为 org.jboss.jaxws.service.HelloWS.class：

HelloWS port = service.getPort(org.jboss.jaxws.service.HelloWS.class);

使用名称作为参数调用 Web 服务代理的 sayHello 方法。 sayHello 方法返回一个 String。输出来自 Web 服务的响应：

String result = port.sayHello("John Smith");
out.println(result);

JAXWSClient.jsp 在这里列出：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ page
  import="org.jboss.jaxws.service.*,javax.xml.ws.WebServiceRef,java.net.URL,javax.xml.namespace.QName,javax.xml.ws.Service"%>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/xml; charset=windows-1252" />
    <title>JAXWS Client</title>
  </head>
  <body>
    <%URL wsdlLocation = new URL ( "http://localhost:8080/jboss-jaxws/HelloWorld?WSDL");
    QName serviceName = new QName("http://org.jboss.jaxws.service/", "HelloWorldService");
    Service service = Service.create(wsdlLocation, serviceName);

    HelloWS port = service.getPort(org.jboss.jaxws.service.HelloWS.class);
    String result = port.sayHello("John Smith");
    out.println(result);
%>
  </body>
</html>

jboss-jaxws 应用程序的目录结构在 Java EE web 项目中显示在以下屏幕截图中：

Deploying the JAX-WS application with Maven

在本节中，我们将编译、打包和部署 jboss-jaxws 应用到 WildFly 8.1。在 pom.xml 文件中指定下表中讨论的 JAX-WS 相关依赖项：

依赖	描述
组 ID：`com.sun.xml.ws` 工件 ID：`jaxws-rt`	JSR 224 的开源参考实现：用于 XML Web 服务的 Java API
组 ID：`javax.xml.ws` 工件 ID：`jaxws-api`	JAX-WS (JSR 224) API
组 ID：`com.sun.xml.bind` 工件 ID：`jaxb-impl`	JAXB (JSR 222) 参考实现
组 ID：`com.sun.xml.bind` 工件 ID：`jaxb-xjc`	JAXB (JSR 222) 参考实现模式编译器

我们将使用 JAX-WS Maven 插件（http://jax-ws-commons.java.net/jaxws-maven-plugin/)，其中是 JAX 的 Maven 适配器- WS 的工具集。该插件提供 wsgen 和 wsimport 目标来为 Web 服务生成所需的可移植工件。首先，运行 wsgen 目标以从端点实现类生成 JAX-WS Web 服务可移植工件，包括 WSDL。随后，运行 wsimport 目标以从 WSDL 生成 Web 服务客户端使用的 Web 服务可移植工件。对于 wsgen 目标，将 <sei/> 元素中的服务端点接口指定为 org.jboss.jaxws.service.HelloWorld，并在 <serviceName/> 元素中指定服务名称为 HelloWorldService。将 wsgen 目标的 <genwsdl/> 设置为 true。指定 Maven 编译器插件和 Maven WAR 插件，输出目录设置为部署目录。 pom.xml 代码在这里列出：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.jboss.jaxws</groupId>
  <artifactId>jboss-jaxws</artifactId>
  <version>1.0.0</version>
  <packaging>war</packaging>
  <name>Java EE 7 webapp project</name>
  <description>A starter Java EE 7 webapp project for use on JBoss 
  WildFly / WildFly, generated from the jboss-javaee6-webapp 
  archetype</description>
  <url>http://wildfly.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-
    8</project.build.sourceEncoding>
    <!-- JBoss dependency versions -->
    <version.wildfly.maven.plugin>1.0.2.Final </version.wildfly.maven.plugin>
    <!-- Define the version of the JBoss BOMs we want to import to specify tested stacks. -->
    <version.jboss.bom>8.1.0.Final</version.jboss.bom>
    <!-- other plugin versions -->
    <version.compiler.plugin>3.1</version.compiler.plugin>
    <version.war.plugin>2.1.1</version.war.plugin>
    <!-- maven-compiler-plugin -->
    <maven.compiler.target>1.7</maven.compiler.target>
    <maven.compiler.source>1.7</maven.compiler.source>
  </properties>
  <repositories>
    <repository>
      <id>JBoss Repository</id>
      <url>https://repository.jboss.org/nexus/content /groups/public/</url>
    </repository>
  </repositories>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.wildfly.bom</groupId>
        <artifactId>jboss-javaee-7.0-with-tools</artifactId>
        <version>${version.jboss.bom}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>org.wildfly.bom</groupId>
        <artifactId>jboss-javaee-7.0-with-hibernate</artifactId>
        <version>${version.jboss.bom}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <dependencies>
    <!-- First declare the APIs we depend on and need for compilation. All of them are provided by JBoss WildFly -->
    <!-- Import the CDI API, we use provided scope as the API is included in JBoss WildFly -->
    <dependency>
      <groupId>javax.enterprise</groupId>
      <artifactId>cdi-api</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.sun.xml.ws</groupId>
      <artifactId>jaxws-rt</artifactId>
      <version>2.2.8</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.xml.ws</groupId>
      <artifactId>jaxws-api</artifactId>
      <version>2.2.8</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.sun.xml.bind</groupId>
      <artifactId>jaxb-impl</artifactId>
      <version>2.2.7</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
    <!-- Import the Common Annotations API (JSR-250), we use provided scope as the API is included in JBoss WildFly -->
    <dependency>
      <groupId>org.jboss.spec.javax.annotation</groupId>
      <artifactId>jboss-annotations-api_1.2_spec</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.xml.bind</groupId>
      <artifactId>jaxb-api</artifactId>
      <version>2.2.7</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <!-- Maven will append the version to the finalName (which is the name given to the generated war, and hence the context root) -->
    <finalName>${project.artifactId}</finalName>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.eclipse.m2e</groupId>
          <artifactId>lifecycle-mapping</artifactId>
          <version>1.0.0</version>
          <configuration>
            <lifecycleMappingMetadata>
              <pluginExecutions>
                <pluginExecution>
                  <pluginExecutionFilter>
                    <groupId>org.jvnet.jax-ws-commons</groupId>
                    <artifactId>jaxws-maven-plugin</artifactId>
                    <versionRange>[2.2,)</versionRange>
                    <goals>
                      <goal>wsimport</goal>
                    </goals>
                  </pluginExecutionFilter>
                  <action>
                    <ignore />
                  </action>
                </pluginExecution>
              </pluginExecutions>
            </lifecycleMappingMetadata>
          </configuration>
        </plugin>
        <!-- Compiler plugin enforces Java 1.6 compatibility and activates annotation processors -->
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>${version.compiler.plugin}</version>
          <configuration>
            <source>${maven.compiler.source}</source>
            <target>${maven.compiler.target}</target>
          </configuration>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>${version.war.plugin}</version>
          <configuration>
            <outputDirectory>C:\wildfly-8.1.0.Final\standalone\deployments</outputDirectory>
            <!-- Java EE 7 doesn't require web.xml, Maven needs to catch up! -->
            <failOnMissingWebXml>false</failOnMissingWebXml>
          </configuration>
        </plugin>
        <!-- The WildFly plugin deploys your war to a local WildFly container -->
        <!-- To use, run: mvn package wildfly:deploy -->
        <plugin>
          <groupId>org.wildfly.plugins</groupId>
          <artifactId>wildfly-maven-plugin</artifactId>
          <version>${version.wildfly.maven.plugin}</version>
        </plugin>
        <plugin>
          <groupId>org.jvnet.jax-ws-commons</groupId>
          <artifactId>jaxws-maven-plugin</artifactId>
          <version>2.2</version>
          <executions>
            <execution>
              <id>HelloWorldService</id>
              <phase>compile</phase>
              <goals>
                <goal>wsgen</goal>
              </goals>
              <configuration>
                <sei>org.jboss.jaxws.service.HelloWorld</sei>
                <genwsdl>true</genwsdl>
                <servicename>HelloWorldService</servicename>
                <keep>true</keep>
              </configuration>
            </execution>
          </executions>
        </plugin>
        <plugin>
          <groupId>org.jvnet.jax-ws-commons</groupId>
          <artifactId>jaxws-maven-plugin</artifactId>
          <version>2.3</version>
          <executions>
            <execution>
              <id>HelloWorldService</id>
              <goals>
                <goal>wsimport</goal>
              </goals>
            </execution>
          </executions>
          <configuration>
            <packagename>org.jboss.jaxws.service</packagename>
            <target>2.0</target>
            <keep>true</keep>
          </configuration>
          <dependencies>
            <dependency>
              <groupId>com.sun.xml.ws</groupId>
              <artifactId>jaxws-tools</artifactId>
              <version>2.2.8</version>
              <exclusions>
                <exclusion>
                  <groupId>org.jvnet.staxex</groupId>
                  <artifactId>stax-ex</artifactId>
                </exclusion>
              </exclusions>
            </dependency>
            <dependency>
              <groupId>org.jvnet.staxex</groupId>
              <artifactId>stax-ex</artifactId>
              <version>1.7.6</version>
              <exclusions>
                <exclusion>
                  <groupId>javax.xml.stream</groupId>
                  <artifactId>stax-api</artifactId>
                </exclusion>
              </exclusions>
            </dependency>
          </dependencies>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

在中的 pom.xml 上右键单击 Project Explorer 并选择 Run As | Maven 安装，如下图所示：

jboss-jaxws 项目被编译并且打包到 jboss-jaxws.war 档案中。 BUILD SUCCESS 消息表明 Maven 构建完成且没有任何错误，如下所示：

如果尚未启动，则启动 WildFly 8.1。 jboss-jaxws.war 存档被部署到 WildFly 8.1，如 Administration 控制台所示：

Web 服务的 WSDL 可以在浏览器中使用 URL < code class="literal">http://localhost:8080/jboss-jaxws/HelloWorld?WSDL，如下截图所示：

WSDL 文件的内容如下所示：

<wsdl:definitions xmlns:xsd="http://www.w3.org/2001/XMLSchema"xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"xmlns:tns="http://org.jboss.jaxws.service/"xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"xmlns:ns1="http://schemas.xmlsoap.org/soap/http"name="HelloWorl dService"targetNamespace="http://org.jboss.jaxws.service/">
<wsdl:types>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"xmlns:tns="http://org.jboss.jaxws.service/"elementFormDefault="unqualified"tar getNamespace="http://org.jboss.jaxws.service/" version="1.0">
<xs:element name="hello" type="tns:hello"/>
<xs:element name="helloResponse" type="tns:helloResponse"/>
<xs:complexType name="hello">
<xs:sequence>
<xs:element minOccurs="0" name="arg0" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="helloResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:schema>
</wsdl:types>
<wsdl:message name="hello">
<wsdl:part element="tns:hello" name="parameters"></wsdl:part>
</wsdl:message>
<wsdl:message name="helloResponse">
<wsdl:part element="tns:helloResponse" name="parameters"> </wsdl:part>
</wsdl:message>
<wsdl:portType name="HelloWS">
<wsdl:operation name="hello">
<wsdl:input message="tns:hello" name="hello"></wsdl:input>
<wsdl:output message="tns:helloResponse"name="helloResponse"> </wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="HelloWorldServiceSoapBinding" type="tns:HelloWS">
<soap:binding style="document"transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="hello">
<soap:operation soapAction="" style="document"/>
<wsdl:input name="hello">
<soap:body use="literal"/>
</wsdl:input>
<wsdl:output name="helloResponse">
<soap:body use="literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="HelloWorldService">
<wsdl:port binding="tns:HelloWorldServiceSoapBinding" name="HelloWorldPort">
<soap:address location="http://localhost:8080/jboss-jaxws/HelloWorld"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

Running the JAX-WS application

在本节中，我们将使用 JSP 客户端调用 Web 服务。使用 URL http://localhost:8080/jboss-jaxws/JAXWSClient.jspJAXWSClient.jsp 文件>。 Web 服务响应显示在浏览器中，如以下屏幕截图所示：

Summary

在本章中，我们使用 JBoss Tools 示例 Web 服务在 Eclipse IDE 中开发了一个 JAX-WS Web 服务。我们创建了一个端点实现类和一个端点接口。我们为 Web 服务开发了一个 JSP 客户端。 Web 服务使用 JSR-109 部署模型进行部署，其中涉及将端点类配置为 web.xml 中的 servlet。我们使用 Maven 构建工具对 Web 服务项目进行编译和打包，并将 Web 应用程序部署到 WildFly 8.1。随后，我们在浏览器中运行 Web 服务客户端 JSP。

在下一章中，我们将讨论 WildFly 8.1 的 RESTful Web 服务。

vlambda博客
学习文章列表