Hibernate在entitymanager.flush（）上抛出“ org.hibernate.HibernateException：找到相同集合的两个表示形式”

Question

I am currently working on a medium sized Java project with Hibernate and I have come across what seems to be a rare but quite persistent error. The situation is as follows: I have a Student entity who has a bidirectional many-to-many relation to an Education entity (implemented as a join table on the database) and an Admin entity who is a subclass of Student. My code allows for a Student to be "upgraded" to an Admin by removing the Student from the database, creating a new Admin based on the Student and persisting this Admin. However, whenever this happens, Hibernate throws the following error on EntityManager.flush():

org.hibernate.HibernateException: Found two representations of same collection: domain.Student.enrolledEducations

Below you can find the relevant code:

Education class

@Entity
public class Education {

...

@ManyToMany
@JoinColumn(name = "education_id")
private Set<Course> courses = new HashSet<>();

Student class

@Entity
public class Student {

....

@ManyToMany
@JoinColumn(name = "student_id")
private Set<Education> enrolledEducations = new HashSet<>();

Admin class

@Entity
public class Admin extends Student {

...

public Admin(Student student) {
    this.setId(student.getId());
    this.setFirstName(student.getFirstName());
    this.setLastName(student.getLastName());
    this.setEmail(student.getEmail());
    this.setSalt(student.getSalt());
    this.setSuperAdmin(false);
    this.setEnrolledEducations(student.getEnrolledEducations());
    this.setSessions(student.getSessions());
    this.setManagedEducations(new HashSet<Education>());
}

Database methods

public Admin upgrade(Person person) {
    Admin admin;
    if (person instanceof Student){
        removeStudent((Student) person);
        admin = new Admin((Student) person);
    }
    else{
        removePerson(person);
        admin = new Admin(person);

    }
    addAdmin(admin); //exception happens here

    return admin;
}

public void addAdmin(Admin admin) {
    manager.getTransaction().begin();

    if(manager.contains(admin)){
        manager.merge(admin);
    }
    else{
        manager.persist(admin);
    }

    manager.flush(); //exception happens here
    manager.getTransaction().commit();
}

Test method

@Test
public void getEducationsForAdmin_and_upgrade_to_admin_work_correctly(){

    educationSetup();

    Admin admin1 = facade.upgrade(student1); //exception happens here
    Admin admin2 = facade.upgrade(student2);

    admin1.addNewEducation(education1);
    admin1.addNewEducation(education2);
    admin2.addNewEducation(education1);

    facade.updateAdmin(admin1);
    facade.updateAdmin(admin2);

    Set<Education> educations1 = new HashSet<>(facade.getEducationsForStudent(admin1));
    Set<Education> educations2 = new HashSet<>(facade.getEducationsForStudent(admin2));

    assertTrue("admin 1 does not have exactly 1 education", educations1.size()==1);
    assertTrue("admin 2 does not have exactly 2 educations", educations2.size()==2);
    assertTrue("admin 1 does not have the IT education",educations1.contains(education1));
    assertTrue("admin 2 does not have the IT education",educations2.contains(education1));
    assertTrue("admin 2 does not have the M education",educations2.contains(education2));
}

Answer 1

It seems that you have a problem that both Admin and Student have the same identifier.

Since the Admin is created by calling the new function, it is not in the persistent state, the code

manager.contains(admin)

will always return false, so it will always go to the manager.persist statement.

Since Admin is a different object with the same identifier, you will get the exception

Found two representations of same collection

All you need to do is to add

manager.delete(person)

in your

removePerson

function. It should solve this problem.