HIbernate charges de sous-classes avec des classes

Je suis de l'utilisation d'Hibernate pour se connecter à ma base de données.
J'ai une structure d'héritage dans mon application.Le problème est que lorsque je fais une requête comme "de l'Animal", il fait une jointure externe gauche pour la classe Animal,de ses sous-classes et de toutes les associations pour les Animaux et de ses sous-classes.
Comment puis-je éviter cette situation.Je veux charger les données que lorsque je le spécifier par le biais d'un fetchmode dans mes critères de requête?

J'ai le même problème, j'ai simplement supposé qu'il a à faire, que les tables n'est pas très grand, je n'ai pas pris la peine d'y penser, mais serait certainement aimerais savoir si vous pouvez l'éviter.

OriginalL'auteur rima | 2010-08-05

17

Oui, Hibernate prend en charge les requêtes polymorphiques. À partir de la documentation:
14.8. Des requêtes polymorphiques

Une requête comme:
```
from Cat as cat
```
retourne les instances non seulement de Cat, mais
aussi des sous-classes comme DomesticCat.
Hibernate des requêtes nom tout Java
de classe ou d'interface dans la clause from.
La requête doit retourner les instances de tous les
les classes qui étendent cette
de classe ou de mettre en œuvre l'interface. L'
requête suivante serait de retour tous les
les objets persistants:
```
from java.lang.Object o
```
L'interface Named peut-être
mis en œuvre par les différents persistante
catégories:
```
from Named n, Named m where n.name = m.name
```
Ces deux dernières requêtes nécessitent
plus d'un SQL SELECT. Cela signifie
que la clause order by n'est pas
ordonner correctement les résultats ensemble.
Cela signifie également que vous ne peut pas appeler ces
requêtes à l'aide de Query.scroll().
C'est le comportement par défaut (appelé implicite polymorphisme) et Hibernate supporte à la fois implicite et explicite polymorphisme:

Implicite polymorphisme signifie que les instances de la classe sera
retournées par une requête que les noms de tout
super-classe ou interface implémentée ou
de la classe, et que les instances de tout
sous-classe de la classe sera retourné
par une requête, que le nom de la classe
lui-même. Explicite polymorphisme signifie
que des instances de classe sera retourné
seulement par des requêtes explicitement le nom de
que classe. Les requêtes de ce nom la
la classe sera de retour que les instances de
les sous-classes mappées à l'intérieur de ce
<class> déclaration en tant que
<subclass> ou <joined-subclass>.
Pour la plupart des fins, la valeur par défaut
polymorphism="implicit" est
approprié. Explicite polymorphisme est
utile lorsque deux classes sont
mappé à la même table, Ce qui permet une
"léger" de la classe qui contient une
sous-ensemble des colonnes de la table.

Cela peut être configuré au niveau de la classe. Utilisation polymorphism="explicit" si vous êtes si vous utilisez des mappages xml, voir 5.1.3 Classe. L'utilisation de Hibernate @Entity annotation si vous utilisez des annotations, voir 2.4.1. Entité. Ci-dessous un exemple:
```
@javax.persistence.Entity
@org.hibernate.annotations.Entity(polymorphism = PolymorphismType.EXPLICIT)
@Inheritance(strategy = InheritanceType.JOINED)
public class Foo {
    ...
}
```
OriginalL'auteur Pascal Thivent
3

Supposons que vous disposez d'une structure de classe comme suit:
```
class Animal { }

class Dog : Animal { }

class Cat : Animal { }
```
puis lorsque vous sélectionnez tous les Animals, vous vous attendez à charger tous les Dogs et Cats. Après tout, ils sont Animals.

Une autre histoire sont les associations. Vous pouvez créer, vous mappages tels que les associations sont paresseux de charge au lieu d'désireux de charge.

Merci John. J'ai reçu votre point. pouvez-vous laissez-moi savoir ce que vous devez spécifier dans le fichier de mappage de sorte que l'association est chargé ,uniquement lorsque cela est requis par fetchmode. Le problème, je suis confronté actuellement, c'est que, quand je suis le chargement de la super-classe,il est également le chargement de la associations de la sous-classe.Je veux éviter de le faire
Pour le chargement paresseux de un-à-un, voir: community.jboss.org/wiki/... ou stackoverflow.com/questions/389026/... Pour le chargement paresseux de un-à-plusieurs, voir nhforge.org/doc/nh/en/index.html#collections-lazy
Ce serait le travail pour les associations (a-relations). Serait-il travailler pour des requêtes Polymorphiques (est-un)?

OriginalL'auteur Manfred
0

Fondamentalement, c'est la valeur par défaut de l'ORM de l'héritage de modèle de conception utilisé par Hibernate appelé l'héritage de classe (toutes les classes sont mappés à un seul tableau), si vous voulez changer ce que vous pouvez google:

- classe unique hierarhy ou une table par classe (cette carte a chaque classe à une autre table dans la DB)

en béton de classe hierarhy (cette carte ne la des implémentations concrètes à une table).

Des requêtes polymorphiques juste se produit, les différentes stratégie de l'héritage, il suffit de fournir une bonne ou une mauvaise technique. Mon point est que la modification de la stratégie de l'héritage de ne pas désactiver les requêtes polymorphiques.

OriginalL'auteur Mateusz Dymczyk

Pour éviter de multiples rejoint au cours de la classe de la hiérarchie de l'extraction, vous pouvez appliquer SINGLE_TABLE hiérarchie stratégie de mapping, et de définir des tableaux secondaires sur les sous-classes avec chargement par SELECT stratégie. Cependant, ce que vous avez fait "lourd rejoindre le" modèle "N+1 sélectionnez" modèle. L'exemple:

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = Super.DISCRIMINATOR_COLUMN, discriminatorType = DiscriminatorType .STRING, length = 255)
public class Super {
public static final String DISCRIMINATOR_COLUMN = "classname";
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
protected long id;
@Column(updatable = false, insertable = false)
protected String classname;
protected String superProp = "superProp";
public long getId() {
return id;
}
public String getClassname() {
return classname;
}
public String getSuperProp() {
return superProp;
}
public void setSuperProp(String superProp) {
this.superProp = superProp;
}
}
@Entity
@SecondaryTable(name = SubA.TABLE)
@Table(appliesTo = SubA.TABLE, fetch = FetchMode.SELECT)
public class SubA extends Super {
public static final String TABLE = "SUBA";
@Column(table = TABLE)
protected String subAProp = "subAProp";
public String getSubAProp() {
return subAProp;
}
public void setSubAProp(String subAProp) {
this.subAProp = subAProp;
}
}
@Entity
@SecondaryTable(name = SubB.TABLE)
@Table(appliesTo = SubB.TABLE, fetch = FetchMode.SELECT)
public class SubB extends Super {
public static final String TABLE = "SUBB";
@Column(table = TABLE)
protected String subBProp = "subBProp";
public String getSubBProp() {
return subBProp;
}
public void setSubBProp(String subBProp) {
this.subBProp = subBProp;
}
}

Et ce que SQL est fait sur from Super requête HQL:

select [...] from SUPER super0_
select super_1_.subaprop as subaprop1_83_ from SUBA super_1_ where super_1_.id=1
select super_2_.subbprop as subbprop1_84_ from SUBB super_2_ where super_2_.id=2

Plus sur cette approche générale et hibernate performance de conseils, que vous pouvez lire dans mon article.

OriginalL'auteur Łukasz Frankowski

Vous devez vous connecter pour publier un commentaire.

14.8. Des requêtes polymorphiques