Skip to content

9. 分层架构与数据访问

之前的示例把数据存储在内存中。真实的应用程序把数据存储在数据库中,并被组织成多个层 (参见引言中的图):

  • Web 层(控制器、视图):读取请求,调用业务层,选择视图;
  • 业务层:业务规则;
  • DAO ([Data Access Object])层:数据库查询。

每一层只了解它下面的那一层,并且尽可能少地了解其细节:Web 层不知道 SQL,业务层不知道 HTML。这种分离使每一层都更容易理解、测试和演进。示例 28 将其应用于管理一个人员列表:这是案例研究中医生和客户管理的缩小版。

在 [Java] 中,数据库访问被组织成多个层次:

  • [JDBC] ([Java Database Connectivity])是 [Java] 向数据库发送 SQL 命令的标准接口。每个数据库管理系统都提供一个 驱动程序 [JDBC]:对于 [MySQL],就是库 [mysql-connector-j]。打开连接开销很大:[Spring Boot] 使用连接池 ([HikariCP]),它保持少量连接处于打开状态,并把它们借给请求使用;
  • [JPA] ([Jakarta Persistence API])是 [Java] 中 ORM([Object-Relational Mapper])的标准:它把 [Java] 类(实体)映射到数据库表,并把读取到的行转换为对象。[JPA] 只是一个标准,由接口和注解组成;实现它的 ORM 在这里是 [Hibernate];
  • [Spring Data JPA] 在此之上再添加一层:你只需要声明一个 DAO 接口,应用程序启动时 [Spring Data JPA] 会自己编写实现,包括从方法名推导出的查询。

所有这些都由 [spring-boot-starter-data-jpa] 启动器提供。

9.1. 示例 28:三层架构的人员管理系统

28-layers/
├── database/
│   └── dbpersons.sql
├── src/
│   └── main/
│       ├── java/
│       │   └── example28/
│       │       ├── config/
│       │       │   └── WebConfig.java
│       │       ├── controllers/
│       │       │   └── PersonsController.java
│       │       ├── dao/
│       │       │   └── PersonsDao.java
│       │       ├── entities/
│       │       │   └── Person.java
│       │       ├── business/
│       │       │   ├── PersonData.java
│       │       │   ├── BusinessException.java
│       │       │   └── PersonsBusiness.java
│       │       ├── models/
│       │       │   └── PersonForm.java
│       │       └── Example28Application.java
│       └── resources/
│           ├── static/
│           │   ├── css/
│           │   │   └── styles.css
│           │   └── js/
│           │       └── app.js
│           ├── templates/
│           │   ├── fragments/
│           │   │   ├── field.html
│           │   │   └── confirmation.html
│           │   ├── persons/
│           │   │   ├── form.html
│           │   │   └── list.html
│           │   └── layout.html
│           ├── application.properties
│           └── messages.properties
└── pom.xml

9.1.1. 数据库

数据库 [dbpersons] 由一个 SQL 脚本创建。使用 [Laragon] 时,你可以运行它,例如在 [HeidiSQL] 工具中(文件菜单 / 运行 SQL 文件),或者在示例文件夹中通过命令行运行:

mysql -u root < database/dbpersons.sql

[database/dbpersons.sql] 文件:

-- database of example 28: a single table, [persons]
-- the script is written in UTF-8
SET NAMES utf8mb4;
DROP DATABASE IF EXISTS dbpersons;
CREATE DATABASE dbpersons CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE dbpersons;

CREATE TABLE persons (
  id INT NOT NULL AUTO_INCREMENT,
  -- the version of the row, increased by JPA at each modification
  version INT NOT NULL DEFAULT 0,
  first_name VARCHAR(30) NOT NULL,
  last_name VARCHAR(30) NOT NULL,
  age INT NOT NULL,
  PRIMARY KEY (id),
  -- two persons cannot have the same first and last names
  CONSTRAINT unq_persons_first_name_last_name UNIQUE (first_name, last_name)
) ENGINE = InnoDB;

