无法在Hibernate中保存两种实体之间的一对一关系？

Question

我正在尝试使用Hibernate中的一对一映射工作，并且我感到困惑。我有两个表学生和地址映射通过一对一的关系，并为地址表设置外键。我创建了一个功能，将数据保存到数据库中，如下所示：

public static void oneToOneMappingWithXML(Session session) throws Exception { 
    StudentEntity tom = new StudentEntity(); 
    tom.setName("Tom"); 
    tom.setAge(10); 
    tom.setClazz("5B"); 
    tom.setStudentId(1); 

    AddressEntity tom_address = new AddressEntity(); 
    tom_address.setCity("New York"); 
    tom_address.setAddressId(1); 

    tom.setAddressByStudentId(tom_address); 
    //tom_address.setStudentByAddressId(tom); //#1 
    session.save(tom); 
    session.getTransaction().commit(); 
} 

这是我的映射：

<class name="com.model.xmlType.AddressEntity" table="ADDRESS" schema="CHINOOK"> 
    <id name="addressId"> 
     <column name="ADDRESS_ID" sql-type="number(10)" precision="10"/> 
    </id> 
    <property name="city"> 
     <column name="CITY" sql-type="nvarchar2(50)" length="50"/> 
    </property> 
    <one-to-one name="studentByAddressId" class="com.model.xmlType.StudentEntity"/> 
</class> 


<class name="com.model.xmlType.StudentEntity" table="STUDENT" schema="CHINOOK"> 
    <id name="studentId"> 
     <column name="STUDENT_ID" sql-type="number(10)" precision="10"/> 
    </id> 
    <property name="name"> 
     <column name="NAME" sql-type="nvarchar2(50)" length="50"/> 
    </property> 
    <property name="age"> 
     <column name="AGE" sql-type="number(10)" precision="10"/> 
    </property> 
    <property name="clazz"> 
     <column name="CLASS" sql-type="nvarchar2(10)" length="10"/> 
    </property> 
    <one-to-one name="addressByStudentId" class="com.model.xmlType.AddressEntity" cascade="all"/> 

实体类

学生：

public class StudentEntity { 
    private Integer studentId; 
    private String name; 
    private Integer age; 
    private String clazz; 
    private AddressEntity addressByStudentId; 

    public Integer getStudentId() { 
     return studentId; 
    } 

    public void setStudentId(Integer studentId) { 
     this.studentId = studentId; 
    } 

    public String getName() { 
     return name; 
    } 

    public void setName(String name) { 
     this.name = name; 
    } 

    public Integer getAge() { 
     return age; 
    } 

    public void setAge(Integer age) { 
     this.age = age; 
    } 

    public String getClazz() { 
     return clazz; 
    } 

    public void setClazz(String clazz) { 
     this.clazz = clazz; 
    } 


    public boolean equals(Object o) { 
     if (this == o) return true; 
     if (o == null || getClass() != o.getClass()) return false; 

     StudentEntity that = (StudentEntity) o; 

     if (studentId != null ? !studentId.equals(that.studentId) : that.studentId != null) return false; 
     if (name != null ? !name.equals(that.name) : that.name != null) return false; 
     if (age != null ? !age.equals(that.age) : that.age != null) return false; 
     if (clazz != null ? !clazz.equals(that.clazz) : that.clazz != null) return false; 

     return true; 
    } 

    public int hashCode() { 
     int result = studentId != null ? studentId.hashCode() : 0; 
     result = 31 * result + (name != null ? name.hashCode() : 0); 
     result = 31 * result + (age != null ? age.hashCode() : 0); 
     result = 31 * result + (clazz != null ? clazz.hashCode() : 0); 
     return result; 
    } 

    public AddressEntity getAddressByStudentId() { 
     return addressByStudentId; 
    } 

    public void setAddressByStudentId(AddressEntity addressByStudentId) { 
     this.addressByStudentId = addressByStudentId; 
    } 
} 

地址：

public class AddressEntity { 
    private Integer addressId; 
    private String city; 
    private StudentEntity studentByAddressId; 

    public Integer getAddressId() { 
     return addressId; 
    } 

    public void setAddressId(Integer addressId) { 
     this.addressId = addressId; 
    } 

    public String getCity() { 
     return city; 
    } 

    public void setCity(String city) { 
     this.city = city; 
    } 

    @Override 
    public boolean equals(Object o) { 
     if (this == o) return true; 
     if (o == null || getClass() != o.getClass()) return false; 

     AddressEntity that = (AddressEntity) o; 

     if (addressId != null ? !addressId.equals(that.addressId) : that.addressId != null) return false; 
     if (city != null ? !city.equals(that.city) : that.city != null) return false; 

     return true; 
    } 

    @Override 
    public int hashCode() { 
     int result = addressId != null ? addressId.hashCode() : 0; 
     result = 31 * result + (city != null ? city.hashCode() : 0); 
     return result; 
    } 

    public StudentEntity getStudentByAddressId() { 
     return studentByAddressId; 
    } 

    public void setStudentByAddressId(StudentEntity studentByAddressId) { 
     this.studentByAddressId = studentByAddressId; 
    } 
} 

它工作得很好，两个实体都保存了。但是，当＃1行未注释时，只有实体学生会保存。代码如下：

public static void oneToOneMappingWithXML(Session session) throws Exception { 
    StudentEntity tom = new StudentEntity(); 
    tom.setName("Tom"); 
    tom.setAge(10); 
    tom.setClazz("5B"); 
    tom.setStudentId(1); 

    AddressEntity tom_address = new AddressEntity(); 
    tom_address.setCity("New York"); 
    tom_address.setAddressId(1); 

    tom.setAddressByStudentId(tom_address); 
    tom_address.setStudentByAddressId(tom); //#1 
    session.save(tom); 
    session.getTransaction().commit(); 
} 

我不知道为什么。那么，有人可以向我解释吗？

Answer 1

请注意，当您仅在一侧设置引用时，Hibernate不会自动使对象引用成为双向对象。因此，你必须确保，在双向参考，双方得到正确设置之前坚持。

尝试将实体看作数据库中的记录而不是对象。如果对象“汤姆”不知道，他甚至有一个地址，“汤姆”被要求坚持自己，“汤姆”如何坚持他的地址？ （实际上，你可以用保存没有地址的“tom”，然后保存一个引用“tom”的地址;然后，如果你重新加载“tom”，他会突然有一个地址，因为数据库没关系的关系有哪个方向，但你不应该这样做。）

总是正确初始化两侧的双向参考，你应该是好的。

Answer 2

session.save(tom_address); 
session.save(tom); 
session.getTransaction().commit(); 

在保存学生之前保存地址。