休眠多对多关系意外更新

Question

I have two classes:

class TrainingCourse {
    Integer id;
    @OneToMany(cascade = CascadeType.ALL, fetch=FetchType.EAGER)
    @JoinTable(name = "TrainingCourseClass", joinColumns = { @JoinColumn(name = "CourseID") }, inverseJoinColumns = { @JoinColumn(name = "ClassID") })
    private Set<TrainingClass> trainingClasses; 
}

class TrainingClass {
    Integer id;
}

In the database they are mapped using a join table. So this is a unidirectional relationship.

From the UI, when a TrainingCourse is created, a list of previously created TrainingClasses are selected from the UI.

Now if I create the TrainingCourse, then it automatically updates the associated TrainingClasses also. But trainingClass is independent of TrainingCourse and can exist independently. So TrainingClasses are created and updated separately from the TrainingCourse. So saving the TrainingCourse should save data in the TrainingCourse table and it will also save the association in the join Table TrainingCourseClass. Nothing should happen in the table TrainingClass.

However if I add these to the columns:

nullable=false, updatable=false and CascadeType.REMOVE


@OneToMany(cascade = CascadeType.REMOVE, fetch=FetchType.EAGER)
    @JoinTable(name = "TrainingCourseClass", joinColumns = { @JoinColumn(name = "CourseID", nullable=false, updatable=false) }, inverseJoinColumns = { @JoinColumn(name = "ClassID", nullable=false, updatable=false) })
    private Set<TrainingClass> trainingClasses; 

Then the problem is fixed ie creating trainingCourse doesn't update the trainingClass table. Now I am not 100% sure whether it is the right solution or how it is working to solve the problem. There is also another thing called MappedBy. I am not sure whether this is relevant here.

I just used it as a guess and it is working. Moreover, this seems to be really a many-to-many relationship ie The same class can belong to many courses and one course can include many classes. But one-to-many relationship is also working. This is not very convincing. The trainingclass is really unaware of what training courses include it. It looks like the difference between one-to-many and many-to-many is like whether or not to have bidirectional pointers to each other.

Hence please suggest whether the above approach is correct to prevent updating the trainingclass while creating the trainingcourse.

Thanks

Answer 1

Your first mapping uses cascade = ALL . That means that every operation you make on a TrainingCourse (persist, merge, remove, etc.) will also be applied on the associated TrainingClass. That's precisely what you don't want, if I understand correctly. So just don't set any cascade to this association.

Regarding OneToMany vs. ManyToMany: if what you really want is a OneToMany (ie a TraningClass should not be associated with more than one TrainingCourse), then you should have a unique contraint on the TrainingCourseClass.ClassID column. That's what guarantees that the association is a OneToMany and not a ManyToMany.