原文： http://zetcode.com/springboot/jersey/

Spring Boot Jersey 教程展示了如何在 Spring Boot 应用中使用 Jersey 建立一个简单的 RESTFul 应用。 Jersey 是使用@RestController创建的 Spring RESTFul 应用的替代方案。

Spring 是用于创建企业应用的流行 Java 应用框架。 Spring Boot 是 Spring 框架发展的下一步。 它有助于以最小的努力创建独立的，基于生产级的 Spring 应用。 它提倡在 XML 配置上使用约定而不是配置原则。

RESTFul 应用

RESTFul 应用遵循 REST 架构样式，该样式用于设计网络应用。 RESTful 应用生成对资源执行 CRUD（创建/读取/更新/删除）操作的 HTTP 请求。 RESTFul 应用通常以 JSON 或 XML 格式返回数据。

JAX-RS

RESTful Web 服务的 Java API（JAX-RS）是 Java 编程语言 API 规范，它提供了根据代表性状态传输（REST）架构模式创建 Web 服务的支持。 JAX-RS 使用注解来简化 Web 服务客户端和端点的开发和部署。 JAX-RS 是 Java EE 的正式组成部分。

Jersey

Jersey 是用于用 Java 开发 RESTful Web 服务的开源框架。 它是 RESTful Web 服务 Java API（JAX-RS）规范的参考实现。

Spring Boot Jersey 示例

以下应用是使用 Jersey 创建的 simpe Spring Boot RESTful 应用。

  1. $ tree
  2. .
  3. ├── pom.xml
  4. └── src
  5.     ├── main
  6.     │   ├── java
  7.     │   │   └── com
  8.     │   │       └── zetcode
  9.     │   │           ├── Application.java
  10.     │   │           ├── config
  11.     │   │           │   └── JerseyConfig.java
  12.     │   │           └── endpoint
  13.     │   │               ├── HelloEndpoint.java
  14.     │   │               └── ReverseReturnEndpoint.java
  15.     │   └── resources
  16.     └── test
  17.         └── java
  18.             └── com
  19.                 └── zetcode
  20.                     └── ApplicationTests.java

这是项目结构。

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" 
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
  5. http://maven.apache.org/xsd/maven-4.0.0.xsd">
  7.     <modelVersion>4.0.0</modelVersion>
  8.     <groupId>com.zetcode</groupId>
  9.     <artifactId>SpringBootJersey</artifactId>
  10.     <version>1.0-SNAPSHOT</version>
  11.     <packaging>jar</packaging>
  12.     <properties>
  13.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  14.         <maven.compiler.source>1.8</maven.compiler.source>
  15.         <maven.compiler.target>1.8</maven.compiler.target>
  16.     </properties>
  18.     <parent>
  19.         <groupId>org.springframework.boot</groupId>
  20.         <artifactId>spring-boot-starter-parent</artifactId>
  21.         <version>1.5.9.RELEASE</version>
  22.     </parent>   
  24.     <dependencies>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-jersey</artifactId>
  29.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-test</artifactId>
  34.             <scope>test</scope>
  35.         </dependency>          
  37.     </dependencies>  
  39.     <build>
  40.         <plugins>
  41.             <plugin>
  42.                 <groupId>org.springframework.boot</groupId>
  43.                 <artifactId>spring-boot-maven-plugin</artifactId>
  44.             </plugin>            
  45.         </plugins>
  46.     </build>        
  48. </project>

这是 Maven 构建文件。 Spring Boot 启动器是一组方便的依赖项描述符，可以极大地简化 Maven 配置。 spring-boot-starter-parent具有 Spring Boot 应用的一些常用配置。 spring-boot-starter-jersey是使用 JAX-RS 和 Jersey 构建 RESTful Web 应用的入门。 它是spring-boot-starter-web的替代方法。 spring-boot-starter-test是使用包含 JUnit，Hamcrest 和 Mockito 的库测试 Spring Boot 应用的入门程序。

spring-boot-maven-plugin在 Maven 中提供了 Spring Boot 支持，使我们可以打包可执行的 JAR 或 WAR 档案。 它的spring-boot:run目标运行 Spring Boot 应用。

application.yml

  1. server:
  2.     port: 8086
  3.     context-path: /api
  5. spring: 
  6.     main:
  7.         banner-mode: "off"     
  9. logging: 
  10.     level: 
  11.         org: 
  12.             springframework: ERROR

在application.yml文件中，我们编写了 Spring Boot 应用的各种配置设置。 我们设置端口和上下文路径。 使用banner-mode属性，我们可以关闭 Spring 横幅。

我们将 spring 框架的日志记录级别设置为ERROR。 在application.yml文件位于中src/main/resources目录。

JerseyConfig.java

  1. package com.zetcode.config;
  3. import com.zetcode.endpoint.HelloService;
  4. import com.zetcode.endpoint.ReverseService;
  5. import org.glassfish.jersey.server.ResourceConfig;
  6. import org.springframework.context.annotation.Configuration;
  8. @Configuration
  9. public class JerseyConfig extends ResourceConfig {
  11.     public JerseyConfig() {
  13.         register(HelloService.class);
  14.         register(ReverseService.class);
  15.     }
  16. }

JerseyConfig注册两个服务类别。

HelloService.java

  1. package com.zetcode.service;
  3. import javax.ws.rs.GET;
  4. import javax.ws.rs.Path;
  5. import javax.ws.rs.Produces;
  6. import org.springframework.stereotype.Service;
  8. @Service
  9. @Path("/hello")
  10. public class HelloService {
  12.     @GET
  13.     @Produces("text/plain")
  14.     public String hello() {
  15.         return "Hello from Spring";
  16.     }
  17. }

这是HelloService。 @Path注解定义了服务类将响应的 URL。 Spring 的@Service也注解了HelloService以进行自动检测。 我们的服务方法仅返回"Hello from Spring"消息。

HelloService.java

  1. package com.zetcode.service;
  3. import javax.validation.constraints.NotNull;
  4. import javax.ws.rs.GET;
  5. import javax.ws.rs.Path;
  6. import javax.ws.rs.Produces;
  7. import javax.ws.rs.QueryParam;
  8. import org.springframework.stereotype.Service;
  10. @Service
  11. @Path("/reverse")
  12. public class ReverseService {
  14.     @GET
  15.     @Produces("text/plain")
  16.     public String reverse(@QueryParam("data") @NotNull String data) {
  17.         return new StringBuilder(data).reverse().toString();
  18.     }
  19. }

reverse()服务方法返回一个反向的字符串。 它接受一个参数，不能为 null。 @QueryParam将 HTTP 查询参数的值绑定到资源方法参数。

ApplicationTests.java

  1. package com.zetcode;
  3. import static org.assertj.core.api.Assertions.assertThat;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.test.context.SpringBootTest;
  8. import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
  9. import org.springframework.boot.test.web.client.TestRestTemplate;
  10. import org.springframework.http.HttpStatus;
  11. import org.springframework.http.ResponseEntity;
  12. import org.springframework.test.context.junit4.SpringRunner;
  14. @RunWith(SpringRunner.class)
  15. @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  16. public class ApplicationTests {
  18.     @Autowired
  19.     private TestRestTemplate restTemplate;
  21.     @Test
  22.     public void hello() {
  23.         ResponseEntity<String> entity = this.restTemplate.getForEntity("/hello",
  24.                 String.class);
  25.         assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
  26.         assertThat(entity.getBody()).isEqualTo("Hello from Spring");
  27.     }
  29.     @Test
  30.     public void reverse() {
  31.         ResponseEntity<String> entity = this.restTemplate
  32.                 .getForEntity("/reverse?data=regit", String.class);
  33.         assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
  34.         assertThat(entity.getBody()).isEqualTo("tiger");
  35.     }
  37.     @Test
  38.     public void validation() {
  39.         ResponseEntity<String> entity = this.restTemplate.getForEntity("/reverse",
  40.                 String.class);
  41.         assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
  42.     }
  43. }

在ApplicationTests中，我们测试了两个端点。

Application.java

  1. package com.zetcode;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class Application {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(Application.class, args);
  11.     }
  12. }

Application设置 Spring Boot 应用。 @SpringBootApplication启用自动配置和组件扫描。

  1. $ mvn spring-boot:run

使用mvn spring-boot:run命令，运行应用。 该应用部署在嵌入式 Tomcat 服务器上。

  1. $ curl localhost:8086/api/hello
  2. Hello from Spring

使用curl命令，我们连接到 hello 端点。

  1. $ curl localhost:8086/api/reverse?data=summer
  2. remmus

夏天的字符是相反的。

在本教程中，我们使用 Jersey 借助 Spring Boot 创建了一个简单的 RESTFul 应用，它是 JAX-RS 规范的参考实现。 您可能也对相关教程感兴趣：