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]:
| package example28.business;
// 某条业务规则拒绝了该操作:消息是给用户看的
public class BusinessException extends RuntimeException {
public BusinessException(String message) {
super(message);
}
}
|
[BusinessException] 表示某条业务规则拒绝了一次操作。这不是程序错误:其消息是给用户看的。它继承自 [RuntimeException]:它是一种非受检异常,方法可以抛出它而无需声明([throws])。我们将看到,这一选择同样适用于事务。
文件 [business/PersonData.java]:
| 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/:

无效的表单:

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

添加成功:

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

带确认的删除:

