Java 后端 / 系统课时
测试 JPA 数据访问
测试 JPA 数据访问
本课构建一个部门与员工账户的最小数据模型,使用 @DataJpaTest 验证实体关联、派生查询、唯一约束和事务回滚,并说明为什么数据库约束测试必须主动执行 flush()。
学习目标
- 使用
@DataJpaTest加载实体、Repository、测试数据库和事务环境。 - 验证关联保存、派生查询排序以及唯一约束异常。
- 理解
flush()、一级缓存和测试结束自动回滚之间的关系。
DataJpaTest 的测试边界
@DataJpaTest 聚焦 JPA 数据访问切片,通常扫描实体和 Spring Data JPA Repository,并为每个测试方法开启事务。测试结束时默认回滚,因此不同用例可以共享数据库配置而不必手工删除本次写入的数据。

建立实体与 Repository
部门是一方,员工账户是多方;员工邮箱在数据库层唯一。以下代码按文件名分别保存到同一包 com.example.employee。
package com.example.employee;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
@Entity
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true)
private String code;
protected Department() {
}
public Department(String code) {
this.code = code;
}
public Long getId() {
return id;
}
public String getCode() {
return code;
}
}package com.example.employee;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
@Entity
@Table(
name = "employee_account",
uniqueConstraints = @UniqueConstraint(
name = "uk_employee_email",
columnNames = "email"))
public class EmployeeAccount {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String email;
@Column(nullable = false)
private String name;
@Column(nullable = false)
private boolean active;
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "department_id", nullable = false)
private Department department;
protected EmployeeAccount() {
}
public EmployeeAccount(
String email,
String name,
boolean active,
Department department) {
this.email = email;
this.name = name;
this.active = active;
this.department = department;
}
public String getName() {
return name;
}
public Department getDepartment() {
return department;
}
}package com.example.employee;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface EmployeeAccountRepository
extends JpaRepository<EmployeeAccount, Long> {
List<EmployeeAccount>
findByDepartmentIdAndActiveTrueOrderByNameAsc(Long departmentId);
}数据库约束写在实体映射中,查询方法名同时表达过滤条件和排序规则。测试应验证可观察结果,而不是只验证 Repository 方法“能够被调用”。
验证查询、约束与关联
flush() 会把待执行 SQL 立即发送到数据库,使唯一约束在断言范围内暴露;clear() 会清空一级缓存,随后查询得到的是数据库重新加载的实体,而不是刚刚保存在内存中的同一个对象。
package com.example.employee;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.transaction.AfterTransaction;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
@DataJpaTest
class EmployeeAccountRepositoryTest {
@Autowired
private TestEntityManager entityManager;
@Autowired
private EmployeeAccountRepository repository;
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
void shouldQueryActiveEmployeesAndLoadAssociation() {
Department department =
entityManager.persist(new Department("OPS"));
entityManager.persist(new EmployeeAccount(
"zoe@example.com", "Zoe", true, department));
entityManager.persist(new EmployeeAccount(
"amy@example.com", "Amy", true, department));
entityManager.persist(new EmployeeAccount(
"bob@example.com", "Bob", false, department));
entityManager.flush();
entityManager.clear();
List<EmployeeAccount> result = repository
.findByDepartmentIdAndActiveTrueOrderByNameAsc(
department.getId());
assertThat(result)
.extracting(EmployeeAccount::getName)
.containsExactly("Amy", "Zoe");
assertThat(result.get(0).getDepartment().getCode())
.isEqualTo("OPS");
}
@Test
void shouldRejectDuplicateEmailWhenFlushed() {
Department department =
entityManager.persist(new Department("DEV"));
repository.saveAndFlush(new EmployeeAccount(
"same@example.com", "Alice", true, department));
repository.save(new EmployeeAccount(
"same@example.com", "Ben", true, department));
assertThatThrownBy(repository::flush)
.isInstanceOf(DataIntegrityViolationException.class);
}
@Test
void shouldRollBackInsertedRowsAfterTest() {
Department department =
entityManager.persist(new Department("QA"));
entityManager.persist(new EmployeeAccount(
"qa@example.com", "Quinn", true, department));
entityManager.flush();
Integer count = jdbcTemplate.queryForObject(
"select count(*) from employee_account",
Integer.class);
assertThat(count).isEqualTo(1);
}
@AfterTransaction
void verifyDatabaseWasRestored() {
Integer employeeCount = jdbcTemplate.queryForObject(
"select count(*) from employee_account",
Integer.class);
Integer departmentCount = jdbcTemplate.queryForObject(
"select count(*) from department",
Integer.class);
assertThat(employeeCount).isZero();
assertThat(departmentCount).isZero();
}
}@AfterTransaction 在测试事务完成后执行,因此这里能直接确认回滚后的数据库状态。不要使用抢占式超时让测试主体运行到另一个线程,否则写入可能脱离 Spring 管理的测试事务。
运行与验证
项目需要 spring-boot-starter-data-jpa、spring-boot-starter-test,并在测试运行时提供 H2 等嵌入式数据库。执行:
mvn -Dtest=EmployeeAccountRepositoryTest test预期输出:
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS实际 SQL 日志、耗时和生成主键可能不同。通过结果说明查询、关联、约束和默认回滚已被验证,但仍不能证明生产数据库方言、索引和锁行为完全一致。
避免测试假阳性
只调用 save() 而不 flush(),SQL 可能推迟到事务结束才执行,约束异常就会落在断言之外。查询前不清空持久化上下文,也可能直接命中一级缓存,让错误映射暂时不暴露。
H2 适合快速切片测试,但生产使用 PostgreSQL、MySQL 等数据库时,应再增加基于真实方言的 Testcontainers 集成测试,并使用 @AutoConfigureTestDatabase(replace = NONE) 避免测试数据库被自动替换。