INSERT INTO persons (first_name, last_name, age) VALUES
  ('Marie', 'Pélissier', 42),
  ('Jacques', 'Bromard', 35),
  ('Philippe', 'Jandot', 58);
  • 第 3 行:脚本以 UTF-8 编写;这一点要告知服务器,以便数据中的重音字符([Pélissier])保持完好;
  • 第 5 行:字符集 [utf8mb4] 接受所有字符(重音字符、表情符号等)。排序规则 [utf8mb4_unicode_ci] 在比较字符串时不区分大小写和重音:对于 [MySQL],[pelissier] 与 [Pélissier] 是相等的;
  • 第 11 行:版本号,每次修改该行时递增(参见下文的“乐观锁”);
  • 第 17 行:一个具名唯一性约束:数据库不允许两个人拥有相同的名和姓。该名称将用于识别错误。

9.1.2. 配置

文件 [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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>course.springmvc</groupId>
    <artifactId>examples</artifactId>
    <version>1.0</version>
  </parent>
  <artifactId>example28</artifactId>

  <dependencies>
    <!-- Thymeleaf 视图 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- 验证(Bean Validation、Hibernate Validator) -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <!-- Spring Data JPA(Hibernate)和 MySQL JDBC 驱动程序 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.mysql</groupId>
      <artifactId>mysql-connector-j</artifactId>
      <scope>runtime</scope>
    </dependency>
  </dependencies>
</project>
  • 第 20–23 行:数据验证(参见第 3 章);
  • 第 25–28 行:[Spring Data JPA],以及 [Hibernate]、[HikariCP]和 [Spring] 的事务管理;
  • 第 29–33 行:用于 [JDBC] [MySQL] 的驱动程序。 [runtime] 作用域表明应用程序代码不会直接使用它(它只认识 [JPA]):驱动程序只在运行时才需要。它同样适用于 [MariaDB]。

文件 [application.properties]:

# 服务器的监听端口(默认为 8080)
server.port=5000
# Spring Boot 的错误响应不包含调用栈
spring.web.error.include-stacktrace=never
# 会话(承载闪现属性)仅通过 Cookie 来跟踪
server.servlet.session.tracking-modes=cookie

# 到数据库的连接:JDBC URL、用户、密码(Laragon 的默认值)
spring.datasource.url=jdbc:mysql://localhost:3306/dbpersons
spring.datasource.username=root
spring.datasource.password=
# Hibernate 既不创建也不修改表:这是 SQL 脚本的职责
spring.jpa.hibernate.ddl-auto=none
# 在构建视图期间,不保持与数据库的连接处于打开状态
spring.jpa.open-in-view=false
# true:发送到数据库的 SQL 语句会显示在控制台中
spring.jpa.show-sql=false
  • 第 6 行:成功消息作为闪现属性发送(参见示例 20),存储在会话中:只需会话 Cookie 就足以找回它,而无需把会话 ID 添加到 URL 中;
  • 第 9–11 行:与数据库的连接,用于 数据源 ([DataSource]),它由 [Spring Boot] 使用 [HikariCP] 创建:包括 [JDBC] URL(驱动程序、服务器、端口、数据库)、用户名和密码。这些是 [Laragon] 的默认值(用户 [root],无密码)。无需指定数据库类型(及其版本):[Hibernate] 在首次连接时向服务器请求这些信息,并相应地调整它所生成的 SQL;
  • 第 13 行:[Hibernate] 能够根据实体创建或修改表;这里禁止这样做([none]):数据库由 SQL 脚本创建,并以它为准;
  • 第 15 行:默认情况下,[Spring Boot] 会让 [JPA] 会话(及其与数据库的连接)一直保持打开,直到视图完全生成([Open Session In View]):这样视图就可能在用户不知情的情况下触发 SQL 查询。这里禁用了这种行为:所有读取都由业务层在视图之前完成。如果没有指定该属性,[Spring Boot] 会在启动时用一条警告报告这一点([spring.jpa.open-in-view is enabled by default...]);
  • 第 17 行:[true] 会在控制台中显示由 [Hibernate] 发送的每条 SQL 命令(参见下面的运行部分)。

文件 [messages.properties] 包含一条转换错误消息(年龄 [abc]),与示例 19 中相同。类 [config/WebConfig.java] 提供 [Bootstrap],与之前的示例相同。

9.1.3. Person 实体

文件 [entities/Person.java]:

package example28.entities;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Version;

// [persons] 表的一行
@Entity
@Table(name = "persons")
public class Person {

    // 主键,由数据库生成(AUTO_INCREMENT);JPA 在每次 INSERT 之后
    // 重新读取其值
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;

    // 乐观锁:JPA 在每次 UPDATE 时递增版本,
    // 并添加条件 "AND version = <读取到的值>"
    @Version
    @Column(name = "version")
    private Integer version;

    @Column(name = "first_name", length = 30)
    private String firstName;

    @Column(name = "last_name", length = 30)
    private String lastName;

    @Column(name = "age")
    private int age;

    // JPA 需要一个无参数的构造函数
    public Person() {
    }

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Integer getId() { return id; }

    public Integer getVersion() { return version; }

    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 int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}
  • 第 12 行:[@Entity] 把 [JPA] 实体 从 [Person] 类创建出来:表中的每一行都将是一个 [Person] 对象。这些注解来自 [jakarta.persistence] 包:它们属于 [JPA] 标准,而不是来自 [Hibernate];
  • 第 13 行:对应的表(默认情况下会是 [Person]);
  • 第 18–21 行:主键([@Id])。[@GeneratedValue(strategy = GenerationType.IDENTITY)] 表示其值由数据库分配([AUTO_INCREMENT]):[Hibernate] 在每次 [INSERT] 之后读取分配的值。类型 [Integer]——而不是 [int]——允许值 [null]:尚未登记的人没有 ID。[@Column] 指定与每个字段对应的列名;
  • 第 25–27 行:版本列。[@Version] 为 乐观锁 赋予 [Hibernate]:它在 [INSERT] 时把版本设为 0,在每次 [UPDATE] 时将其加 1,并在每次 [AND version = <value read>] 添加条件 [UPDATE] (以及每次 [DELETE] 时)。我们稍后会看到它的用途;
  • 第 29–36 行:其他列。[length] 指定列宽:只有当 [Hibernate] 自己创建表时它才有意义,而这里并非如此(参见 [ddl-auto]);
  • 第 39–40 行:[JPA] 要求有一个无参构造函数:[Hibernate] 就是用它从读取到的行创建对象,然后再填充其字段;
  • 第 48–59 行:访问器 (方法 [getX] 和 [setX]):该实体是一个 JavaBean。没有 [setId] 或 [setVersion]:这两个值只由 [Hibernate] 写入,它直接访问字段。

9.1.4. DAO 层

[dao/PersonsDao.java] 文件:

package example28.dao;

import java.util.List;
import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;

import example28.entities.Person;

// DAO 层:查询,没有业务规则。
// 一个接口,由 Spring Data JPA 在启动时自行实现。
// JpaRepository<Person, Integer> 已经提供了 findById、save、deleteById 等
public interface PersonsDao extends JpaRepository<Person, Integer> {

    // 方法的名称描述了查询:
    // SELECT ... FROM persons ORDER BY last_name, first_name
    List<Person> findAllByOrderByLastNameAscFirstNameAsc();

    // 名和姓相同的人员,[exceptId] 除外:
    // SELECT ... WHERE first_name = ? AND last_name = ? AND id <> ? LIMIT 1
    Optional<Person> findFirstByFirstNameAndLastNameAndIdNot(String firstName, String lastName, Integer exceptId);
}

这就是整个 DAO 层:一个接口,没有一行可执行代码。

  • 第 13 行:该接口继承自 [JpaRepository<Person, Integer>] (一个实体 [Person],其键是 [Integer])。启动时,[Spring Data JPA] 会创建一个实现该接口的类,并把它变成 Bean,然后注入。[JpaRepository] 已经提供了标准的方法:[findById] (按键读取,结果放在 [Optional] 中)、[findAll]、[save] ([INSERT] 或 [UPDATE])、[saveAndFlush]、[deleteById]、[count]……;
  • 第 17 行:一个派生查询:[Spring Data JPA] 分析方法名,并从中推导出查询。[findAll]:所有人员;[By]:没有条件,因为后面没有任何内容;[OrderByLastNameAscFirstNameAsc]:先按姓、再按名升序排序;
  • 第 21 行:[findFirst]:找到的第一个人([LIMIT 1]),或者一个空的 [Optional];[ByFirstNameAndLastNameAndIdNot]:其名和姓与作为参数提供的名和姓相匹配,并且其 ID 不同于第三个参数。这在修改记录时很有用,因为记录不能与它自己冲突。比较由 [MySQL] 执行,因此遵循数据库的排序规则:忽略大小写和重音。

方法名中的错误([findAllByOrderByLastNamee])会在启动时被检测到:应用程序拒绝启动,并报告存在未知属性。对于一个方法名无法表达的复杂查询,则用 [JPQL] 语言([Jakarta Persistence Query Language],一种引用实体及其字段而不是表的 SQL)编写,放在 [@Query] 注解中:案例研究使用了其中的几个。

9.1.5. 业务层

文件 [business/BusinessException.java]:

1
2
3
4
5
6
7
8
9
package example28.business;

// 某条业务规则拒绝了该操作:消息是给用户看的
public class BusinessException extends RuntimeException {

    public BusinessException(String message) {
        super(message);
    }
}

[BusinessException] 表示某条业务规则拒绝了一次操作。这不是程序错误:其消息是给用户看的。它继承自 [RuntimeException]:它是一种非受检异常,方法可以抛出它而无需声明([throws])。我们将看到,这一选择同样适用于事务。

文件 [business/PersonData.java]:

1
2
3
4
5
package example28.business;

// 人员的数据,即 Web 层传递过来的样子
public record PersonData(String firstName, String lastName, int age) {
}

一个人的数据,由 Web 层传递过来:业务层不认识表单类。

[business/PersonsBusiness.java] 文件:

package example28.business;

import java.util.List;
import java.util.Objects;

import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.orm.ObjectOptimisticLockingFailureException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import example28.dao.PersonsDao;
import example28.entities.Person;

// 业务层:业务规则,且只有业务规则。
// 类上的 @Transactional:每个公共方法都在一个
// 事务中运行,在方法结束时提交(COMMIT),如果
// 抛出异常则撤销(ROLLBACK)
@Service
@Transactional
public class PersonsBusiness {

    private static final String NAMESAKE = "A person already has these first and last names.";
    private static final String MODIFIED = "This record has been modified meanwhile: reload it.";

    private final PersonsDao dao;

    public PersonsBusiness(PersonsDao dao) {
        this.dao = dao;
    }

    // readOnly:只读事务
    @Transactional(readOnly = true)
    public List<Person> list() {
        return dao.findAllByOrderByLastNameAscFirstNameAsc();
    }

    @Transactional(readOnly = true)
    public Person read(int id) {
        return dao.findById(id).orElseThrow(() -> new BusinessException("This person does not exist (anymore)."));
    }

    public Person add(PersonData data) {
        // 规则 1:不允许存在名和姓都相同的两个人员
        if (dao.findFirstByFirstNameAndLastNameAndIdNot(data.firstName(), data.lastName(), 0).isPresent()) {
            throw new BusinessException(NAMESAKE);
        }
        return save(new Person(data.firstName(), data.lastName(), data.age()));
    }

    public Person edit(int id, Integer version, PersonData data) {
        Person person = read(id);
        // 规则 2:我们不修改在此期间被别人修改过的记录
        if (!Objects.equals(person.getVersion(), version)) {
            throw new BusinessException(MODIFIED);
        }
        if (dao.findFirstByFirstNameAndLastNameAndIdNot(data.firstName(), data.lastName(), id).isPresent()) {
            throw new BusinessException(NAMESAKE);
        }
        // 读取到的实体受 JPA“跟踪”:只需修改它即可
        person.setFirstName(data.firstName());
        person.setLastName(data.lastName());
        person.setAge(data.age());
        return save(person);
    }

    public Person delete(int id) {
        Person person = read(id);
        dao.deleteById(id);
        return person;
    }

    // saveAndFlush:INSERT 或 UPDATE 立即发送到数据库(而不是在
    // COMMIT 时),以便能在此处捕获数据库错误
    private Person save(Person person) {
        try {
            return dao.saveAndFlush(person);
        } catch (ObjectOptimisticLockingFailureException e) {
            // UPDATE "WHERE id = ... AND version = ..." 没有修改任何行
            throw new BusinessException(MODIFIED);
        } catch (DataIntegrityViolationException e) {
            // 两个同时发生的添加:数据库的唯一性约束拒绝了第二个
            if (String.valueOf(e.getMostSpecificCause().getMessage()).contains("unq_persons_first_name_last_name")) {
                throw new BusinessException(NAMESAKE);
            }
            throw e;
        }
    }
}

我们来解释这段代码:

  • 第 18 行:业务层是一个服务 Bean;
  • 第 19 行:附加在类上的 [@Transactional] 适用于它的每个公共方法:方法在一个事务 中执行,该事务在方法被调用之前打开([START TRANSACTION]),在方法返回时提交([COMMIT]),如果方法抛出非受检异常则回滚([ROLLBACK])。与 [@PreAuthorize] (示例 26)一样,[Spring] 把 Bean 包装在一个代理中,由它在调用前后打开和关闭事务。方法所做的一切,包括对 DAO 的调用,都发生在同一个事务和同一个连接上;
  • 第 32–35 行:[readOnly = true]:只读事务,它使 [Hibernate] 不必在结束时检查已修改的实体;
  • 第 37–40 行:不存在的人会抛出 [BusinessException]。[orElseThrow] 返回 [Optional] 的内容,如果它为空,则抛出由 lambda 生成的异常;
  • 第 42–48 行:添加。规则:任何两个人都不能有相同的名和姓。这一点在写入之前检查,以便显示清晰的消息。没有任何人的 ID 为 0:因此 [IdNot] 在这里不会把任何人排除在搜索之外;
  • 第 50–64 行:更新。附加规则:乐观锁(第 53–55 行)。更新表单使用的是表单被打开时那条记录的版本。如果它在此期间发生了变化(另一个用户编辑了同一条记录),更新就会被拒绝,而不是悄悄地覆盖用户的工作。[Objects.equals] 比较两个 [Integer] 实例 ,同时接受 [null];
  • 第 51 行:对 [read] 的调用是类内的内部调用:它不经过代理,因此其 [readOnly] 不起作用。[read] 只是在 [edit] 的事务中执行;
  • 第 60–63 行:在事务中读取的实体会被 跟踪([Hibernate] 称之为“受管理的”):只需修改它的字段;[Hibernate] 会检测到变化,并为表的各列生成一条 [UPDATE] ;
  • 第 66–70 行:删除。先读取这个人——既是为了验证其存在,也是为了让控制器可以提及他们的姓名;
  • 第 74–87 行:保存。通常情况下,[Hibernate] 只在事务结束时才发送 [INSERT] 和 [UPDATE] 到数据库,也就是在 [COMMIT] 时,即 在退出方法之后:此时在这里已经无法拦截数据库错误了。[saveAndFlush] 保存实体并立即发送([flush])待处理的 SQL 命令;
  • 第 77–79 行:前面提到的版本检查并不总是足够:两个用户可以同时保存同一条记录,并且都通过检查。第二个用户的 [UPDATE ... WHERE id = ? AND version = ?] 随后不会修改任何行;[Hibernate] 检测到这一点,[Spring] 抛出 [ObjectOptimisticLockingFailureException],它最终变成同样的 [BusinessException];
  • 第 80–85 行:类似地,同一个人的两次同时添加都会通过同名检查,但数据库的唯一性约束不允许它们都被接受。[Spring] 把来自各种数据库和各种 ORM 的异常翻译成一个通用的异常层次结构:违反约束会变成 [DataIntegrityViolationException]。[getMostSpecificCause()] 返回原始异常——即 [MySQL] 驱动程序的异常——其消息指明了约束的名称([Duplicate entry '...' for key 'unq_persons_first_name_last_name'])。违反其他约束的异常则继续向外传播(第 85 行):这是一种异常情况。

在异常离开 [PersonsBusiness] 的某个方法的所有情况下(包括 [BusinessException],因为它继承自 [RuntimeException]),代理都会回滚事务:该方法的所有操作都不会保留。注意:默认情况下,受检异常(继承自 [Exception] 而不继承自 [RuntimeException])不会导致回滚。

我们通过同时发送 30 个添加同一个人的请求验证了后一种情况:只有一个被接受;对于其他请求,数据库拒绝了 [INSERT] ([MySQL] 错误编号 1062,[Hibernate] 在控制台中将其报告为警告 [HHH000247]),用户收到的是“同名”消息,而不是 500 错误。

9.1.6. Web 层

文件 [models/PersonForm.java]:

package example28.models;

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;

// 表单字段及其约束(参见示例 19)
public class PersonForm {

    @NotBlank(message = "The first name is required.")
    @Size(max = 30, message = "30 characters at most.")
    private String firstName;

    @NotBlank(message = "The last name is required.")
    @Size(max = 30, message = "30 characters at most.")
    private String lastName;

    @NotNull(message = "The age is required.")
    @Min(value = 0, message = "The age must be between 0 and 150.")
    @Max(value = 150, message = "The age must be between 0 and 150.")
    private Integer age;

    // 记录的版本,由隐藏字段携带(仅用于编辑)
    private Integer version;

    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 Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }

    public Integer getVersion() { return version; }
    public void setVersion(Integer version) { this.version = version; }
}

