JPA: Comment avoir une relation un-à-plusieurs du même type d'entité

Question

Il existe une classe d'entité "A". La classe A peut avoir des enfants du même type "A". Aussi "A" devrait tenir son parent s'il s'agit d'un enfant.

Est-ce possible? Si oui, comment dois-je cartographier les relations dans la classe Entity? ["A" a une colonne id.]

Answer 1

Oui, cela est possible. C'est un cas particulier de la relation bidirectionnelle standard @ManyToOne/@OneToMany. C'est spécial parce que l'entité à chaque extrémité de la relation est la même. Le cas général est détaillé à la section 2.10.2 du JPA 2.0 spec.

Voici un exemple travaillé. Tout d'abord, la classe d'entité 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... 
} 

Voici une méthode main() grossière qui persiste trois de ces entités:

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(); 
} 

Dans ce cas, doivent être conservées trois instances d'entités avant validation de la transaction. Si je ne parviens pas à persister une des entités dans le graphique des relations parent-enfant, une exception est lancée sur commit(). Sur Eclipselink, il s'agit d'un RollbackException détaillant l'incohérence.

Ce comportement est configurable via l'attribut cascade sur les annotations @OneToMany et @ManyToOne de A. Par exemple, si je mets cascade=CascadeType.ALL sur ces deux annotations, je peux en toute sécurité persister une des entités et ignorer les autres. Dire que j'ai persisté parent dans ma transaction. La mise en œuvre JPA traverse parentchildren car il est marqué CascadeType.ALL. L'implémentation JPA trouve son et daughter là. Il persiste alors les deux enfants en mon nom, même si je ne l'ai pas explicitement demandé.

Une note de plus. Il est toujours de la responsabilité du programmeur de mettre à jour les deux côtés d'une relation bidirectionnelle. En d'autres termes, chaque fois que j'ajoute un enfant à un parent, je dois mettre à jour la propriété parent de l'enfant en conséquence. La mise à jour d'un seul côté d'une relation bidirectionnelle est une erreur sous JPA. Toujours mettre à jour les deux côtés de la relation. Ceci est écrit clairement à la page 42 de la spécification JPA 2.0:

Notez qu'il est l'application qui porte la responsabilité de maintenir la cohérence de runtime relations par exemple, pour assurer que le « un » et « beaucoup Les côtés d'une relation bidirectionnelle sont cohérents entre eux lorsque l'application met à jour la relation lors de l'exécution.

Answer 2

Pour moi, l'astuce consistait à utiliser une relation plusieurs-à-plusieurs. Supposons que votre entité A soit une division pouvant comporter des sous-divisions. Ensuite (sauter les détails non pertinents):

@Entity 
@Table(name = "DIVISION") 
@EntityListeners({ HierarchyListener.class }) 
public class Division implements IHierarchyElement { 

    private Long id; 

    @Id 
    @Column(name = "DIV_ID") 
    public Long getId() { 
     return id; 
    } 
    ... 
    private Division parent; 
    private List<Division> subDivisions = new ArrayList<Division>(); 
    ... 
    @ManyToOne 
    @JoinColumn(name = "DIV_PARENT_ID") 
    public Division getParent() { 
     return parent; 
    } 

    @ManyToMany 
    @JoinTable(name = "DIVISION", joinColumns = { @JoinColumn(name = "DIV_PARENT_ID") }, inverseJoinColumns = { @JoinColumn(name = "DIV_ID") }) 
    public List<Division> getSubDivisions() { 
     return subDivisions; 
    } 
... 
} 

Depuis que j'avais une logique d'affaires étendu autour de la structure hiérarchique et JPA (basée sur le modèle relationnel) est très faible pour le soutenir, j'ai présenté l'interface IHierarchyElement et auditeur de l'entité HierarchyListener:

public interface IHierarchyElement { 

    public String getNodeId(); 

    public IHierarchyElement getParent(); 

    public Short getLevel(); 

    public void setLevel(Short level); 

    public IHierarchyElement getTop(); 

    public void setTop(IHierarchyElement top); 

    public String getTreePath(); 

    public void setTreePath(String theTreePath); 
} 


public class HierarchyListener { 

    @PrePersist 
    @PreUpdate 
    public void setHierarchyAttributes(IHierarchyElement entity) { 
     final IHierarchyElement parent = entity.getParent(); 

     // set level 
     if (parent == null) { 
      entity.setLevel((short) 0); 
     } else { 
      if (parent.getLevel() == null) { 
       throw new PersistenceException("Parent entity must have level defined"); 
      } 
      if (parent.getLevel() == Short.MAX_VALUE) { 
       throw new PersistenceException("Maximum number of hierarchy levels reached - please restrict use of parent/level relationship for " 
         + entity.getClass()); 
      } 
      entity.setLevel(Short.valueOf((short) (parent.getLevel().intValue() + 1))); 
     } 

     // set top 
     if (parent == null) { 
      entity.setTop(entity); 
     } else { 
      if (parent.getTop() == null) { 
       throw new PersistenceException("Parent entity must have top defined"); 
      } 
      entity.setTop(parent.getTop()); 
     } 

     // set tree path 
     try { 
      if (parent != null) { 
       String parentTreePath = StringUtils.isNotBlank(parent.getTreePath()) ? parent.getTreePath() : ""; 
       entity.setTreePath(parentTreePath + parent.getNodeId() + "."); 
      } else { 
       entity.setTreePath(null); 
      } 
     } catch (UnsupportedOperationException uoe) { 
      LOGGER.warn(uoe); 
     } 
    } 

}