La cartographie multi-Niveau de l'héritage en veille prolongée avec des Annotations

Prendre la situation répertoriés dans cette question:

La cartographie multi-Niveau de l'héritage en veille prolongée

Comment cette cartographie être fait avec des Annotations plutôt que d'une hbm fichier?

OriginalL'auteur evan.leonard | 2009-12-10

  1. 10

    Ce que précisément vous avez des problèmes avec? Cartographie de la hiérarchie de classes via rejoint les sous-classes est assez simple:

    @Entity
@Inheritance(strategy=InheritanceType.JOINED)
public class A implements Serializable { ... }

@Entity
public class B extends A { ... }

@Entity
@PrimaryKeyJoinColumn(name="A_ID")
public class C extends A { ... }

@Entity
@PrimaryKeyJoinColumn(name="B_ID")
public class D extends B { ... }

    Mise à jour (basé sur Michal commentaire).

    Dans le cas où vous voulez utiliser des discriminateurs (et vous devriez avoir une bonne raison de le faire), il est possible de le faire en mélangeant table par classe-une stratégie de hiérarchie avec tableaux secondaires:

    @Entity
@Table(name="A_table")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="entity_type")
@DiscriminatorValue("A")
public class A implements Serializable { ... }

@Entity
@SecondaryTable(name="B_table")
public class B extends A { ... }

@Entity
@SecondaryTable(name="C_table", pkJoinColumns={
    @PrimaryKeyJoinColumn(name="A_ID", referencedColumnName="ID")
))
public class C extends A { ... }

@Entity
@SecondaryTable(name="D_table", pkJoinColumns={
    @PrimaryKeyJoinColumn(name="B_ID", referencedColumnName="ID")
))
public class D extends B { ... }

    L'inconvénient de cette approche est que vous aurez à spécifier explicitement la table pour chaque propriété mappé:

    public class D extends B {
  @Column(table="D_table")
  private String someProperty;

  ...
}
    Je pense que ce n'était pas la question. Il veut utiliser le discriminant de colonnes que j'ai compris. C'est la raison de ma réponse acheter vous êtes réputation ici est beaucoup plus élevé, donc je pourrais très bien être mal 🙂
    L'OP ne mentionne pas le discriminant de n'importe où. La Question qu'il a lié pour dit discriminateur est utilisé pour des raisons historiques, mais de ne pas dire qu'il veut continuer de les utiliser. En tout cas, si l'OP n'souhaitez utiliser les discriminateurs il est facilement possible - j'ai mis à jour ma réponse à montrer un exemple.
    S'avère que j'étais sur la bonne piste, mais a eu un problème dans ma hbm qui a causé mes annotations pour ne pas être pris. Merci pour la réponse en tout cas. Cheers!
    Une question cependant, pourquoi dites-vous "vous devriez avoir un bon raison" d'utiliser les discriminateurs? Notre application a plus d'une utilisation de la cartographie des classes à un seul tableau à l'aide de discriminateurs. Semble fonctionner très bien. Quel est l'inconvénient que vous faites référence?
    À l'aide de la table par hiérarchie de la stratégie est très bien; l'inconvénient est d'avoir plusieurs valeurs null dans chaque ligne (et dans l'incapacité d'avoir des non-null de contraintes sur la non-root classes). A l'aide du tableau par le béton de classe de la stratégie est bien aussi; l'inconvénient est rejoint. Lorsque vous combinez les deux, vous obtenez le pire des deux mondes et il y a rarement une raison de faire de cette façon.

    OriginalL'auteur ChssPly76

  2. 0

    L'héritage entre @Entity classes annotées est repris automatiquement. Donc, si vous avez Une classe est annotée et de la classe B est également annoté avec @Entité et s'étend, et C extends B et est également @Entity annoté tous seront ramassés.

    Je n'ai pas utilisé rejoint les sous-classes combinées avec discriminateur de valeurs, mais je suis sûr qu'il sera très similaire à ce qui se fait en XML à l'aide du @DiscriminatorColumn et @DiscriminatorValue)

    Ceci est incorrect. Il y a une grande différence entre le polymorphisme implicite vous faites référence et fait mappage de classe de la hiérarchie.
    Pouvez-vous élaborer sur cette déclaration? Je n'étais pas au courant que je faisait allusion implicite polymorphisme, n'étais-je vouloir. Je voulais décrire une hiérarchie A < B <- C...
    "L'héritage entre @Entity annoté classes est ramassé automatiquement" - c'est implicite polymorphisme. Pour la carte de la classe réelle hiérarchie, vous devez explicitement annoté de la racine de la classe à @Inheritance (plus utiliser des annotations supplémentaires en fonction de la stratégie sélectionnée).

    OriginalL'auteur Fried Hoeben

  3. 0

    C'est exactement la chose qui a bien fonctionné pour moi:

    @Entity
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name="LoanType",discriminatorType="String")
@Table(name = "A")
public class A implements Serializable{
}

@Entity
@Table(name= "B")
@PrimaryKeyJoinColumn(name = "B_ID", referencedColumnName ="A_ID")
public class B extends A{
}


@Entity
@Table(name= "C")
@PrimaryKeyJoinColumn(name = "C_ID", referencedColumnName = "B_ID")
public class C extends B{}

    OriginalL'auteur KayV