Hibernate one-to-one entity association with shared PK between 3 classes

I want a unidirectional one-to-one relationship between objects of 3 java classes: Person to Heart, and Person to Liver. I want the objects to share the same PK i.e. every person has a corresponding heart and liver, where person.person_id = heart.heart_id = liver.liver_id. I do not want to merge the 3 tables into 1 because each has loads of fields. Here's my code (mostly based on the accepted answer for this question):

@Entity
public class Person {
   public long personId;
   private String name;
   public Heart heart;
   public Liver liver;
   // other fields

   @Id
   @GeneratedValue
   public long getPersonId() {return personId;}

   @OneToOne(cascade = CascadeType.ALL)
   @PrimaryKeyJoinColumn
   public Heart getHeart() {return heart;}

   @OneToOne(cascade = CascadeType.ALL)
   @PrimaryKeyJoinColumn
   public Liver getLiver() {return liver;}

   // other getters and setters and constructors
}


@Entity
public class Heart {
   private long heartId;
   private int bpm;
   private Person person;
   // other fields

   @Id
   @GenericGenerator(
      name = "generator",
      strategy = "foreign",
      parameters = @Parameter(name = "property", value = "person")
   )
   @GeneratedValue(generator = "generator")
   public long getHeartId() {return heardId;}

   @OneToOne(mappedBy="heart")
   @PrimaryKeyJoinColumn
   public Person getPerson() {return person;}

   // other getters and setters and constructors
}


@Entity
public class Liver {
   private long liverId;
   private boolean healthy;
   private Person person;
   // other fields

   // the rest uses the same hibernate annotation as Heart
}

I setup the session and do the following:

Person jack = new Person();
jack.setName("jack");
Heart heart = new Heart();
heart.setBpm(80);
Liver liver = new Liver();
liver.setHealthy(true);

Then if I link up the person object with it's organs, and save it, I get an error (NOTE: I got the same behaviour when I just used 2 classes e.g. Person and Heart):

开发者_运维问答jack.setHeart(heart);
jack.setLiver(liver);
session.save(jack);

org.hibernate.id.IdentifierGenerationException: attempted to assign id from null one-to-one property: person

However it works if I set the relationship both ways:

jack.setHeart(heart);
heart.setPerson(jack);
jack.setLiver(liver);
liver.setPerson(jack);
session.save(jack);

But surely this should not be necessary for unidirectional relationships?

Cheers

ps. Oddly enough, I notice it works (saves both objects to the DB) when I just use 2 classes e.g. Person and Heart, and I just set the link the other way:

heart.setPerson(jack);
session.save(heart);

I have no idea why this works (it seems logical to me that Person is the parent object, as it auto-generates it's own PK, and the others use that; so that's all you should have to setup), but anyway I cannot figure out how to apply this working method to my 3-class situation...

I hate to tell you this, but you have a bi-directional relationship there. The Person has a reference to the Heart and Liver and each of those have a reference back to the Person. The annotations that you have set up on the Id properties of your Heart and Liver are specifically saying that they get the value of their Id property by delegating to their Person property. In the examples that you've shown that don't work, you haven't set the Person property on those guys yet and so, they obviously cannot obtain their Id value.

You can either set this relationship up as a true unidirectional OneToOne, which is documented in the Hibernate annotations documentation:

@Entity
public class Body {
    @Id
    public Long getId() { return id; }

    @OneToOne(cascade = CascadeType.ALL)
    @PrimaryKeyJoinColumn
    public Heart getHeart() {
        return heart;
    }
    ...
}


@Entity
public class Heart {
    @Id
    public Long getId() { ...}
}

or you can change our entity objects slightly to streamline hooking up both sides of the relationship such as:

@Entity
public class Person {
   public long personId;
   private String name;
   public Heart heart;
   public Liver liver;
   // other fields

   @Id
   @GeneratedValue
   public long getPersonId() {return personId;}

   @OneToOne(cascade = CascadeType.ALL)
   @PrimaryKeyJoinColumn
   public Heart getHeart() {return heart;}

   public void setHeart(Heart heart){
      this.heart = heart;
      this.heart.setPerson(this);
   }

   @OneToOne(cascade = CascadeType.ALL)
   @PrimaryKeyJoinColumn
   public Liver getLiver() {return liver;}

   public void setLiver(Liver liver){
      this.liver = liver;
      this.liver.setPerson(this);
   }
   // other getters and setters and constructors
}

I didn't try it, but I would say that ....

A difference between both sides is that the Person class has no mappedBy in his mapping.

So, for each One-To-One, Person has the reference value, the one that Hibernate consider as official. On the contrary, on the other objects, the mappedBy indicates to Hibernate to not use the value, but go to that object and consider the mapped property on the that object.

To check if I'm right, you could set only the values that have no mappedBy, and save the Person object (because it is the one that has the cascades), and see if the result is correct.. ;-)