Do I need to save both entities when adding a oneToMany relationship?-CodePudding

TL;DR: Is it enough to call repository.save() on the owning entity to persist the relationship or do I need to save both entities?

Let's say I have two entities, A and B and a oneToMany relationship between them. A can have multiple B's, B can have an A. B is the owning side of the relationship (has the foreign key). If I have two, already persisted entities and want to add and persist a relationship between them, then I typically do this:

a.addB(b);
b.setA(a);
bRepository.save(b);

My question is, do I also need to call aRepository.save(a)? Thanks in advance, Googling didn't help me to find the answer.

CodePudding user response：

If as you describe the relationship is owned by B, A didn't change at all as far as JPA is concerned. So it doesn't need to get persisted.

If you have persisted or loaded A and B in the current session, no save at all is technically necessary. JPA keeps track of the entities, note that they are changed and will flush the changes to the database at the end of the transaction.

CodePudding user response：

Good question and assuming that you have already saved the A entity the answer should be that you do NOT need to save the parent A entity again since you have added the child entity B to A's list of children yourself and A is already persisted.

If you ever reload A and all its children you should get the same list as you currently have.

Since it is lazy loaded your query should specifically load the children in the case you want that otherwise you might get into the situation where you assume that A has all its children but you doesn't if you reloaded A from the database without getting them.

In general though I have to question why you are keeping A around in the first place. Caching can be a good thing but your cache should refresh A when its children are updated and should fetch all of A's children if that is what is needed. In that case you don't need to add the new child to A yourself b/c it will be overwritten anyway. Probably doesn't hurt, but why do you want to second guess the cache?

More generally the pattern is simply to save B and be done with it. If your code needs A and all its children it should fetch from the database when needed.

These thoughts do not include JPAs entity cache since I have not attempted to get into very specific detail about that.