JPA: How to have one-to-many relation of the same Entity type

by

Yes, this is possible. This is a special case of the standard bidirectional @ManyToOne/@OneToMany relationship. It is special because the entity on each end of the relationship is the same. The general case is detailed in Section 2.10.2 of the JPA 2.0 spec.

Here’s a worked example. First, the entity class A:

@Entity
public class A implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
    @ManyToOne
    private A parent;
    @OneToMany(mappedBy="parent")
    private Collection<A> children;

    // Getters, Setters, serialVersionUID, etc...
}

Here’s a rough main() method that persists three such entities:

public static void main(String[] args) {

    EntityManager em = ... // from EntityManagerFactory, injection, etc.

    em.getTransaction().begin();

    A parent   = new A();
    A son      = new A();
    A daughter = new A();

    son.setParent(parent);
    daughter.setParent(parent);
    parent.setChildren(Arrays.asList(son, daughter));

    em.persist(parent);
    em.persist(son);
    em.persist(daughter);

    em.getTransaction().commit();
}

In this case, all three entity instances must be persisted before transaction commit. If I fail to persist one of the entities in the graph of parent-child relationships, then an exception is thrown on commit(). On Eclipselink, this is a RollbackException detailing the inconsistency.

This behavior is configurable through the cascade attribute on A‘s @OneToMany and @ManyToOne annotations. For instance, if I set cascade=CascadeType.ALL on both of those annotations, I could safely persist one of the entities and ignore the others. Say I persisted parent in my transaction. The JPA implementation traverses parent‘s children property because it is marked with CascadeType.ALL. The JPA implementation finds son and daughter there. It then persists both children on my behalf, even though I didn’t explicitly request it.

One more note. It is always the programmer’s responsibility to update both sides of a bidirectional relationship. In other words, whenever I add a child to some parent, I must update the child’s parent property accordingly. Updating only one side of a bidirectional relationship is an error under JPA. Always update both sides of the relationship. This is written unambiguously on page 42 of the JPA 2.0 spec:

Note that it is the application that bears responsibility for maintaining the consistency of runtime relationships—for example, for insuring that the “one” and the “many” sides of a bidirectional relationship are consistent with one another when the application updates the
relationship at runtime.

More Related Contents:

  1. JPA – Persisting a One to Many relationship
  2. How to fix the Hibernate “object references an unsaved transient instance – save the transient instance before flushing” error
  3. Hibernate throws MultipleBagFetchException – cannot simultaneously fetch multiple bags
  4. Hibernate Annotations – Which is better, field or property access?
  5. How to map calculated properties with JPA and Hibernate
  6. What is the meaning of the CascadeType.ALL for a @ManyToOne JPA association
  7. Bypass GeneratedValue in Hibernate (merge data not in db?)
  8. When and why JPA entities should implement the Serializable interface?
  9. JPQL Create new Object In Select Statement – avoid or embrace?
  10. How to annotate MYSQL autoincrement field with JPA annotations
  11. What is the difference between Unidirectional and Bidirectional JPA and Hibernate associations?
  12. How to remove entity with ManyToMany relationship in JPA (and corresponding join table rows)?
  13. What is “the inverse side of the association” in a bidirectional JPA OneToMany/ManyToOne association?
  14. Storing a Map using JPA
  15. How to persist a property of type List in JPA?
  16. I found JPA, or alike, don’t encourage DAO pattern
  17. Getting Database connection in pure JPA setup
  18. Hibernate – @ElementCollection – Strange delete/insert behavior
  19. Hibernate/JPA – annotating bean methods vs fields [duplicate]
  20. How to clone a JPA entity
  21. JPA: Implementing Model Hierarchy – @MappedSuperclass vs. @Inheritance
  22. Is it possible to dynamically define column names in Hibernate / JPA?
  23. JPA OneToMany and ManyToOne throw: Repeated column in mapping for entity column (should be mapped with insert=”false” update=”false”)
  24. @Basic(optional = false) vs @Column(nullable = false) in JPA
  25. No operator matches the given name and argument type(s). You might need to add explicit type casts. — Netbeans, Postgresql 8.4 and Glassfish
  26. Batch inserts with JPA/EJB3
  27. Hibernate triggering constraint violations using orphanRemoval
  28. Hibernate vs JPA vs JDO – pros and cons of each? [closed]
  29. Clarifying terminology – What does “hydrating” a JPA or Hibernate entity mean when fetching the entity from the DB
  30. Does JPA support mapping to sql views?

Leave a Comment