Spring Boot REST Data JPA 教程

原文： http://zetcode.com/articles/springbootrestdatajpa/

在本教程中，我们将使用 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 的 Spring Boot 支持，使我们能够打包可执行的 JAR 或 WAR 档案。它的spring-boot:run目标运行 Spring Boot 应用。

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 数据库检索数据。您可能也对相关教程感兴趣：

Spring Boot CSV 教程
Spring Boot Data JPA @Query教程
Spring Boot Data JPA @NamedQuery教程
在 Spring Boot 中加载资源
Spring Boot H2 REST 教程
Spring Boot Thymeleaf 教程
Spring Boot Mustache 教程
Spring Boot Swing 集成教程
Spring Web 应用介绍
Spring Boot RESTFul 应用

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

41.md

41.md

Spring Boot REST Data JPA 教程

应用

Files

41.md

Latest commit

History

41.md

File metadata and controls

Spring Boot REST Data JPA 教程

应用