在这篇文章中，我们将逐步学习如何使用Jersey 2.26与Spring boot 2.0.5 RELEASE、JPA/Hibernate 5和MySQL作为数据库的集成来开发CRUD REST APIs。
Jersey RESTful Web服务框架是开源的、具有生产质量的、在Java中开发RESTful Web服务的框架，它提供对JAX-RS API的支持，并作为JAX-RS（JSR 311 & JSR 339）参考实现。

Spring boot使用spring-boot-starter-jersey启动依赖，为Jersey与spring boot应用程序的集成提供了支持。

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jersey</artifactId>
</dependency>

让我们一步一步地创建一个Spring Boot Jersey CRUD RESTful APIs项目。

1. 我们要建立什么？

我们正在开发一个CRUD REST APIs，使用Jersey 2.26与Spring boot 2.0.5 RELEASE、JPA/Hibernate 5和MySQL作为数据库的整合。

2. 使用的工具和技术

Spring Boot - 2.0.4.RELEASE
JDK - 1.8或更高版本
Spring Framework - 5.0.8 RELEASE
Hibernate - 5.2.17.Final
Maven - 3.2以上
Spring Data JPA - 2.0.10 RELEASE
IDE - Eclipse或Spring Tool Suite (STS)
mysql - 5.1.47
Jersey - 2.26

3. 创建和导入一个项目

有很多方法可以创建Spring Boot应用程序。最简单的方法是在http://start.spring.io/使用Spring Initializr，它是一个在线Spring Boot应用程序生成器。

看上面的图，我们指定了以下细节。

Generate：Maven项目
Java版本：1.8（默认）。
Spring Boot:2.0.6
Group：net.guards.springboot2
Artifact: springboot-jersey-rest-crud-jpa
Name: springboot-jersey-rest-crud-jpa
Description: 简单用户管理应用的Rest API
Package Name：net.guards.springboot2
Packaging: jar (这是默认值)
Dependencies:Jersey, JPA, MySQL
一旦，所有的细节被输入，点击生成项目按钮将生成一个spring boot项目并下载。接下来，解压下载的压缩文件并将其导入你最喜欢的IDE。

4. 包装结构

以下是供你参考的打包结构 -

the pom.xml File

<?xmlversion="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/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>net.guides.springboot2</groupId>
 <artifactId>springboot-jersey-rest-crud-jpa</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>
 <name>springboot-jersey-rest-crud-jpa</name>
 <description>Demo project for Spring Boot</description>
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.0.5.RELEASE</version>
  <relativePath /> <!-- lookup parent from repository -->
 </parent>
 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  <java.version>1.8</java.version>
 </properties>
 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jersey</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <scope>runtime</scope>
  </dependency>
 </dependencies>
 <build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
  </plugins>
 </build>
</project>

SpringBootCrudRestApplication.java

这个spring boot应用程序有一个名为SpringBootCrudRestApplication.java的入口点Java类，其中有*public static void main(String[] args)*方法，你可以运行它来启动应用程序。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringBootCrudRestApplication {
 public static void main(String[] args) {
  SpringApplication.run(SpringBootCrudRestApplication.class, args);
 }
}

@SpringBootApplication是一个方便的注解，增加了以下所有内容。

@Configuration将该类标记为应用程序上下文的bean定义的来源。
@EnableAutoConfiguration告诉Spring Boot开始根据classpath设置、其他bean和各种属性设置来添加bean。
通常你会为Spring MVC应用添加@EnableWebMvc，但Spring Boot在classpath上看到spring-webmvc时，会自动添加它。这标志着该应用是一个Web应用，并激活了一些关键行为，如设置DispatcherServlet。
@ComponentScan告诉Spring寻找hello包中的其他组件、配置和服务，使其能够找到控制器。
main()方法使用Spring Boot的SpringApplication.run()方法来启动一个应用程序。

5. 配置MySQL数据库

配置application.properties以连接到你的MySQL数据库。让我们打开一个application.properties文件，并在其中添加以下数据库配置。

spring.datasource.url = jdbc:mysql://localhost:3306/users_database?useSSL=false
spring.datasource.username = root
spring.datasource.password = root
## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update

根据你的环境改变上述配置，如JDBC URL、用户名和密码。

6. 创建泽西岛资源 - UserResource.java

