java - 当复合键与实体一起使用时，分离的实体被传递以保留

Question

我收到类似错误

org.springframework.dao.InvalidDataAccessApiUsageException: detached entity passed to persist: com.websopti.wotms.entity.Project; nested exception is org.hibernate.PersistentObjectException: detached entity passed to persist: com.websopti.wotms.entity.Project

我在实体上有复合键连接基本上我有两个实体，一个是Project，一个是User，我通过创建另一个名为ProjectUser的实体在它们之间创建了复合键连接，下面是类

用户

public class User extends BaseEntity<Long> implements UserDetails {

private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue
    private Long id;
    ...

    @OneToMany(mappedBy="user",fetch=FetchType.LAZY)
    private List<ProjectUser> userProjects;
    ...
    getter and setters
}

项目

public class Project extends BaseEntity<Long> {

    private static final long serialVersionUID = 7541005803335530236L;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
    ...
    @OneToMany(mappedBy="project",fetch=FetchType.LAZY, cascade=CascadeType.ALL)
    private List<ProjectUser> projectUsers;
    ...
}

项目用户

@IdClass(CompositeKey.class)
public class ProjectUser extends BaseEntity<Long> {

    private static final long serialVersionUID = 476483195548055916L;

    @ManyToOne
    @Id
    @JoinColumn(name="user_id", referencedColumnName="id")
    private User user;

    @ManyToOne
    @Id
    @JoinColumn(name="project_id", referencedColumnName="id")
    private Project project;

    private ProjectRole role;
    ...
    getter setter
}

复合键

public class CompositeKey implements Serializable {

    private static final long serialVersionUID = 2186028617883601307L;

    private long user;
    private long project;

    public CompositeKey() {}

    public CompositeKey(long user, long project) {
        this.user = user;
        this.project = project;
    }

    public boolean equals(Object object) {
        if (object instanceof CompositeKey) {
            CompositeKey pk = (CompositeKey)object;
            return user == pk.user && project == pk.project;
        } else {
            return false;
        }
    }
    ...
    getter setter
}

现在，当我当时创建项目时，如果我设置 List 对象并保存，那么它工作正常，但是当我想更新该项目并设置由代码手动创建并设置为项目对象的修改列表对象时。所以现在当我尝试保存这个修改后的项目对象时，我收到“分离实体传递到持久化”的错误。

我正在执行以下操作并保存此项目对象我用于保存项目对象 Controller 方法的代码如下

@RequestMapping(value="/update", method=RequestMethod.POST)
    public String updateProject(@ModelAttribute("project") Project project, HttpServletRequest request, RedirectAttributes redirectAttributes){

        try {

            project.setIpAddress(CommonUtils.getClientIpAddr(request));

            Project oldProject = projectService.findById(project.getId());

            List<ProjectUser> newProjectUsers = new ArrayList<ProjectUser>();

            List<Integer> selectedIndexes = project.getSelectedRoleIndexes();

            List<User> users = project.getTeam();

            if(users != null && users.size() > 0){
                for (User u : users) {
                    newProjectUsers.add(new ProjectUser(u, project, ProjectRole.getRole(selectedIndexes.get(users.indexOf(u)))));
                }
            }

            List<ProjectUser> oldProjectUsers = oldProject.getProjectUsers();

            for (ProjectUser projectUser : new ArrayList<>(oldProjectUsers)) {
                if(!users.contains(projectUser.getUser())){

                    /*disable all task for user*/
                    //taskService.disableUserTaskForProject(projectUser.getUser(), oldProject);

                    /*send remove member form project mail*/
                    //projectEmailService.sendProjectTeamMemberRemoveEmail(projectUser.getUser(), oldProject);

                    oldProjectUsers.remove(projectUser);
                }else{
                    ProjectUser pu = newProjectUsers.get(users.indexOf(projectUser.getUser()));
                    oldProjectUsers.remove(projectUser);
                    projectUser.setRole(pu.getRole());
                    oldProjectUsers.add(projectUser);
                }
            }

            List<User> oldTeam = oldProjectUsers.stream().map(pu -> {return pu.getUser();}).collect(Collectors.toList());

            for (ProjectUser projectUser : newProjectUsers) {
                if(!oldTeam.contains(projectUser.getUser())){
                    /*send user add in project mail*/
                    //projectEmailService.sendProjectTeamMemberAddEmail(projectUser.getUser(), oldProject);

                    oldProjectUsers.add(projectUser);
                }
            }

            //oldProjectUsers = entityManager.merge(oldProjectUsers);
            //projectUserService.updateAllProjectUsers(oldProjectUsers);
            /*for (ProjectUser projectUser : oldProjectUsers) {
                entityManager.merge(projectUser);
            }*/
            project.setProjectUsers(oldProjectUsers);

            //project = entityManager.merge(project);

            project = projectService.update(project);

            /*old team except admin*/
            /*List<User> oldTeam = oldProject.getProjectUsers()
                    .stream()
                    .map(pu -> {return pu.getUser();})
                    .collect(Collectors.toList());
            List<User> newTeam = project.getTeam()
                    .stream()
                    .filter(u -> u.getRole() != SystemRole.ADMIN)
                    .collect(Collectors.toList());

            project = projectService.update(project);

            for (User user : oldTeam) {
                if(!newTeam.contains(user)){
                    disable all task for user
                    taskService.disableUserTaskForProject(user, project);

                    send remove member form project mail
                    projectEmailService.sendProjectTeamMemberRemoveEmail(user, project);
                }
            }

            for (User user : newTeam) {
                if(!oldTeam.contains(user)){
                    send user add in project mail
                    projectEmailService.sendProjectTeamMemberAddEmail(user, project);
                }
            }*/

        } catch(Exception e) {

            e.printStackTrace();
            return "redirect:/user/UserDashboard";
        }

        redirectAttributes.addFlashAttribute("projectId",project.getId());

        redirectAttributes.addFlashAttribute("fromUpdate", true);

        return "redirect:/user/"+PageTemplate.userDashboard;

    }

请帮助我，我被困在这里

Answer 1

首先感谢 hansnae 让我有信心解决这个问题，因为我已经访问过这个问题 3 次，并且浏览过这个问题也想过应用该解决方案，但由于我不确定而没有应用。

现在我的情况存在双向关系问题，因此我已应用该逻辑在 List 对象中进行修改，并且它对我有用

JPA/Hibernate: detached entity passed to persist

但在这个问题中，删除对象设施对我不起作用，因为我在我的情况下使用了复合键连接，我需要额外的工作来删除该对象

当我尝试保存已删除的对象并在相关连接实体中设置 null 时，我的情况会抛出异常

No part of a composite identifier may be null

因此，要从列表中删除该对象，我必须通过存储库删除查询手动删除该对象。

感谢这个伟大社区的帮助和举手