Spring Boot REST Data JPA
最后修改于 2020 年 7 月 13 日
在本教程中，我们将创建一个带有 Data JPA 的 Spring Boot RESTful 应用程序。
Spring 是一个流行的 Java 应用程序框架，用于创建企业应用程序。Spring Boot 是 Spring 框架演进的下一步。它有助于以最小的努力创建独立的、生产级别的 Spring 应用程序。它不再使用 XML 配置，并实现了约定优于配置原则。
H2 是一个 Java 开源关系数据库管理系统。它可以以客户端-服务器模式运行，也可以嵌入到 Java 应用程序中。H2 易于部署和安装，并且占用空间小。
Spring Data JPA 是 Spring Data 项目伞的一部分，它使实现基于 JPA 的存储库更加容易。Spring Data JPA 使用 JPA 将数据存储在关系数据库中。它可以根据存储库接口，在运行时自动创建存储库实现。
RESTFul 应用程序遵循 REST 架构风格，该风格用于设计网络应用程序。RESTful 应用程序生成执行资源上的 CRUD（创建/读取/更新/删除）操作的 HTTP 请求。RESTFul 应用程序通常以 JSON 或 XML 格式返回数据。
应用程序
下面的应用程序是一个 Spring Boot RESTful 应用程序，它使用 Spring Data JPA 从 H2 数据库以 JSON 格式返回数据。
$ tree
.
├── pom.xml
└── src
├── main
│ ├── java
│ │ └── com
│ │ └── zetcode
│ │ ├── Application.java
│ │ ├── bean
│ │ │ └── City.java
│ │ ├── controller
│ │ │ └── MyController.java
│ │ ├── repository
│ │ │ └── CityRepository.java
│ │ └── service
│ │ ├── CityService.java
│ │ └── ICityService.java
│ └── resources
│ ├── application.yml
│ └── import.sql
└── test
└── java
这是项目结构。
<?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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.zetcode</groupId>
<artifactId>SpringBootRestDataJPA</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.3.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
这是 Maven 构建文件。h2 依赖项包括 H2 数据库驱动程序。
Spring Boot starters 是一组方便的依赖项描述符，它们大大简化了 Maven 配置。spring-boot-starter-parent 具有 Spring Boot 应用程序的一些通用配置。spring-boot-starter-web 是一个用于使用 Spring MVC 构建 Web 应用程序的 starter。它使用 Tomcat 作为默认的嵌入式容器。spring-boot-starter-data-jpa 是一个用于将 Spring Data JPA 与 Hibernate 结合使用的 starter。
spring-boot-maven-plugin 为 Maven 提供了 Spring Boot 支持，使我们能够打包可执行的 JAR 或 WAR 归档文件。它的 spring-boot:run 目标运行 Spring Boot 应用程序。
server:
port: 8086
context-path: /rest
spring:
main:
banner-mode: "off"
jpa:
database: h2
hibernate:
dialect: org.hibernate.dialect.H2Dialect
ddl-auto: create-drop
logging:
level:
org:
springframework: ERROR
在 application.yml 文件中，我们编写 Spring Boot 应用程序的各种配置设置。port 设置服务器端口，context-path 设置上下文路径（应用程序名称）。完成这些设置后，我们就可以在 localhost:8086/rest/ 访问该应用程序了。使用 banner-mode 属性，我们可以关闭 Spring 启动横幅。
JPA database 值指定要操作的目标数据库。在本例中，我们指定了 Hibernate 方言 org.hibernate.dialect.H2Dialect。ddl-auto 是数据定义语言模式；create-drop 选项会自动创建和删除数据库模式。
H2 数据库在内存中运行。此外，我们将 Spring 框架的日志级别设置为 ERROR。application.yml 文件位于 src/main/resources 目录中。
package com.zetcode.bean;
import java.util.Objects;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "cities")
public class City {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
private int population;
public City() {
}
public City(String name, int population) {
this.name = name;
this.population = population;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPopulation() {
return population;
}
public void setPopulation(int population) {
this.population = population;
}
@Override
public int hashCode() {
int hash = 7;
hash = 13 * hash + Objects.hashCode(this.id);
hash = 13 * hash + Objects.hashCode(this.name);
hash = 13 * hash + this.population;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final City other = (City) obj;
if (this.population != other.population) {
return false;
}
if (!Objects.equals(this.name, other.name)) {
return false;
}
return Objects.equals(this.id, other.id);
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("City{id=").append(id).append(", name=")
.append(name).append(", population=")
.append(population).append("}");
return builder.toString();
}
}
这是 City 实体。每个实体必须至少定义两个注解：@Entity 和 @Id。之前，我们将 ddl-auto 选项设置为 create-drop，这意味着 Hibernate 将根据此实体创建表模式。
@Entity
@Table(name = "cities")
public class City {
@Entity 注解指定该类是一个实体，并映射到一个数据库表。@Table 注解指定用于映射的数据库表的名称。
@Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id;
@Id 注解指定了实体的标识符，@GeneratedValue 提供了为主键值生成策略的规范。
INSERT INTO cities(name, population) VALUES('Bratislava', 432000);
INSERT INTO cities(name, population) VALUES('Budapest', 1759000);
INSERT INTO cities(name, population) VALUES('Prague', 1280000);
INSERT INTO cities(name, population) VALUES('Warsaw', 1748000);
INSERT INTO cities(name, population) VALUES('Los Angeles', 3971000);
INSERT INTO cities(name, population) VALUES('New York', 8550000);
INSERT INTO cities(name, population) VALUES('Edinburgh', 464000);
INSERT INTO cities(name, population) VALUES('Berlin', 3671000);
模式由 Hibernate 自动创建；之后，执行 import.sql 文件以填充表数据。
package com.zetcode.repository;
import com.zetcode.bean.City;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface CityRepository extends CrudRepository<City, Long> {
}
通过扩展 Spring 的 CrudRepository，我们将拥有一些数据存储库的已实现方法，包括 findAll 和 findOne。这样我们就节省了很多样板代码。
package com.zetcode.service;
import com.zetcode.bean.City;
import java.util.List;
public interface ICityService {
public List<City> findAll();
public City findById(Long id);
}
ICityService 提供了获取所有城市和从数据源获取城市 ID 的合同方法。
package com.zetcode.service;
import com.zetcode.bean.City;
import com.zetcode.repository.CityRepository;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class CityService implements ICityService {
@Autowired
private CityRepository repository;
@Override
public List<City> findAll() {
List<City> cities = (List<City>) repository.findAll();
return cities;
}
@Override
public City findById(Long id) {
City city = repository.findOne(id);
return city;
}
}
CityService 包含 findAll 和 findById 方法的实现。我们使用存储库从数据库检索数据。
@Autowired private CityRepository repository;
CityRepository 被注入。
List<City> cities = (List<City>) repository.findAll();
存储库的 findAll 方法返回城市列表。
City city = repository.findOne(id);
存储库的 findOne 方法返回由其 ID 标识的一个城市对象。
package com.zetcode.controller;
import com.zetcode.bean.City;
import com.zetcode.service.ICityService;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@Autowired
ICityService cityService;
@RequestMapping("/cities")
public List<City> findCities() {
List<City> cities = (List<City>) cityService.findAll();
return cities;
}
@RequestMapping("/cities/{userId}")
public City findCity(@PathVariable Long userId) {
City city = cityService.findById(userId);
return city;
}
}
这是 Spring Boot RESTful 应用程序的控制器类。@RestController 注解创建了一个 RESTful 控制器。传统的 MVC 控制器使用 ModelAndView，而 RESTful 控制器直接返回对象，并且对象数据直接写入 HTTP 响应（通常是 JSON 或 XML 格式）。
@Autowired private ICityService cityService;
我们将 ICityService 注入到 countryService 字段中。
@RequestMapping("/cities")
public List<City> findCities() {
List<City> cities = (List<City>) cityService.findAll();
return cities;
}
我们将 /cities 路径的请求映射到控制器的 findCities 方法。默认请求是 GET 请求。该方法返回找到的所有城市的列表。
@RequestMapping("/cities/{userId}")
public City findCity(@PathVariable Long userId) {
City city = cityService.findById(userId);
return city;
}
在第二个方法中，我们返回一个特定的城市。URL 路径包含要检索的城市的 ID；我们使用 @PathVariable 注解将 URL 模板变量绑定到 cityId 参数。
我们不需要手动将 City 域对象转换为 JSON。由于 Jackson 2 在类路径上（通过 spring-boot-starter-web 包含），Spring 会自动选择 MappingJackson2HttpMessageConverter 来将 City 实例转换为 JSON。
package com.zetcode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Application 设置了 Spring Boot 应用程序。@SpringBootApplication 启用了自动配置和组件扫描。
$ mvn spring-boot:run
使用 mvn spring-boot:run 命令，我们运行该应用程序。该应用程序部署在嵌入式 Tomcat 服务器上。
$ curl localhost:8086/rest/cities
[{"id":1,"name":"Bratislava","population":432000},
{"id":2,"name":"Budapest","population":1759000},
{"id":3,"name":"Prague","population":1280000},
{"id":4,"name":"Warsaw","population":1748000},
{"id":5,"name":"Los Angeles","population":3971000},
{"id":6,"name":"New York","population":8550000},
{"id":7,"name":"Edinburgh","population":464000},
{"id":8,"name":"Berlin","population":3671000}]
使用 curl 命令，我们可以获取所有城市。
$ curl localhost:8086/rest/cities/1
{"id":1,"name":"Bratislava","population":432000}
这里我们通过 ID 获取一个城市。
在本教程中，我们已将数据以 JSON 格式从 Spring Boot RESTful 应用程序返回给客户端。我们使用 Spring Data JPA 从 H2 数据库检索数据。