表单及其验证约束(参见示例 19),记录版本(第 26 行)通过隐藏字段传递。年龄是 [Integer] 而不是 [int]:空字段会得到 [null],由 [@NotNull] 指出。

文件 [controllers/PersonsController.java]:

package example28.controllers;

import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import example28.entities.Person;
import example28.business.PersonData;
import example28.business.BusinessException;
import example28.business.PersonsBusiness;
import example28.models.PersonForm;
import jakarta.validation.Valid;

// Web 层:它只知道业务层
@Controller
public class PersonsController {

    private final PersonsBusiness business;

    public PersonsController(PersonsBusiness business) {
        this.business = business;
    }

    // 接收到的字符串会去除多余的空格(参见示例 19)
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
    }

    @GetMapping("/")
    public String home() {
        return "redirect:/persons";
    }

    @GetMapping("/persons")
    public String list(Model model) {
        model.addAttribute("persons", business.list());
        return "persons/list";
    }

    @GetMapping("/persons/add")
    public String addForm(Model model) {
        return form(model, "Add a person", "/persons/add", new PersonForm(), null);
    }

    @PostMapping("/persons/add")
    public String add(@Valid @ModelAttribute("person") PersonForm input, BindingResult result,
            Model model, RedirectAttributes redirect) {
        if (result.hasErrors()) {
            return form(model, "Add a person", "/persons/add", input, null);
        }
        try {
            Person p = business.add(new PersonData(input.getFirstName(), input.getLastName(), input.getAge()));
            redirect.addFlashAttribute("success", p.getFirstName() + " " + p.getLastName() + " has been added.");
            return "redirect:/persons";
        } catch (BusinessException e) {
            // 某条业务规则拒绝:我们重新显示表单,消息显示在页面底部
            return form(model, "Add a person", "/persons/add", input, e.getMessage());
        }
    }

    @GetMapping("/persons/{id:\\d+}/edit")
    public String editForm(@PathVariable int id, Model model, RedirectAttributes redirect) {
        try {
            Person p = business.read(id);
            PersonForm values = new PersonForm();
            values.setFirstName(p.getFirstName());
            values.setLastName(p.getLastName());
            values.setAge(p.getAge());
            values.setVersion(p.getVersion());
            return form(model, "Edit a person", "/persons/" + id + "/edit", values, null);
        } catch (BusinessException e) {
            redirect.addFlashAttribute("error", e.getMessage());
            return "redirect:/persons";
        }
    }

    @PostMapping("/persons/{id:\\d+}/edit")
    public String edit(@PathVariable int id, @Valid @ModelAttribute("person") PersonForm input,
            BindingResult result, Model model, RedirectAttributes redirect) {
        String action = "/persons/" + id + "/edit";
        if (result.hasErrors()) {
            return form(model, "Edit a person", action, input, null);
        }
        try {
            PersonData data = new PersonData(input.getFirstName(), input.getLastName(), input.getAge());
            Person p = business.edit(id, input.getVersion(), data);
            redirect.addFlashAttribute("success", p.getFirstName() + " " + p.getLastName() + " has been edited.");
            return "redirect:/persons";
        } catch (BusinessException e) {
            return form(model, "Edit a person", action, input, e.getMessage());
        }
    }

    @PostMapping("/persons/{id:\\d+}/delete")
    public String delete(@PathVariable int id, RedirectAttributes redirect) {
        try {
            Person p = business.delete(id);
            redirect.addFlashAttribute("success", p.getFirstName() + " " + p.getLastName() + " has been deleted.");
        } catch (BusinessException e) {
            // 没有要重新显示的表单:错误也作为闪现属性传递
            redirect.addFlashAttribute("error", e.getMessage());
        }
        return "redirect:/persons";
    }

    // 表单视图的模型:标题、提交地址、值、全局错误
    private String form(Model model, String title, String action, PersonForm values, String error) {
        model.addAttribute("title", title);
        model.addAttribute("action", action);
        model.addAttribute("person", values);
        model.addAttribute("error", error);
        return "persons/form";
    }
}

