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

Chapter 7. Developing a JAX-RS 1.1 Web Service

在本章中，我们将讨论 Representational State Transfer（REST) Web 服务，特别是那些基于 Java API 的 RESTful Web 服务 (JAX-RS 1.x)，在 JSR 311 (http: //jcp.org/en/jsr/detail?id=311）。新版本的 JAX-RS (2.0) 已经可用，并在第 9 章，在带有 RESTEasy 的 Java EE 7 中使用 JAX-RS 2.0。首先讨论以前的版本，因为它构成了新版本的基础，也因为许多开发人员仍在使用以前的版本。当新版本可用时，不会迁移到现有应用程序的新版本。 REST 是一种独立于协议、松散耦合的分布式系统软件架构风格。协议无关意味着 REST 支持任何支持表示状态传输的协议，但我们将仅讨论基于 HTTP 的 REST。与 SOAP 相比，REST 的类型不那么强，不需要 XML 解析，也不需要消息头。 RESTful Web 服务基于 REST 原则，简单、轻量、快速。 RESTful Web 服务公开了一组资源，这些资源只是信息的来源，由 HTTP 中的 URI 标识。资源可以是数据库记录或 Plain Old Java Object ( POJO）例如。交换的不是资源本身，而是资源的表示，通常是 HTML、XML、JSON 和纯文本格式的文档，但它们可以是图像或其他格式。基于资源的表示和包含的元数据，客户端对资源进行更改。

RESTful Web 服务遵循以下 RESTful 原则：

每个资源都有一个唯一的基本 URI。
用于调用 Web 服务操作的 HTTP 协议方法，例如 GET、PUT、POST< /code> 和 DELETE 被使用。
客户端向服务发送请求，服务将请求的资源的表示返回给客户端。
客户端会话不存储在服务器上，这使得在集群环境中以更少的数据复制更容易扩展服务。

在本章中，我们将使用 Jersey JAX-RS (JSR 311) 参考实现 (RI ) 在 Java 中创建 RESTful Web 服务。本章包含以下部分：

设置环境
创建 Java EE Web 项目
创建示例 RESTful Web 服务
部署 RESTful Web 服务
运行 RESTful Web 服务
创建 Java 客户端
运行 Java 客户端
创建 JSP 客户端
运行 JSP 客户端

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

在这个部分，我们将创建一个 Java EE Web 项目。选择文件 | 新 | 其他。在 New 中，选择 JBoss Central | Java EE Web 项目，如此处所示。现在，点击下一步。

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

要求列表，包括 m2e 和 m2eclipse-wtp 插件，JBoss Maven Tools 插件如下所示。选中 Create a blank project 复选框并选择 WildFly 8.x Runtime 作为目标运行时。然后，点击下一步。

指定项目名称 (jboss-jaxrs) 和打包（org.jboss.jaxrs），然后点击下一步，如下所示：

指定组 ID (org. jboss.jaxrs), 工件 ID (jboss-jaxrs), 版本（1.0.0）和包 (org.jboss.jaxrs) 并点击 Finish，如此处所示：

jboss-jaxrs Java EE web 项目显示在项目浏览器：

Creating a sample RESTful web service

在这个部分中，我们将创建一个 RESTful Web 服务。右键单击 Project ExplorerJAX-RS Web Services 节点span> 并选择 New JAX-RS Resource，如下所示：

选择 jboss-jaxrs 项目并指定Package 作为 org.jboss.jaxrs.rest，Name 作为 < code class="literal">HelloWorldResource, 资源路径 as /helloworld,并点击Next，如下图所示：

在 JAX-RS Application 窗口中，选择源文件夹为jboss-jaxrs/src/main/java并指定包为org.jboss.jaxrs.rest，名称作为 HelloRESTApplication，应用程序路径作为 /rest< /code>，然后点击Finish，如下所示：

org.jboss.jaxrs.rest.HelloWorldResource 类被生成，如项目浏览器。

JAX-RS RESTful Web 服务资源是使用根资源类定义的。 Web 服务的 URI 由路径指示符构成，这些指示符是使用 @PATH 注释指定的。使用根资源类定义资源。根资源类是用 @PATH 注释的 POJO，其中一个或多个用资源方法指示符 (@GET 注释的类方法， @PUT, @POST, @DELETE) 或使用 @PATH 注释或同时使用资源方法指示符和 @PATH。使用资源方法指示符注释的根类方法称为资源方法。使用 @PATH 注释的资源方法称为子资源方法。仅使用 @PATH 注释的类方法称为子资源定位器。

资源响应 HTTP 方法，例如 GET、POST 、PUT 和 DELETE (http://www.w3.org/Protocols/HTTP/Methods.html)。例如，客户端可以使用 GET 获取资源表示，使用 PUT 上传资源的修改副本，或者删除使用 DELETE 的资源。资源方法（以及子资源方法和子资源定位器）可以返回各种格式的资源表示，例如 HTML、纯文本、XML、PDF、JPEG 和 JSON。

我们将使用 @GET 请求方法指示符创建具有一些资源方法的根资源类。使用 @PATH 注释对 Java 类 org.jboss.jaxrs.rest.HelloWorldResource 进行注释。将托管 Java 类的 URI 路径指定为 /helloworld：

@Path("/helloworld")
public class HelloWorldResource {
…
}

接下来，添加资源方法以生成三种不同的 MIME 类型。添加资源方法 getClicedMessage()、getXMLMessage() 和 getHTMLMessage() （方法名任意）用@GET注解，表示资源方法将处理HTTP GET来自客户的请求。每个资源方法产生不同的 MIME 类型资源表示。每个资源方法都返回 String，但是在 @Produces 注解中返回和指定的 MIME 类型对于不同的资源是不同的方法。我们将以三种不同的 MIME 类型输出 "Hello JAX-RS" 消息：text/plain、text/xml 和 text/html。每个资源方法中返回的 String 值的格式与指定的 MIME 类型相对应。为 JSP 客户端添加两个版本的 getXMLMessage() 方法，如后面部分所述。添加一个使用 @Produces("application/xml") 注释的资源方法，以演示生成的 MIME 类型与客户端中可接受的 MIME 类型相匹配的要求。根资源类列举如下；一些部分已被注释掉以单独测试资源方法：

package org.jboss.jaxrs.rest;

import javax.ws.rs.GET;
import javax.ws.rs.Produces;
import javax.ws.rs.Path;
import javax.ws.rs.core.MediaType;

// The Java class will be hosted at the URI path "/helloworld"
@Path("/helloworld")
public class HelloWorldResource {

  // The Java method will process HTTP GET requests
  //
  // The Java method will produce content identified by the MIME Media
  // type "text/plain"
  @GET
  @Produces("text/plain")
  public String getClichedMessage() {
    // Return some cliched textual content
    return "Hello JAX-RS";
  }
  /**
   * @GET
   * @Produces("application/xml") public String getXMLMessage() { return
   *                              "<?xml version=\"1.0\"?>" +
   *                              "<hello> Hello JAX-RS" + "</hello>"; }
  */

//for java  client
@GET
  @Produces("text/xml")
  public String getXMLMessage() { 
    return "<?xml version=\"1.0\"?>" + "<hello> Hello JAX-RS" + "</hello>";
  } 

//for jsp client
  /**@GET
  @Produces("text/xml")
  public String getXMLMessage () {
    return "&lt;?xml version=\"1.0\"?&gt;" + "&lt;hello&gt;Hello JAX-RS" + "&lt;/hello&gt;";
  }*/

  @GET
  @Produces("text/html")
  public String getHTMLMessage() {
    return "<html> " + "<title>" + "Hello JAX-RS" + "</title>"
        + "<body><h1>" + "Hello JAX-RS" + "</body></h1> " + "</html> ";
  }

}

我们还需要创建一个网络部署描述符web.xml。选择文件 | 新 | Other，并在 New 中选择 JBoss 工具网站 | Web Descriptor并点击Next，如下图所示：

在 New Web Descriptor File 中，选择 /jboss-jaxrs/src/main/webapp/WEB-INF 文件夹并将 Name 指定为 web.xml 并选择 Version 作为 3.1 ，然后点击Finish，如下图所示：

在 web.xml 文件中，为 servlet 类 一个 servlet >com.sun.jersey.spi.container.servlet.ServletContainer，这是一个用于部署根资源类的servlet。将 servlet 映射 URL 模式指定为 /jaxrs/*：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
 <display-name>EclipseJAX-RS</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  <servlet>
    <servlet-name>JAX-RS Servlet</servlet-name>
    <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer </servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>JAX-RS Servlet</servlet-name>
    <url-pattern>/jaxrs/*</url-pattern>
  </servlet-mapping>
</web-app>

web.xml 文件是显示在 Project Explorer 如下：

Deploying the RESTful web service

在这个部分，我们将编译、打包和部署 JAX-RS 应用程序 jboss-jaxrs马文。创建 Java EE Web 项目时会创建 pom.xml 文件。在 pom.xml 文件中，jboss-jaxrs 工件 ID 被指定为包装为 战争。 JAX-RS API 由 WildFly 8.1 提供：

  <dependency>
    <groupId>org.jboss.spec.javax.ws.rs</groupId>
    <artifactId>jboss-jaxrs-api_1.1_spec</artifactId>
    <version>1.0.1.Final</version>
    <scope>provided</scope>
  </dependency>

因为我们是使用 Jersey JAX-RS RI，所以包括 Jersey 的依赖项，这些依赖项在 Group ID com 中可用.sun.jersey：

  <dependency>
     <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-server</artifactId>
    <version>1.18</version>
  </dependency>
  <dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-core</artifactId>
    <version>1.18</version>
  </dependency>

  <dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-servlet</artifactId>
    <version>1.18</version>
  </dependency>
  <dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-client</artifactId>
    <version>1.18</version>
  </dependency>

添加 Maven Compiler 插件和 Maven WAR 插件，并将输出目录指定为 WildFly 8.1 安装的 deployments 目录。 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.jaxrs</groupId>
  <artifactId>jboss-jaxrs</artifactId>
  <version>1.0.0</version>
  <packaging>war</packaging>
  <name>WildFly JAX-RS</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>
    <!-- Explicitly declaring the source encoding eliminates the following message: -->
    <!-- [WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent! -->
    <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>
    <version.arquillian.container>8.1.0.Final </version.arquillian.container>
    <!-- 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>
  <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.jboss.spec</groupId>
        <artifactId>jboss-javaee-web-7.0</artifactId>
        <version>1.0.0.Final</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>
    <!-- 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>
    <!-- Import the JAX-RS API, we use provided scope as the API is included in JBoss WildFly -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.jboss.spec.javax.ws.rs</groupId>
      <artifactId>jboss-jaxrs-api_1.1_spec</artifactId>
      <version>1.0.1.Final</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-server</artifactId>
      <version>1.18</version>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-core</artifactId>
      <version>1.18</version>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-servlet</artifactId>
      <version>1.18</version>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-client</artifactId>
      <version>1.18</version>
    </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>
        <!-- Compiler plugin enforces Java 1.6 compatibility and activates annotation processors -->
        <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>
        <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>

在我们安装 jboss-jaxrs 应用程序之前，删除 org.jboss .jaxrs.rest.HelloRESTApplication.java，它是自动创建的。另外，删除资源和测试目录。 jboss-jaxrs 应用程序的目录结构如下所示：

右键单击 pom.xml 上的并选择运行作为 | Maven 安装，如下图所示：

jboss-jaxrs 应用程序被编译，打包到 jboss-jaxrs .war 并输出到 deployments 目录。 Maven install 输出消息 BUILD SUCCESS，如下所示：

启动 WildFly 8.1 服务器（如果尚未启动）。默认情况下，会在 WEB-INF/lib 和 WEB-INF/classes 目录中扫描根资源类。 org.jboss.jaxrs.rest.HelloWorldResource 根资源类被找到。 jboss-jaxrs.war 应用程序被部署到服务器。现在，登录 WildFly 8.1 Administration 控制台并点击 Manage Deployments< /跨度>。 jboss-jaxrs.war 文件应列为已部署，如下所示：

Running the RESTful web service

在本节中，我们将运行根资源类。调用 URL http://localhost:8080/jboss-jaxrs/jaxrs/helloworld。 jboss-jaxrs 包含在 URL 中，因为它是 Web 应用程序的上下文。包含 jaxrs 以调用 servlet com.sun.jersey.spi.container.servlet.ServletContainer。 /helloworld 是 RESTful Web 服务的资源 URI。我们没有用 @PATH 注释任何资源方法或类方法；因此，我们不会调用特定的方法。根资源类中的第一个资源方法被调用。将不同的资源方法作为根资源类中的第一个来测试不同的 MIME 类型输出。如果需要 HTML 输出，请将 getHTMLMessage 方法设置为根资源类中的第一个方法。

浏览器中的 HTML 输出如下所示：

如果 getClichedMessage() 资源方法在资源类中按顺序排在第一位，则 http://localhost:8080/jboss-jaxrs/jaxrs/helloworld 被调用时，="literal">text/plain 表示会显示在浏览器中如此处所示：

如果 getXMLMessage() 资源方法在资源类中按顺序排在第一位，则 XML 表示将显示在浏览器中，如下所示：

当修改后在资源类中调用不同的方法时，jboss-jaxrs 应用程序将需要重新安装。要重新安装，首先必须清理 Maven 项目，您需要右键单击 pom.xml 并选择 Run As | Maven 清理。 BUILD SUCCESS 消息表明先前安装生成的文件已被删除。

Creating a Java client

在这个部分中，我们将使用 Jersey 客户端 API 创建一个 JAX-RS Web 服务客户端。为 Java 客户端创建一个 Java 类。选择文件 | 新 | 其他。在 New 中，选择 Class 并点击下一步。在 New Java Class 向导中，选择 Source folder 作为 < code class="literal">src/main/java，指定Package为org.jboss .jaxrs.rest，Name为JAXRSClient，如下图.然后点击完成。

org.jboss.jaxrs.rest.JAXRSClient 类被创建，如下所示：

Jersey 提供客户端 API 来调用 JAX-RS Web 服务。在 Java 客户端中，使用 Jersey 客户端 API 调用资源方法。使用 com.sun.jersey.api.client.Client 类创建资源实例。首先，我们需要创建一个 ClientConfig 对象，该对象使用 DefaultClientConfig< 的无参数构造函数表示客户端配置，例如属性名称和功能。 /代码>。使用静态方法 create(ClientConfig) 从 ClientConfig 对象创建一个 Client 对象代码>。使用 resource(URI) 从 Client 对象创建一个 WebResource 对象Client 对象的方法，其中 URI 参数是 JAX-RS Web 服务的基本 URI，可以通过getBaseURI() 方法。 WebResource 对象是对 Web 资源的封装，用于向 Web 资源发送请求和从 Web 资源接收响应：

ClientConfig config = new DefaultClientConfig();
Client client = Client.create(config);
WebResource service = client.resource(getBaseURI());

添加方法 getBaseURI() 以返回基本 URI。基本 URI 是通过 UriBuilder 类使用静态方法 fromUri 获取 URL http ://localhost:8080/jboss-jaxrs 以及随后的 build 方法来构建 URI 对象：

private static URI getBaseURI() {
    return UriBuilder.fromUri("http://localhost:8080/jboss-jaxrs")
  .build();
}

通过在 get() 方法获取 Web 服务响应>WebResource 对象，以 String.class 作为参数，因为资源方法的返回类型是 String。首先，使用 path() 方法将路径添加到 WebResource 对象的基本 URI，该方法返回一个新的 WebResource 对象添加了路径。将 jaxrs 添加到 URI 路径以调用 com.sun.jersey.spi.container.servlet.ServletContainer servlet 并添加 < code class="literal">helloworld 到 URI 路径以调用 HelloWorldResource 资源。使用 accept() 方法将可接受的媒体类型添加到 WebResource 对象。我们将使用三种不同的媒体类型测试 HelloWorldResource：TEXT_PLAIN、TEXT_XML、和 TEXT_HTML。例如，TEXT_PLAIN 响应输出如下：

System.out.println(service.path("jaxrs").path("helloworld").accept (MediaType.TEXT_PLAIN).get(String.class));

同样，使用 MediaType.TEXT_XML 和 MediaType.TEXT_HTML 媒体类型将响应输出为 XML 和 HTML。 JAXRSClient.java 类如下：

package org.jboss.jaxrs.rest;

import java.net.URI;
import javax.ws.rs.core.*;
import com.sun.jersey.api.client.*;
import com.sun.jersey.api.client.config.*;

public class JAXRSClient {
  public static void main(String[] args) {
    ClientConfig config = new DefaultClientConfig();
    Client client = Client.create(config);
    WebResource service = client.resource(getBaseURI());
  System.out.println(service.path("jaxrs").path("helloworld").accept (MediaType.TEXT_PLAIN).get(String.class));
  System.out.println(service.path("jaxrs").path("helloworld").accept (MediaType.TEXT_XML).get(String.class));

  System.out.println(service.path("jaxrs").path("helloworld").accept (MediaType.TEXT_HTML).get(String.class));
  }
  private static URI getBaseURI() {
    return UriBuilder.fromUri("http://localhost:8080/jboss- jaxrs").build();
  }
}

Running the Java client

在本节中，我们将运行 Java 客户端。首先，运行客户端来测试只输出媒体类型 TEXT_PLAIN。客户端类中可接受的媒体类型必须与资源类中生成的 MIME 媒体类型相匹配。在 JAXRSClient 类中，仅取消注释接受 TEXT_PLAIN System.out 语句代码>媒体类型。取消注释 HelloWorldResource 类中的所有资源方法。然后右键单击 JAXRSClient.java 并选择 Run As | Java 应用程序，如下所示：

资源响应以 TEXT_PLAIN 媒体类型显示，如下所示：

可接受的媒体类型必须与资源类生成的媒体类型相匹配。如果根资源类中生成的 MIME 媒体类型未找到可接受的媒体类型，则会生成 com.sun.jersey.api.client.UniformInterfaceException 异常。例如，将可接受的媒体类型设置为 MediaType.TEXT_XML，方法是取消注释 JAXRSClient 类：

System.out.println(service.path("jaxrs").path("helloworld").accept (MediaType.TEXT_XML).get(String.class));

其他可接受的媒体类型的 System.out 语句可以保持未注释或注释掉，因为每个资源方法都独立于其他资源方法调用。在 HelloWorldResource 中，注释掉以下资源方法：

@GET
  @Produces("text/xml")
  public String getXMLMessage() {
    return "<?xml version=\"1.0\"?>" + "<hello> Hello JAX-RS" + "</hello>";
  }

并取消注释产生 MIME 媒体类型 application/xml 的资源方法：

@GET
  @Produces("application/xml")
  public String getXMLMessage() {
    return "<?xml version=\"1.0\"?>" + "<hello> Hello JAX-RS" + "</hello>";
  }

在对应用程序进行任何修改后重新部署 Maven 应用程序。要重新部署，请右键单击 Project Explorer 中的 pom.xml 并选择运行方式 | Maven 清理。随后，右键单击 pom.xml 并选择 Run As | Maven 安装。将 JAXRSClient.java 作为 Java 应用程序运行。 UniformInterfaceException 异常被生成。 406 (http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)，如下图：

可以通过取消注释产生 MIME 媒体类型 text/xml 的资源方法并注释掉产生 MIME 类型 application 的方法来消除该错误/xml ：

@GET
  @Produces("text/xml")
  public String getXMLMessage() {
    return "<?xml version=\"1.0\"?>" + "<hello> Hello JAX-RS" + "</hello>";
  }

如果 JAXRSClient.java 应用程序通过将可接受的媒体类型设置为 MediaType.TEXT_XML 并取消注释产生 text/xml 媒体类型的资源方法，生成以下输出：

当我们没有为根资源类使用客户端时，我们一次只能调用一个资源方法。生成与客户端中最可接受的媒体类型匹配的 MIME 媒体类型的资源方法被调用。可以在同一个 @Produces 注释实例中指定多个 MIME 媒体类型。如果多个媒体类型同样可接受，则首先选择按顺序指定的媒体类型。接下来，我们将从客户端调用所有资源方法，取消注释 HelloWorldResource 类中的所有资源方法，并取消注释 System.out< JAXRSClient 类中所有可接受的媒体类型的 /code> 语句。将 JAXRSClient 类作为 Java 应用程序运行。三种不同媒体类型中所有资源方法的响应得到输出，如下所示：

Creating a JSP client

在上一节中，我们使用Java 客户端作为根资源类。要将客户端与 Web 应用程序打包在一起，需要一个基于浏览器的客户端，例如 JSP 客户端。在本节中，我们将为根资源类创建一个 JSP 客户端。选择文件 | 新 | Other，并在 New 中选择网络 | JSP File并点击下一步，如下图：

在 New JSP File 向导中，选择 webapp 文件夹并指定 File name 为 jaxrsclient.jsp，如图这里。现在点击下一步。

选择 New JSP file (html)模板，点击完成。 jaxrsclient.jsp 文件被添加到 webapp 文件夹中，如下所示：

在 jaxrsclient.jsp JSP 客户端中，根资源类资源方法的调用与在 Java 客户端中一样. jaxrsclient.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="java.net.URI,javax.ws.rs.core.*,com.sun.jersey.api.client. *,com.sun.jersey.api.client.config.*"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/xml; charset=windows-1252" />
<title>JAX-RS Client</title>
</head>
<body>
    <%
        ClientConfig clientconfig = new DefaultClientConfig();
        Client client = Client.create(clientconfig);
        WebResource service = client.resource(UriBuilder.fromUri("http://localhost:8080/jboss-jaxrs").build()); out.println(service.path("jaxrs").path("helloworld").accept(MediaType.TEXT_PLAIN).get(String.class));
    out.println(service.path("jaxrs").path("helloworld").accept(MediaType.TEXT_XML).get(String.class));
    out.println(service.path("jaxrs").path("helloworld").accept(MediaType.TEXT_HTML).get(String.class));
    %>
</body>
</html>

Running the JSP client

在本节中，我们将运行 jaxrsclient.jsp 文件。在我们运行 JSP 客户端之前，我们需要在根资源类中稍作修改以输出一个 XML 字符串。修改getXMLMessage()方法如下：

@GET
  @Produces("text/xml")
  public String getXMLMessage() {
    return "&lt;?xml version=\"1.0\"?&gt;" + "&lt;hello&gt;Hello JAX-RS" + "&lt;/hello&gt;";
  }

如果尚未启动 WildFly 8.1.1，请启动。在根资源类中取消注释所有资源方法以及在 JSP 客户端中取消注释不同可接受媒体类型的所有 out.println 语句，清理并重新部署/重新安装 Maven 项目.在浏览器中调用 URL http://localhost:8080/jboss-jaxrs/jaxrsclient.jsp。所有资源方法都被调用，三种不同的媒体类型得到输出，如下所示：

Summary

在本章中，我们使用 Jersey JAX-RS RI 开发了一个 JAX-RS RESTful Web 服务。我们为 RESTful Web 服务创建了一个 Java EE Web 项目。首先，我们创建了一个具有三种资源方法的根资源类，以生成三种不同的媒体类型。我们编译、打包并部署了 jboss-jaxrs 应用程序到 WildFly 8.1。我们测试了根资源类以输出不同的媒体类型。随后，我们使用 Java 客户端调用根资源类方法。我们还使用 JSP 客户端来测试 RESTful Web 服务。

在下一章中，我们将讨论 Spring MVC 和 WildFly 8.1。

vlambda博客
学习文章列表