Hibernate学习笔记之ORM实体间关系“OneToOne”详解

最新推荐文章于 2020-11-14 22:26:23 发布

Aaron-SCUT

最新推荐文章于 2020-11-14 22:26:23 发布

阅读量1.9k

点赞数

CC 4.0 BY-SA版权

分类专栏： Hibernate java 文章标签： hibernate 数据库 java orm 对象

本文链接：https://blog.youkuaiyun.com/qq_27606119/article/details/52170555

Hibernate 同时被 2 个专栏收录

7 篇文章

订阅专栏

java

5 篇文章

订阅专栏

本文深入探讨了Hibernate中的一对一对象关系映射，包括单向外键、双向外键、联合主键和组件关联四种情况，通过Annotation和XML配置文件的方式进行了示例说明。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

我们知道ORM是对象—关系映射的意思，是沟通对象和底层关系数据库之间的桥梁，可以简单的将对象和关系数据库中的表对应起来，在关系数据库中，不同的表之间存在不同的关系，比如一对一，一对多，多对多等，那怎样用Java语言在上层对底层关系进行实现呢，我们本文来详细讲述一下。

一对一的映射关系
一对一的映射关系应该是最简单最基础的一种映射关系了，我们现实生活中有很多一对一映射关系的例子，最典型的就是一个人对应一个身份证号码，这里我们就用这个例子作为我们的讲述基础。

注意：本文所有的实例都将采用两种实现方法：Annotation注释和Xml配置文件方式，以供自己和大家深入理解。

1.1 一对一单向外键（Annotation）
单向外键的意思就是一个实体通过外键关联到另一个实体的主键。注：一对一，则外键必须为唯一约束。也就是说，映射关系交给一方来维护。

我们这里新建两个实体类：Students和IdCard，并且Students通过外键关联到IdCard的主键。

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

@Entity
public class Students {
    private int sid;
    private String sname;   
    private IdCard cardId;

    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="pid",unique=true)//关联到IdCard的主键pid
    public IdCard getCardId() {
        return cardId;
    }
    public void setCardId(IdCard cardId) {
        this.cardId = cardId;
    }

    @Id
    @GeneratedValue
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
}

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

import org.hibernate.annotations.GenericGenerator;

@Entity
public class IdCard {

    private String pid;//身份证号码
    private String province;//省份

    @Id
    @GeneratedValue(generator="pid")//generator指明主键生成器的名称
    @GenericGenerator(name="pid",strategy="assigned")
    //@GenericGenerator为hibernate特有的注解方式，使其可以使用主键生成策略assigned
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
}

然后执行SchemaExport():

@Test
    public void testSchemaExport() {

        SchemaExport se = new SchemaExport(new AnnotationConfiguration().configure());
        se.create(true, true);
        //第一个true就是把DDL语句输出到控制台，第二个true就是根据持久化类和映射文件先执行删除再执行创建操作
    }

执行结果为：
这里写图片描述
可以看到：students表中插入了pid外键，而pid是idcard表的主键，这样两者就关联起来了。

现在，我们向两个表中插入数据：

@Test
    public void testSave() {

        Session session = sessionFactory.getCurrentSession();
        Transaction tx = session.beginTransaction();

        try {

            IdCard c = new IdCard();
            c.setPid("8888888888888888888");
            c.setProvince("guangdong");
            Students s = new Students();
            s.setSname("zhangsan");
            s.setCardId(c);

            session.save(c);
            //先保存外键对象
            session.save(s);
            //再保存主对象

            tx.commit();            

        } catch (Exception e) {         
            e.printStackTrace();
            tx.rollback();          
        }   
    }

执行结果为：
这里写图片描述

1.2 一对一单向外键（XML）
前面已经使用Annotation注解的方式实现了OneToOne关联方式，现在来简单介绍以下怎样通过配置文件，也就是*.hbm.xml，来达到相同的目的。

