在本教程中,我们将使用 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
这是项目结构。
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/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 启动器是一组方便的依赖项描述符,可以极大地简化 Maven 配置。 spring-boot-starter-parent
具有 Spring Boot 应用的一些常用配置。 spring-boot-starter-web
是使用 Spring MVC 构建 Web 应用的入门工具。 它使用 Tomcat 作为默认的嵌入式容器。 spring-boot-starter-data-jpa
是将 Spring Data JPA 与 Hibernate 结合使用的入门工具。
在spring-boot-maven-plugin
提供了 Maven 的春季启动支持,使我们能够打包可执行的 JAR 或 WAR 档案。 它的spring-boot:run
目标运行春季启动应用。
application.yml
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
目录。
City.java
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
提供规范主键值的生成策略。
import.sql
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
文件以将数据填充到表中。
CityRepository.java
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()
。 这样,我们节省了大量样板代码。
ICityService.java
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 从数据源获取城市的合同方法。
CityService.java
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 标识的城市对象。
MyController.java
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 控制器仅返回对象,并且对象数据通常以 JSON 或 XML 格式直接写入 HTTP 响应(通常)。
@Autowired
private ICityService cityService;
我们在countryService
字段中插入ICityService
。
@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。
Application.java
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 标识的城市。
在本教程中,我们已从 Spring Boot RESTful 应用以 JSON 格式将数据返回给客户端。 我们使用 Spring Data JPA 从 H2 数据库检索数据。 (/articles/springbootrestsimple/)