如何在单向@ManyToOne 关系中保持 Parent from Child？

Question

I have a case where in my Entity I have 2 unidirectional @ManyToOne relations like this:

@Entity
public class A {

@Id
private Long apiId;

//other fields

@ManyToOne(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE})
@JoinColumn(name = "classBid", foreignKey = @ForeignKey(name = "FK_classA_classB"))
private B b;

@ManyToOne(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE})
@JoinColumn(name = "classCid", foreignKey = @ForeignKey(name = "FK_classA_classC"))
private C C;

//equals and hashcode
}

This class represents main domain object which comes from outside (by external api). Both B and C parents are equally important.

Now I want to save incoming data:

    @Override
    @Transactional
    public void updateAllInformation() {
        Set<AllInformationDTO> allInformationDTOS = apiService.getAllInformation();

        Set<A> aClassToSaveOrUpdate = new HashSet<>();
        for (AllInformationDTO allInformationDTO : allInformationDTOS) {

            BDTO bDTO = allInformationDTO.b();
            CDTO cDTO = allInformationDTO.c();
            ADTO aDTO = allInformationDTO.a();

            B b = //mapping from dto
            C c = //mapping from dto
            A a = //mapping from dto

            a.setB(b);
            a.setC(c);

            aClassToSaveOrUpdate.add(a);
        }

        aClassRepository.saveAll(aClassToSaveOrUpdate);
    }

But there is a problem when same Parent is in incoming data: DataIntegrityViolationException exception: A different object with the same identifier value was already associated with the session: B#78

How to cascade persist parent entities from child side of @ManyToOne relation? Should I change it to bidirectional and persist child from parent? But which one (B or C) should I choose to persist from if they are equally important?

I didn't want to make it @OneToMany based on this quote from Vlad's blog:

Answer 1

I don't understand your issue exactly, or more, I don't understand why you think a OneToMany is the solution. Your session has duplicate java instances for the same row data without having the OneToMany - persist cascading will not help you or change that. If you have multiple As referencing the same b1 row, they need to use the same b1 instance as well. The allInformationDTO.b(); is returning an instance that represents a row in the B table, say b1, and creating a new b1' instance likely every time it is called.

The solution depends on what you need to do with the Bs and Cs in this set of allInformationDTO. If you care about changes to the B and C data, something like:

    for (AllInformationDTO allInformationDTO : allInformationDTOS) {

        BDTO bDTO = allInformationDTO.b();
        CDTO cDTO = allInformationDTO.c();
        ADTO aDTO = allInformationDTO.a();

        B b = bClassRepository.save(convert(bDTO));//mapping from dto
        C c = cClassRepository.save(convert(cDTO));//mapping from dto
        A a = convert(aDTO));//mapping from dto

        a.setB(b);
        a.setC(c);

        aClassRepository.save(a);
    }

Note though that every redefinition of B and C in your allInformationDTOS will overwrite what was previously there.

Your provider should be able to batch up these save requests and issue them only when needed (when the transaction commits), but it depends on your configuration.