5

Take the situation listed in this question:

Mapping multi-Level inheritance in Hibernate

How would this mapping be done with Annotations rather than an hbm file?

Community
  • 1
  • 1
evan.leonard
  • 989
  • 2
  • 8
  • 10

3 Answers3

11

What specifically are you having trouble with? Mapping class hierarchy via joined subclasses is pretty straightforward:

@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 { ... }

Update (based on Michal's comment).

In case you do want to use discriminators (and you should have a good reason to do so), it's possible to do so by mixing table-per-class-hierarchy strategy with secondary tables:

@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 { ... }

The downside to this approach is you'll have to explicitly specify the table for each property mapped:

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

  ...
}
ChssPly76
  • 99,456
  • 24
  • 206
  • 195
  • I think this wasn't the question. He wants to use discriminator columns as far as I understood it. That's the reason for my answer buy you're reputation here is much higher, so I might very well be wrong :-) – Michal Bachman Dec 11 '09 at 01:15
  • @Michal - OP doesn't mention discriminator anywhere. Question he linked to says discriminator is used for historic reasons but doesn't say that he wants to keep using them. At any rate, if OP does want to use discriminators it's easily possible - I've updated my answer to show an example. – ChssPly76 Dec 11 '09 at 01:44
  • Turns out I was on the right track but had a more basic issue in my hbm that caused my annotations to not be picked up. Thanks for the clear answer anyhow. Cheers! – evan.leonard Dec 16 '09 at 17:22
  • One question though, why do you say "you should have a *good* reason" to use discriminators? Our app has more than one usage of mapping classes to a single table using discriminators. Seems to be working very well. What is the drawback you're alluding to? – evan.leonard Dec 16 '09 at 17:24
  • Using table-per-hierarchy strategy is fine; the drawback is having multiple nulls in each row (and the inability to have not-null constraints on non-root classes). Using table-per-concrete-class strategy is fine too; the drawback is joins. When you combine the two you get the worst of both worlds and there's rarely a reason to do it this way. – ChssPly76 Dec 16 '09 at 18:14
0

Inheritance between @Entity annotated classes is picked up automatically. So if you class A is annotated and class B is also annotated with @Entity and extends A, and C extends B and is also @Entity annotated all will be picked up.

I have not used joined subclasses combined with discriminator values, but I'm sure it will be very similar to what is done in XML (using @DiscriminatorColumn and @DiscriminatorValue)

Fried Hoeben
  • 3,247
  • 16
  • 14
  • This is incorrect. There is a big difference between implicit polymorphism you're alluding to and actually mapping class hierarchy. – ChssPly76 Dec 11 '09 at 00:26
  • Can you elaborate on this statement? I was not aware I was alluding to implicit polymorphism, not was I intending to. I wanted to describe a hierarchy A <- B <- C... – Fried Hoeben Dec 11 '09 at 06:22
  • "Inheritance between @Entity annotated classes is picked up automatically" - that's implicit polymorphism. In order to map the actual class hierarchy you have to explicitly annotated the root class with `@Inheritance` (plus use additional annotations depending on chosen strategy). – ChssPly76 Dec 11 '09 at 07:25
0

This is the exact thing which worked fine for me:

@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{}
KayV
  • 12,987
  • 11
  • 98
  • 148