java - 为什么我们需要双向同步方法？
问题描述
如主题所述。为什么我们需要双向同步方法？它解决了哪些现实世界的用例？如果我不使用它们会怎样？
在 Hibernate 的用户指南中：
每当形成双向关联时，应用程序开发人员必须确保双方始终保持同步。addPhone() 和 removePhone() 是在添加或删除子元素时同步两端的实用方法。
在 Vlad 的一篇博文中：
但是，我们仍然需要双方同步，否则我们会破坏领域模型关系的一致性，并且除非双方正确同步，否则无法保证实体状态转换有效。
最后，在 Vlad 的书 - 高性能 Java 持久性中，第 216 页：
对于双向 @ManyToMany 关联，必须将辅助方法添加到更可能与之交互的实体中。在我们的例子中，根实体是 Post，所以辅助方法被添加到 Post 实体中
但是，如果我使用简单的生成设置器，Hibernate 似乎也可以正常工作。此外，同步方法可能会导致性能下降。
同步方法：
public void joinProject(ProjectEntity project) {
project.getEmployees().add(this);
this.projects.add(project);
}
生成这个：
Hibernate:
select
employeeen0_.id as id1_0_0_,
projectent2_.id as id1_2_1_,
teamentity3_.id as id1_3_2_,
employeeen0_.first_name as first_na2_0_0_,
employeeen0_.job_title as job_titl3_0_0_,
employeeen0_.last_name as last_nam4_0_0_,
employeeen0_.team_id as team_id5_0_0_,
projectent2_.budget as budget2_2_1_,
projectent2_.name as name3_2_1_,
projects1_.employee_id as employee1_1_0__,
projects1_.project_id as project_2_1_0__,
teamentity3_.name as name2_3_2_
from
employees.employee employeeen0_
inner join
employees.employee_project projects1_
on employeeen0_.id=projects1_.employee_id
inner join
employees.project projectent2_
on projects1_.project_id=projectent2_.id
inner join
employees.team teamentity3_
on employeeen0_.team_id=teamentity3_.id
where
employeeen0_.id=?
Hibernate:
select
projectent0_.id as id1_2_,
projectent0_.budget as budget2_2_,
projectent0_.name as name3_2_
from
employees.project projectent0_
where
projectent0_.id=?
Hibernate:
select
employees0_.project_id as project_2_1_0_,
employees0_.employee_id as employee1_1_0_,
employeeen1_.id as id1_0_1_,
employeeen1_.first_name as first_na2_0_1_,
employeeen1_.job_title as job_titl3_0_1_,
employeeen1_.last_name as last_nam4_0_1_,
employeeen1_.team_id as team_id5_0_1_
from
employees.employee_project employees0_
inner join
employees.employee employeeen1_
on employees0_.employee_id=employeeen1_.id
where
employees0_.project_id=?
Hibernate:
insert
into
employees.employee_project
(employee_id, project_id)
values
(?, ?)
在获取项目后立即注意对员工的额外选择。如果我简单地使用employeeEntity.getProjects().add(projectEntity);，它会生成：
Hibernate:
select
employeeen0_.id as id1_0_0_,
projectent2_.id as id1_2_1_,
teamentity3_.id as id1_3_2_,
employeeen0_.first_name as first_na2_0_0_,
employeeen0_.job_title as job_titl3_0_0_,
employeeen0_.last_name as last_nam4_0_0_,
employeeen0_.team_id as team_id5_0_0_,
projectent2_.budget as budget2_2_1_,
projectent2_.name as name3_2_1_,
projects1_.employee_id as employee1_1_0__,
projects1_.project_id as project_2_1_0__,
teamentity3_.name as name2_3_2_
from
employees.employee employeeen0_
inner join
employees.employee_project projects1_
on employeeen0_.id=projects1_.employee_id
inner join
employees.project projectent2_
on projects1_.project_id=projectent2_.id
inner join
employees.team teamentity3_
on employeeen0_.team_id=teamentity3_.id
where
employeeen0_.id=?
Hibernate:
select
projectent0_.id as id1_2_,
projectent0_.budget as budget2_2_,
projectent0_.name as name3_2_
from
employees.project projectent0_
where
projectent0_.id=?
Hibernate:
insert
into
employees.employee_project
(employee_id, project_id)
values
(?, ?)
没有更多的员工。
完整的代码。
控制器。
@RestController
@RequestMapping(path = "${application.endpoints.projects}", produces = MediaType.APPLICATION_JSON_VALUE)
@Validated
public class ProjectsEndPoint {
@PostMapping("add-employee")
@ApiOperation("Add employee to project")
public void addEmployeeToProject(@RequestBody @Valid EmployeeProjectRequest request) {
LOGGER.info("Add employee to project. Request: {}", request);
this.projectsService.addEmployeeToProject(request);
}
}
员工项目请求。
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
public record EmployeeProjectRequest(
@NotNull @Min(0) Long employeeId,
@NotNull @Min(0) Long projectId) {
}
项目服务。
@Service
public class ProjectsService {
private final ProjectRepo projectRepo;
private final EmployeeRepo repo;
public ProjectsService(ProjectRepo projectRepo, EmployeeRepo repo) {
this.projectRepo = projectRepo;
this.repo = repo;
}
@Transactional
public void addEmployeeToProject(EmployeeProjectRequest request) {
var employeeEntity = this.repo.getEmployee(request.employeeId())
.orElseThrow(() -> new NotFoundException("Employee with id: %d does not exist".formatted(request.employeeId())));
var projectEntity = this.projectRepo.getProject(request.projectId())
.orElseThrow(() -> new NotFoundException("Project with id: %d does not exists".formatted(request.projectId())));
//This line can be changed with employeeEntity.joinProject(projectEntity);
employeeEntity.getProjects().add(projectEntity);
}
}
项目回购。
@Repository
public class ProjectRepo {
private final EntityManager em;
public ProjectRepo(EntityManager em) {
this.em = em;
}
public Optional<ProjectEntity> getProject(Long id) {
var result = this.em.createQuery("SELECT p FROM ProjectEntity p where p.id = :id", ProjectEntity.class)
.setParameter("id", id)
.getResultList();
return RepoUtils.fromResultListToOptional(result);
}
}
员工回购。
@Repository
public class EmployeeRepo {
private final EntityManager em;
public EmployeeRepo(EntityManager em) {
this.em = em;
}
public Optional<EmployeeEntity> getEmployee(Long id) {
var employees = this.em.createQuery("""
SELECT e FROM EmployeeEntity e
JOIN FETCH e.projects p
JOIN FETCH e.team t
WHERE e.id = :id""", EmployeeEntity.class)
.setParameter("id", id)
.getResultList();
return Optional.ofNullable(employees.isEmpty() ? null : employees.get(0));
}
}
员工实体。
@Entity
@Table(name = "employee", schema = "employees")
public class EmployeeEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String firstName;
private String lastName;
@Enumerated(EnumType.STRING)
private JobTitle jobTitle;
@ManyToOne(fetch = FetchType.LAZY)
private TeamEntity team;
@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.PERSIST)
@JoinTable(schema = "employees", name = "employee_project",
joinColumns = @JoinColumn(name = "employee_id", referencedColumnName = "id"),
inverseJoinColumns = @JoinColumn(name = "project_id", referencedColumnName = "id"))
private Set<ProjectEntity> projects = new HashSet<>();
public EmployeeEntity() {
}
public void joinProject(ProjectEntity project) {
project.getEmployees().add(this);
this.projects.add(project);
}
public void leaveProject(ProjectEntity project) {
project.getEmployees().remove(this);
this.projects.remove(project);
}
... Getters and Setters ...
}
项目实体。
Entity
@Table(name = "project", schema = "employees")
public class ProjectEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private BigDecimal budget;
@ManyToMany(fetch = FetchType.LAZY, mappedBy = "projects")
private Set<EmployeeEntity> employees = new HashSet<>();
public ProjectEntity() {
}
... Getters and Setters ...
}
解决方案
如果 Many 方面确实有很多元素，那么您可能根本不应该使用 OneToMany。获取大型集合意味着使用某种分页\过滤，但 OneToMany 会加载整个集合。
首先，您需要更新拥有实体（FK 所在的位置）以将其存储在数据库中。Vlad 和 Hibernate 指南关于一致性的含义是指更新当前会话中的实体对象。这些对象在生命周期中具有转换，并且当您具有双向关联时，如果您不设置反面，那么该反面实体将不会更新该字段，并且将与拥有方实体不一致（并且可能与DB 最终，在 TX 提交之后）在当前会话中。让我以 OneToMany 为例进行说明。如果我们得到 2 个托管实体 Company 和 Employee：
set employee.company = X -> persist(employee) -> managed List<Employee> company.employees gets inconsistent with db
并且可能存在不同类型的不一致，例如从company.employees现场获取并产生副作用（猜测它不是空的，但只是没有您刚刚添加的员工），如果有 Cascade.ALL，您可能会错过或错误地删除\通过断开的关系更新\添加实体，因为您的实体处于模棱两可的状态，并且休眠以防御性但有时不可预测的方式处理它：
删除不使用 JpaRepository
此外，您可能会发现这个答案很有趣：https ://stackoverflow.com/a/5361587/2924122
推荐阅读
- c# - 从路径加载文件和从流 C# 加载文件之间的区别
- typescript - 打字稿部分但不是完整的对象本身
- python - 如何从所有熊猫列中计算成对矩阵
- html - 如何在不使用 div 标签和不使用容器的情况下更改 HTML5 中同一行中文本的字体颜色？
- angular - 从 Angular 绑定中抓取数据：数据从何而来？
- reactjs - 在道具条件下设置模态isOpen React js
- mysql - 针对长时间运行的查询的 MySQL 配置调整
- r - 具有 p.value 星的组的回归估计
- javascript - 更新状态变量而不更改在渲染时分配给它们的其他状态的值
- c# - 如何从域名中删除所有 Unicode (\u8236) 字符