我们来分析这段代码:

  • 第 26–30 行:控制器只认识业务层;
  • 第 33–36 行:收到的字符串会去掉首尾空格,空字符串会变成 [null] (参见示例 19);
  • 第 38–41 行:站点根路径重定向到列表;
  • 第 54–68 行:添加,分三步:表单验证(出错:重新加载),调用业务层(成功:闪现消息并重定向;参见示例 20),[BusinessException] (带着页面底部的消息重新加载)。其他异常不会被捕获:这是一种异常情况,会导致 500 错误;
  • 第 70 行:[{id:\\d+}]:由正则表达式约束的路径变量(参见示例 02):[\d+] 表示一串数字(在 [Java] 字符串中反斜杠要写两次)。[/persons/abc/edit] 不对应任何动作:404 错误;
  • 第 70–84 行:更新表单,预先填入从数据库读取的记录,包括其版本;
  • 第 86–101 行:与添加操作结构相同;表单返回的版本被传递给业务层;
  • 第 103–113 行:删除。没有需要重新显示的表单:任何错误也通过闪现属性传递;
  • 第 116–122 行:表单视图模板,同时用于添加和修改记录:标题和提交地址不同,表单的值以及业务层的错误也不同。

[templates/persons/form.html] 文件:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3" th:text="${title}">Add a person</h1>
  <form method="post" th:action="${action}" th:object="${person}" novalidate>
    <!--/* 所读取记录的版本:它会随表单一起回传 */-->
    <input type="hidden" th:field="*{version}">
    <div th:replace="~{fragments/field :: field(name='firstName', label='First name', type='text')}"></div>
    <div th:replace="~{fragments/field :: field(name='lastName', label='Last name', type='text')}"></div>
    <div th:replace="~{fragments/field :: field(name='age', label='Age', type='number')}"></div>
    <button class="btn btn-primary" type="submit">Save</button>
    <a class="btn btn-link" href="/persons">Cancel</a>
  </form>
</main>
</body>
</html>
  • 第 6 行:[th:object] 标识表单对象;[th:action] 接收由控制器提供的提交地址;
  • 第 8 行:携带记录版本的隐藏字段:[th:field="*{version}"] 生成它的属性 [name] 和 [value] (参见示例 19);
  • 第 9–11 行:由示例 19 中的片段 [field] 生成的三个字段。

文件 [templates/layout.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="page(content)">
<head>
  <meta charset="utf-8">
  <title>Persons</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3" style="max-width: 40rem">
    <!--/* 成功消息(闪现属性,在重定向之后):位于顶部 */-->
    <div class="alert alert-success" role="status" th:if="${success != null}" th:text="${success}">success</div>
    <main th:replace="${content}"></main>
    <!--/* 错误:来自当前请求,或来自重定向之前(闪现属性) */-->
    <div class="error-area" role="alert" th:if="${error != null}" th:text="${error}">error</div>
  </div>
  <div th:replace="~{fragments/confirmation :: confirmation}"></div>
  <script src="/js/app.js"></script>
</body>
</html>
  • 第 12 行:成功消息,位于页面顶部;
  • 第 15 行:页面底部的错误消息:要么是当前请求中的错误(由 [form] 放入模板),要么是在重定向之前存储为闪现属性的错误。在这两种情况下,它都是视图模板的 [error] 属性;
  • 第 17–18 行:确认窗口及其脚本(参见示例 21)。

视图 [persons/list.html] 的结构与示例 21 中的联系人列表相同:每个人对应一个指向编辑表单的链接和一个 POST 删除表单,其提交需要确认。片段 [fragments/field.html] 与示例 19 中的相同,而窗口 [fragments/confirmation.html] 和脚本 [static/js/app.js] 与示例 21 中的相同,没有任何改动。

9.1.7. 运行

如果 [application.properties] 中的值不合适(例如 [root] 的密码),可以在不修改该文件的情况下用环境变量替换它们:属性名写成大写,句点替换为下划线。在 [Windows] ([PowerShell])下:

$env:SPRING_DATASOURCE_PASSWORD="secret"; ..\mvnw spring-boot:run

启动时,使用 [MariaDB] 的话,[Hibernate] 会显示一条警告:

... WARN ... org.hibernate.orm.core : HHH000511: The 5.5.5 version for [org.hibernate.dialect.MySQLDialect] is no longer supported, hence certain features may not work properly.The minimum supported version is 8.0.0. Check the community dialects project for available legacy versions.

这没有任何后果:[MariaDB] 向 [MySQL] 驱动程序表明自己的版本号为“5.5.5”,[Hibernate] 把它理解为一个非常古老的 [MySQL]。使用 [MySQL] 8 时则不会出现。

列表,位于 URLhttp://localhost:5000/:

Image

无效的表单:

Image

同名:业务规则会检测到它。[MySQL]使用数据库的排序规则进行比较时,也会拒绝 [marie pelissier]——小写且不带重音。这里输入的是 [Marie Pélissier]:

Image

添加成功:

Image

在 [spring.jpa.show-sql=true] 位于 [application.properties] 的情况下(或者,在不修改文件的情况下,使用 [../mvnw spring-boot:run -Dspring-boot.run.arguments=--spring.jpa.show-sql=true]),控制台会显示由 [Hibernate] 发送的每条 SQL 命令。添加一个人,然后在重定向之后显示列表:

1
2
3
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.first_name=? and p1_0.last_name=? and p1_0.id<>? limit ?
Hibernate: insert into persons (age,first_name,last_name,version) values (?,?,?,?)
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 order by p1_0.last_name,p1_0.first_name

在这里我们可以看到对同名者的搜索(由名称 [findFirstByFirstNameAndLastNameAndIdNot] 派生的查询),[INSERT],然后是列表的读取([findAllByOrderByLastNameAscFirstNameAsc])。各个值作为单独的参数 (即 [?])传递:这正是防止 SQL 注入的保护所在。事务命令([START TRANSACTION]、[COMMIT])不会显示。修改一条主记录:

1
2
3
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.id=?
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.first_name=? and p1_0.last_name=? and p1_0.id<>? limit ?
Hibernate: update persons set age=?,first_name=?,last_name=?,version=? where id=? and version=?

[UPDATE] 写入新版本并检查旧版本([where id=? and version=?]):这就是乐观锁。再看删除操作:

Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.id=?
Hibernate: delete from persons where id=? and version=?

[deleteById] 没有重新读取记录:自从调用 [read] 起,它就已经在事务中被跟踪了。

乐观锁:两个表单打开的是同一条记录;第一个被保存(版本从 0 变为 1);第二个仍然是版本 0,因此被拒绝:

Image

带确认的删除:

Image

Image