Students.hbm.xml的配置：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-7-26 21:10:34 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
 <class name="persistence_class_fk.Students" table="students">
  <id name="sid" type="int">
   <column name="sid"/>
   <generator class="native"/>
  </id>
  <property generated="never" lazy="false" name="sname" type="string">
   <column name="sname"/>
  </property>

  <!-- 一对一单向外键   主控方配置   name表示受控方对象  column表示关联的外键-->
  <many-to-one name="cardId" column="pid" unique="true"/>

 </class>
</hibernate-mapping>

IdCard.hbm.xml的配置：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-7-26 21:10:34 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
 <class name="persistence_class_fk.IdCard" table="idcard">
  <id name="pid" type="string">
   <column name="pid"/>
   <generator class="assigned"/>
  </id>
  <property generated="never" lazy="false" name="province" type="string">
   <column name="province"/>
  </property>
 </class>
</hibernate-mapping>

关键的文件配置已经完成，其他操作和Annotation几乎相同，这里就不再赘述。

2.1 一对一双向外键关联（Annotation）
“双向一对一”顾名思义就是两者都可以持有对方的控制权，但是呢一次，也就是一次实现过程，一次数据持久化，控制权只能交给一方，不可能双方都设置外键保存关联关系，否则双方都无法保存，这一点要特别注意。

双向关联必须设置mappedBy属性（基于外键的双向关联）：
在主控方设置：@OneToOne
在被控方设置：@OneToOne(mappedBy=”对方的关联属性名”)
（注：还有一种是基于主键的双向关联，我们这里就不涉及了，大家可以自己做做看，网上有相关资料。）

我们还是首先创建实体类IdCard和Students：

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

@Entity
public class Students {
    private int sid;
    private String sname;   
    private IdCard cardId;

    @OneToOne(mappedBy="stu")
    //只要是双向关联，就一定要指定mappedBy，这里将控制权交给IdCard
    //@OneToOne(cascade=CascadeType.ALL)
    //@JoinColumn(name="pid",unique=true)
    public IdCard getCardId() {
        return cardId;
    }
    public void setCardId(IdCard cardId) {
        this.cardId = cardId;
    }

    @Id    //当主键为int类型时，主键生成策略默认为：native
    @GeneratedValue
    //@GeneratedValue(strategy=GenerationType.AUTO)
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
}

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

import org.hibernate.annotations.GenericGenerator;


@Entity
public class IdCard {

    private String pid;//身份证号码
    private String province;//省份
    private Students stu;

    //@OneToOne(mappedBy="cardId")
    //只要是双向关联，就一定要指定mappedBy，这里将控制权交给Students

    @OneToOne(cascade=CascadeType.ALL)
    //这种情况是IdCard作为主控方的测试
    public Students getStu() {
        return stu;
    }
    public void setStu(Students stu) {
        this.stu = stu;
    }

    @Id
    @GeneratedValue(generator="pid")
    @GenericGenerator(name="pid",strategy="assigned")
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
}

然后执行SchemaExport()：

@Test
    public void testSchemaExport() {

        SchemaExport se = new SchemaExport(new AnnotationConfiguration().configure());
        se.create(true, true);
        //第一个true就是把DDL语句输出到控制台，第二个true就是根据持久化类和映射文件先执行删除再执行创建操作
    }

执行结果：
这里写图片描述
可以看到，控制权是在IdCard的手中。

现在，我们向两个表中插入数据：

@Test
    public void testSave() {

                Session session = sessionFactory.getCurrentSession();
        Transaction tx = session.beginTransaction();

        try {

            //此种情况为将Students的控制权交给IdCard
            Students s = new Students();
            s.setSname("lisi");
            IdCard c = new IdCard();
            c.setPid("6666666666666666");
            c.setProvince("shanghai");
            c.setStu(s);

            session.save(s);
            session.save(c);

            tx.commit();

        } catch (Exception e) {

            e.printStackTrace();
            tx.rollback();          
        }   
    }

执行结果为：
这里写图片描述
我们可以看到数据已经插入了。