package net.guides.springboot2.springbootjerseyrestcrudjpa.controller;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.validation.Valid;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import net.guides.springboot2.springbootjerseyrestcrudjpa.exception.ResourceNotFoundException;
import net.guides.springboot2.springbootjerseyrestcrudjpa.model.User;
import net.guides.springboot2.springbootjerseyrestcrudjpa.repository.UserRepository;
@Component
@Path("/api/v1")
public class UserResource {
 @Autowired
 private UserRepository userRepository;
 @GET
 @Produces("application/json")
 @Path("/users")
 public List<User> getAllUsers() {
  return userRepository.findAll();
 }
 @GET
 @Produces("application/json")
 @Path("/users/{id}")
 public ResponseEntity<User> getUserById(@PathParam(value = "id") Long userId) throws ResourceNotFoundException {
  User user = userRepository.findById(userId)
    .orElseThrow(() -> new ResourceNotFoundException("User not found :: " + userId));
  return ResponseEntity.ok().body(user);
 }
 @POST
 @Produces("application/json")
 @Consumes("application/json")
 @Path("/users")
 @PostMapping("/users")
 public User createUser(User user) {
  return userRepository.save(user);
 }
 @PUT
 @Consumes("application/json")
 @Path("/users/{id}}")
 public ResponseEntity<User> updateUser(@PathParam(value = "id") Long userId,
   @Valid @RequestBody User userDetails) throws ResourceNotFoundException {
  User user = userRepository.findById(userId)
    .orElseThrow(() -> new ResourceNotFoundException("User not found :: " + userId));
  user.setEmailId(userDetails.getEmailId());
  user.setLastName(userDetails.getLastName());
  user.setFirstName(userDetails.getFirstName());
  final User updatedUser = userRepository.save(user);
  return ResponseEntity.ok(updatedUser);
 }
 @DELETE
 @Path("/users/{id}")
 public Map<String, Boolean> deleteUser(@PathParam(value = "id") Long userId) throws ResourceNotFoundException {
  User user = userRepository.findById(userId)
    .orElseThrow(() -> new ResourceNotFoundException("User not found :: " + userId));
  userRepository.delete(user);
  Map<String, Boolean> response = new HashMap<>();
  response.put("deleted", Boolean.TRUE);
  return response;
 }
}

我们已经创建了一个UserResource类，并使用了JAX-RS注解。
@Path用于识别资源类或类方法将为请求服务的URI路径（相对）。

@PathParam用于将URI模板参数的值或包含模板参数的路径段与资源方法参数、资源类字段或资源类豆类属性绑定。除非使用@Encoded注解禁用，否则该值会被URL解码。
@GET表示注解的方法处理HTTP GET请求。

@POST表示该注解方法处理HTTP POST请求。
@PUT表示该注解方法处理HTTP PUT请求。

@DELETE表示被注解的方法处理HTTP DELETE请求。
@Produces 定义了资源方法可以产生的媒体类型。

@Consumes 定义了该资源方法可以接受的媒体类型。
你可以在JAX-RS教程中找到所有的JAX-RS注解。

你可能已经注意到，我们用 @Component 注解了 UserResource，这是 Spring 的注解，并将其注册为一个 Bean。我们这样做是为了让Spring的DI能够注入UserRepository类。
当使用Jersey创建REST API时，资源的命名标准应该是实体名称的后缀为 "资源 "字符串，例如UserResource, EmployeeResource。

7. 创建一个JerseyConfiguration类

我们创建了一个JerseyConfiguration类，它扩展了包org.glassfish.jersey.server中的ResourceConfig，用来配置网络应用。我们使用resister方法注册了UserResource。@ApplicationPath标识了作为所有资源基础URI的应用路径。

package net.guides.springboot2.springbootjerseyrestcrudjpa.config;
import javax.ws.rs.ApplicationPath;
import org.glassfish.jersey.server.ResourceConfig;
import org.springframework.stereotype.Component;
import net.guides.springboot2.springbootjerseyrestcrudjpa.controller.UserResource;
@Component
@ApplicationPath("/boot-jersey")
public class JerseyConfiguration extends ResourceConfig {
 public JerseyConfiguration() {
  register(UserResource.class);
 }
}

8. 创建一个名为User.java的JPA实体。

package net.guides.springboot2.springbootjerseyrestcrudjpa.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "table_users")
public class User {
 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private long id;
 
 @Column(name = "first_name", nullable = false)
 private String firstName;
 
 @Column(name = "last_name", nullable = false)
 private String lastName;
 @Column(name = "email_address", nullable = false)
 private String emailId;
 public long getId() {
  return id;
 }
 public void setId(long id) {
  this.id = id;
 }
 public String getFirstName() {
  return firstName;
 }
 public void setFirstName(String firstName) {
  this.firstName = firstName;
 }
 public String getLastName() {
  return lastName;
 }
 public void setLastName(String lastName) {
  this.lastName = lastName;
 }
 public String getEmailId() {
  return emailId;
 }
 public void setEmailId(String emailId) {
  this.emailId = emailId;
 }
}

实现审计请参考Spring Data JPA Auditing with Spring Boot 2 and MySQL Example您可以使用Spring Boot 2 Logging SLF4j Logback和LOG4j2实例实现日志记录您可以使用Spring Boot 2 Exception Handling for REST APIs实现异常处理您可以使用Spring Boot CRUD REST APIs验证实例实现自定义bean验证

9. 创建Spring Data JPA存储库 - UserRepository.java

package net.guides.springboot2.springbootjerseyrestcrudjpa.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import net.guides.springboot2.springbootjerseyrestcrudjpa.model.User;
@Repository
public interface UserRepository extends JpaRepository<User, Long>{
}

10. 创建ResourceNotFoundException.java类

package net.guides.springboot2.springbootjerseyrestcrudjpa.exception;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends Exception{
 private static final long serialVersionUID = 1L;
 public ResourceNotFoundException(String message){
     super(message);
    }
}