Comment modéliser un arbre avec mise en veille prolongée?

Si vous souhaitez utiliser Hibernate/JPA, l'initialisation tardive (c'est le cas normal), alors vous devez pas utiliser le diagramme composite.

Hibernate problème avec le Diagramme Composite est: dans un Composite, vous avez un Composite qui a une référence à son enfant Composants.
Mais le Composant n'est qu'une classe abstraite ou une Interface, de sorte que chaque Composant est une Feuille ou un Composite.
Si vous utilisez maintenant paresseux d'initialisation pour le cild ensemble de Composite, mais alors d'une façon besoin de jeter un béton de l'enfant à la Feuille ou en Composite, vous obtiendrez un Casting d'Exception parce que hibernate utilise un proxy pour le composant ne peut pas être utilisé à la Feuille ou en Composite.

Le second inconvénient du composite motif est que chaque classe sera une Feuille ou d'un Composite, pour sa durée de vie.
C'est très bien si votre structure ne change jamais. Mais il ne fonctionnera pas si une Feuille doit devenir un Composite parce que quelqu'un veut ajouter un sous-nœud feuille.

Donc, si vous avez une certaine structure dynamique, je vous recommande un Nœud de classe qui ont une bidirectionnel plusieurs information des relations entre le parent et l'enfant nœuds.
La relation doit être bidirectionnel, si vous avez souvent besoin d'accéder à des parents ou de l'enfant dans votre code.
Le maintien de cette relation est un peu difficile, alors j'ai décidé de poster un peu plus de code.

@Entity
public class Domain {
@Id
private long id;
/** The parent domain, can be null if this is the root domain. */
@ManyToOne
private Domain parent;
/**
* The children domain of this domain.
* 
* This is the inverse side of the parent relation.
* 
* <strong>It is the children responsibility to manage there parents children set!</strong>
*/
@NotNull
@OneToMany(mappedBy = "parent")
private Set<Domain> children = new HashSet<Domain>();
/**
* Do not use this Constructor!
* Used only by Hibernate.
*/
Domain() {
}
/**
* Instantiates a new domain.
* The domain will be of the same state like the parent domain.
*
* @param parent the parent domain
* @see Domain#createRoot()
*/
public Domain(final Domain parent) {
if(parent==null) throw new IllegalArgumentException("parent required");
this.parent = parent;
registerInParentsChilds();
}
/** Register this domain in the child list of its parent. */
private void registerInParentsChilds() {
this.parent.children.add(this);
}
/**
* Return the <strong>unmodifiable</strong> children of this domain.
* 
* @return the child nodes.
*/
public Set<Domain> getChildren() {
return Collections.unmodifiableSet(this.children);
}        
/**
* Move this domain to an new parent domain.
*
* @param newParent the new parent
*/
public void move(final Domain newParent)  {
Check.notNullArgument(newParent, "newParent");
if (!isProperMoveTarget(newParent) /* detect circles... */ ) { 
throw new IllegalArgumentException("move", "not a proper new parent", this);
}
this.parent.children.remove(this);
this.parent = newParent;
registerInParentsChilds();
}
/**
* Creates the root.
*
* @param bid the bid
* @return the domain
*/
public static Domain createRoot() {
return new Domain();
}
}

OriginalL'auteur Ralph

Il y a plusieurs possibilités, en fonction de la nature des opérations qu'il faut faire.

Le plus simple est de simplement avoir un parent-enfant, un-à-plusieurs association. En fonction de ce que vous devez faire, choisir le type approprié: unidirectionnel un-à-plusieurs, unidirectionnel plusieurs-à-un, ou bidirectionnelle.

Il est souvent utile d'avoir tous les nœuds d'un arbre ont une many-to-one relation avec le nœud racine. Ce qui permet de charger un arbre entier très facilement, en une seule requête.

OriginalL'auteur JB Nizet