2.2 一对一双向外键关联（XML）
这里我们的配置文件分别为：
Students.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-7-26 21:10:34 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
 <class name="persistence_class_bfk.Students" table="students">
  <id name="sid" type="int">
   <column name="sid"/>
   <generator class="native"/>
  </id>
  <property generated="never" lazy="false" name="sname" type="string">
   <column name="sname"/>
  </property>

  <!--Students为受控方-->
  <one-to-one name="cardId" property-ref="stu" />

 </class>
</hibernate-mapping>

IdCard.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-7-26 21:10:34 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
 <class name="persistence_class_bfk.IdCard" table="idcard">
  <id name="pid" type="string">
   <column name="pid"/>
   <generator class="assigned"/>
  </id>
  <property generated="never" lazy="false" name="province" type="string">
   <column name="province"/>
  </property>

  <!--IdCard为主控方：将控制权交给IdCard中的stu-->
  <many-to-one name="stu" column="sid" unique="true"/>
 </class>
</hibernate-mapping>

3.1 一对一单向外键联合主键（Annotation）
所谓主键就是可以唯一确定该行数据，由此可以知道，当一个字段不能决定该行的值时，就要考虑采用多个字段作为主键。比如，对于学校来说，班号可以决定班级，但是决定不了班级里的某个人，表示班级里的某个人就需要用班号+该学生在该班内的编号（当然也可以用唯一的学号来决定，这里只是举个例子）。
我们实际基于Hibernate实现联合主键的时候，要经历的步骤为：
1.创建主键类；
2.主键类必须实现serializable接口，重写hashcode()和equals()方法；
3.主键类要用@Embeddable标注，实体类使用@EmbeddedId标注。

我们首先创建主键类IdCardPK：

import java.io.Serializable;

import javax.persistence.Embeddable;

//身份证主键类

@Embeddable
public class IdCardPK implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String pid;//身份证号码
    private String bloodType;//血型


    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getBloodType() {
        return bloodType;
    }
    public void setBloodType(String bloodType) {
        this.bloodType = bloodType;
    }
}

再创建实体类IdCard：

import javax.persistence.CascadeType;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

import org.hibernate.annotations.GenericGenerator;


@Entity
public class IdCard {

    private IdCardPK pk;
    private String province;//省份
    private Students stu;

    @OneToOne(mappedBy="cardId")//只要是双向关联，就一定要指定mappedBy，这里将控制权交给Students
    public Students getStu() {
        return stu;
    }
    public void setStu(Students stu) {
        this.stu = stu;
    }

    @EmbeddedId
    public IdCardPK getPk() {
        return pk;
    }
    public void setPk(IdCardPK pk) {
        this.pk = pk;
    }

    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return super.hashCode();
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return super.equals(obj);
    }
}

再创建实体类Students：

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.OneToOne;

@Entity
public class Students {
    private int sid;
    private String sname;   
    private IdCard cardId;


    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumns({
        @JoinColumn(name="pid",referencedColumnName="pid"),
        @JoinColumn(name="bloodType",referencedColumnName="bloodtype")
    })
    public IdCard getCardId() {
        return cardId;
    }
    public void setCardId(IdCard cardId) {
        this.cardId = cardId;
    }

    @Id    //当主键为int类型时，主键生成策略默认为：native
    @GeneratedValue
    //@GeneratedValue(strategy=GenerationType.AUTO)
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
}

执行SchemaExport()：

@Test
    public void testSchemaExport() {

        SchemaExport se = new SchemaExport(new AnnotationConfiguration().configure());
        se.create(true, true);
        //第一个true就是把DDL语句输出到控制台，第二个true就是根据持久化类和映射文件先执行删除再执行创建操作
    }

执行结果为：
这里写图片描述
可以看到，idcard表中有两个主键bloodType和pid作为联合主键，而在students表中使用联合主键作为外键。

我们执行插入数据的操作：

