Hi!

I have some thoughts about how to to keep both sides of an OneToMany relationship in sync with each other. Are there any best practices or things to avoid in my example below?

Let's say I have classic Parent / Child case. One Parent can have many children, one Child can only have one Parent. So the Child is the owning side of the relationship.

Now if I create two instances like this (all in one transaction).

Parent p = new Parent();
persist(p);
Child c = new Child();
persist(c);
c.setParent(p);
print("Children: " + p.getChildren());

The print() statement will in this case print an empty set of children. If I do a refresh(p) before the print() then the child will show up in the set. And of course if I start a new transaction and load the parent from the databse the child will be there.

Now, how do I get the child to turn up in the parent side of the relation without doing refresh()? (Or should I at all try that?)

I could add some logic to the setters. E.g in the Child:

public void setParent(Parent parent) {
this.parent = parent;
parent.children.add(this);
}

Are there any dangers in doing something like this? Will I run into conflicts with Hibernate calling the setter?

Any advice would be helpful!

/Niklas

It is a good idea to make sure that both ends of the association are up-to-date. Having this code in a single method is also a good idea. However it may not be a good idea to put this code in in the setParent() method since, as you point, Hibernate is also calling the setParent() method. This will trigger all sorts of things (lazy loading of the parent and it's children collection for example) which you may not want to happen.

The Hibernate documentation has an example (http://www.hibernate.org/hib_docs/v3/re ... child.html)
where this is done from the parent side with methods that are not called by Hibernate.

Ok, so the strategy is to keep bi-directional relations in sync, but not in methods that are called by Hibernate.

(I had read that chapter in the docs but missed that particular thing in the example code.. :-) )

Thanks for the advice!

If a project is using field-based annotations instead of setter injection, then is there any reason that it would not be fine to actually put this relationship maintenance behavior in the setParent() method?