@Test
    public void testSave() {


        Session session = sessionFactory.getCurrentSession();
        Transaction tx = session.beginTransaction();


        try {

            IdCardPK pk = new IdCardPK();
            pk.setBloodType("A");
            pk.setPid("5555555555555555");

            IdCard c = new IdCard();
            c.setPk(pk);
            c.setProvince("beijing");

            Students s = new Students();
            s.setSname("zhaoliu");
            s.setCardId(c);

            session.save(c);
            session.save(s);

            tx.commit();


        } catch (Exception e) {

            e.printStackTrace();
            tx.rollback();          
        }   
    }

执行结果为：
这里写图片描述
这就和我们预期的是一样的了。

3.2 一对一单向外键联合主键（XML）
IdCard.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-7-26 21:10:34 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
 <class name="persistence_class_ufk.IdCard" table="idcard">

  <!--关键语句，composite为混合，综合的意思，这里指代联合主键-->
 <composite-id name="pk" class="persistence_class_ufk.IdCardPK">
 <key-property name="pid" column="pid" type="string" />
 <key-property name="bloodType"  type="string" />
 <generator class="assigned"></generator>
 </composite-id>

 <property name="province" column="province" type="string" />

 </class>
</hibernate-mapping>

Students.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-7-26 21:10:34 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
 <class name="persistence_class_ufk.Students" table="students">
  <id name="sid" type="int">
   <column name="sid"/>
   <generator class="native"/>
  </id>
  <property generated="never" lazy="false" name="sname" type="string">
   <column name="sname"/>
  </property>

  <!--关键语句-->
  <many-to-one name="cardId">
  <column name="pid" unique="true" />
  <column name="bloodid" />
  </many-to-one>

 </class>
</hibernate-mapping>

4.1 一对一组件关联（Annotation）
组件类就是一个POJO类，被嵌入在一个实体类中，是一个实体类的组件部分。实体类需要使用@Embedded标注。
在Hibernate中，component是某个实体的逻辑组成部分，它与实体的根本区别是没有oid，component可以成为是值对象（DDD）。
采用component映射的好处：它实现了对象模型的细粒度划分，层次会更加分明，复用率会更高。
首先创建组件类IdCard：

//身份证类，就是一个POJO类 
public class IdCard {

    private String pid;//身份证号码
    private String province;//省份

    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
}

创建实体类Students：

import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Students {

    private int sid;
    private String sname;   
    private IdCard cardId;

    @Id
    @GeneratedValue
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }

    @Embedded
    public IdCard getCardId() {
        return cardId;
    }
    public void setCardId(IdCard cardId) {
        this.cardId = cardId;
    }   
}

执行SchemaExport()：

@Test
    public void testSchemaExport() {

        SchemaExport se = new SchemaExport(new AnnotationConfiguration().configure());
        se.create(true, true);
        //第一个true就是把DDL语句输出到控制台，第二个true就是根据持久化类和映射文件先执行删除再执行创建操作
    }

执行结果为：
这里写图片描述

我们继续执行插入数据的操作：

@Test
    public void testSave() {


        Session session = sessionFactory.getCurrentSession();
        Transaction tx = session.beginTransaction();


        try {

            IdCard c = new IdCard();
            c.setPid("11111111111111111111");
            c.setProvince("henan");
            Students s = new Students();
            s.setSname("aaron");
            s.setCardId(c);

            session.save(s);

            tx.commit();


        } catch (Exception e) {

            e.printStackTrace();
            tx.rollback();          
        }   
    }

执行结果为：
这里写图片描述

4.2 一对一组件关联（XML）
这里用配置实体类Students的xml文件就行了：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-7-26 21:10:34 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
 <class name="persistence_class_component.Students" table="students">
  <id name="sid" type="int">
   <column name="sid"/>
   <generator class="native"/>
  </id>
  <property generated="never" lazy="false" name="sname" type="string">
   <column name="sname"/>
  </property>

  <component name="cardId" class="persistence_class_component.IdCard">
  <property name="pid" column="pid" type="string"></property>
  <property name="province" type="string"></property>
  </component>

 </class>
</hibernate-mapping>