Hibernate入门（七）Hibernate关联映射

最新推荐文章于 2023-04-06 19:13:24 发布
最新推荐文章于 2023-04-06 19:13:24 发布
阅读量308 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21046965/article/details/86660936
版权

前言

      本章讲解Hibernate的关联关系及其配置方式

方法

1.一对一关联关系

我们之前学过MyBatis，也了解了其关联关系的配置方式。那么Hibernate该如何配置呢？首先我以一对一关联进行讲解！

范例：人和身份证的关系

人和身份证是一对一的关系，也就是说一个人只能拥有一个身份证，一个身份证只属于一个人！

那么，我们首先先建立两个实体类，Person和IDCard，示例代码如下：

package cn.edu.ccut.bo;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.io.Serializable;

@Entity
public class Person implements Serializable {
    @Id
    @GenericGenerator(name = "uuid",strategy = "uuid")
    @GeneratedValue(generator = "uuid")
    private String id;
    private String name;

    public Person() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
package cn.edu.ccut.bo;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.io.Serializable;

@Entity
public class IDCard implements Serializable {

    @Id
    @GenericGenerator(name = "uuid",strategy = "uuid")
    @GeneratedValue(generator = "uuid")
    private String id;
    private String code;

    public IDCard() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "IDCard{" +
                "id='" + id + '\'' +
                ", code='" + code + '\'' +
                '}';
    }
}

1）单向一对一关联

我们在Person类中加入关联属性idCard如下：

这个时候，我们需要添加一对一关联关系所使用的注解，那就是@OneToOne

@OneToOne注解解释：

  • cascade:关联属性，这个属性定义了当前类对象操作了之后，级联对象的操作。其中CascadeType.ALL，当前类增删改查改变之后，关联类跟着增删改查。
  • fetch属性：FetchType类型的属性。可选择项包括：FetchType.EAGER 和FetchType.LAZY。  FetchType.EAGER表示关系类在主类加载的时候同时加载，FetchType.LAZY表示关系类在被访问时才加载。默认值是FetchType.LAZY。
  • mappedBy:拥有关联关系的域，如果关系是单向的就不需要，双向关系表，那么拥有关系的这一方有建立、解除和更新与另一方关系的能力，而另一方没有，只能被动管理，这个属性被定义在关系的被拥有方。

这个时候我们通过@OneToOne注解配置Person如下：

package cn.edu.ccut.bo;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.io.Serializable;

@Entity
public class Person implements Serializable {
    @Id
    @GenericGenerator(name = "uuid",strategy = "uuid")
    @GeneratedValue(generator = "uuid")
    private String id;
    private String name;
    @OneToOne(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    private IDCard iDCard;

    public IDCard getIDCard() {
        return iDCard;
    }

    public void setIDCard(IDCard iDCard) {
        this.iDCard = iDCard;
    }

    public Person() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", iDCard=" + iDCard +
                '}';
    }
}

我们在hibernate.cfg.xml配置如下：

<!-- 自动创建|更新|验证数据库表结构 create表示每次删除表新建表，update表示没表新建表，有表直接更新 -->
<property name="hbm2ddl.auto">create</property>

<!-- 配置映射文件路径 -->
<mapping class="cn.edu.ccut.bo.Person"/>
<mapping class="cn.edu.ccut.bo.IDCard"/>

编写测试类如下：

import cn.edu.ccut.bo.IDCard;
import cn.edu.ccut.bo.Person;
import cn.edu.ccut.util.DBUtil;
import org.hibernate.Session;
import org.junit.Test;

public class HibernateTest {

    @Test
    public void testHibernateConfig() throws Exception{
        //创建Session对象
        Session session = DBUtil.getSession();
        //开启事务
        session.beginTransaction();
        IDCard idCard = new IDCard();
        idCard.setCode("123143");
        Person person = new Person();
        person.setName("张三");
        person.setIDCard(idCard);
        session.save(idCard);
        session.save(person);
        session.getTransaction().commit();
       /* Person person = (Person) session.get(Person.class, "297ebee0688a626701688a6269090000");
        System.out.println(person);*/
        DBUtil.close();
    }
}

执行结果如下：

我们通过上面的结果可以发现，默认创建的关联列名称为  关联表名称_关联表主键

但是，一般情况下，我们的关联字段的设置是自定义的，那么可以使用@JoinColumn注解

@JoinColumn注解解释：

  • name：定义关联字段的名称
  • referencedColumnName：定义参照表的字段（参照表主键）

使用该注解示例如下：

执行结果如下：

  

2）双向一对一关联

有些时候，我们需要通过人查到其身份证信息，通过身份证信息查到其人员信息，那么就需要双向的一对一关联，IDCard.java编写如下：

mappedBy属性表示关联关系由拥有iDCard属性的Person类进行管理，双向关联务必在被管理方配置该选项！

此时，我们分别对人和身份证分别执行查询，看是否可以查到关联数据！

查询Person类测试代码：

import cn.edu.ccut.bo.IDCard;
import cn.edu.ccut.bo.Person;
import cn.edu.ccut.util.DBUtil;
import org.hibernate.Session;
import org.junit.Test;

public class HibernateTest {

    @Test
    public void testHibernateConfig() throws Exception{
        //创建Session对象
        Session session = DBUtil.getSession();
        Person person = (Person) session.get(Person.class, "40288d81688c96ce01688c96ed880001");
        System.out.println(person);
        DBUtil.close();
    }
}

 执行结果如下：

查询IDCard类代码如下：

import cn.edu.ccut.bo.IDCard;
import cn.edu.ccut.util.DBUtil;
import org.hibernate.Session;
import org.junit.Test;

public class HibernateTest {

    @Test
    public void testHibernateConfig() throws Exception{
        //创建Session对象
        Session session = DBUtil.getSession();
        IDCard iDCard = (IDCard) session.get(IDCard.class, "40288d81688c96ce01688c96ed7e0000");
        System.out.println(iDCard.getPerson());
        DBUtil.close();
    }
}

 特别的：被动管理类不允许重写toString()方法，如本例中IDCard类配置toString()会发生递归调用造成死循环

2.一对多关联关系

一对多的关联关系其实和一对一配置方式一致，只需要注意多的要用集合表示即可！
如人和手机的关系，人可以有多个手机，但是一个手机只能属于一个人，那么我们设置Person类和Phone类如下：

Person设置为上面例子中最初始的例子即可，我们编写下Phone类如下：

package cn.edu.ccut.bo;


public class Phone {
    private String id;
    private String phoneName;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPhoneName() {
        return phoneName;
    }

    public void setPhoneName(String phoneName) {
        this.phoneName = phoneName;
    }
}

我这里直接讲双向的一对多关联关系！

在Phone类中进行如下配置：

package cn.edu.ccut.bo;

import org.hibernate.annotations.GenericGenerator;

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

@Entity
public class Phone {
    @Id
    @GenericGenerator(name = "uuid",strategy = "uuid")
    @GeneratedValue(generator = "uuid")
    private String id;
    private String phoneName;
    @ManyToOne
    private Person person;

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPhoneName() {
        return phoneName;
    }

    public void setPhoneName(String phoneName) {
        this.phoneName = phoneName;
    }
}

Person类进行如下配置：

package cn.edu.ccut.bo;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.io.Serializable;
import java.util.List;

@Entity
public class Person implements Serializable {
    @Id
    @GenericGenerator(name = "uuid",strategy = "uuid")
    @GeneratedValue(generator = "uuid")
    private String id;
    private String name;
    @OneToMany(mappedBy = "person")
    private List<Phone> phones;

    public List<Phone> getPhones() {
        return phones;
    }

    public void setPhones(List<Phone> phones) {
        this.phones = phones;
    }

    public Person() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", phones=" + phones +
                '}';
    }
}

编写测试类测试：

import cn.edu.ccut.bo.Person;
import cn.edu.ccut.bo.Phone;
import cn.edu.ccut.util.DBUtil;
import org.hibernate.Session;
import org.junit.Test;

public class HibernateTest {

    @Test
    public void testHibernateConfig() throws Exception{
        //创建Session对象
        Session session = DBUtil.getSession();
        //开启事务
        session.beginTransaction();
        Phone p1 = new Phone();
        p1.setPhoneName("华为");
        Phone p2 = new Phone();
        p2.setPhoneName("苹果");
        Person person = new Person();
        person.setName("张三");
        session.save(person);
        p1.setPerson(person);
        p2.setPerson(person);
        session.save(person);
        session.save(p1);
        session.save(p2);
        session.getTransaction().commit();
        /*Person person = (Person) session.get(Person.class, "40288d81688c96ce01688c96ed880001");
        System.out.println(person);*/
        DBUtil.close();
    }
}

测试结果如下：

 

我们进行一下查询操作，查询Person类和它所拥有的手机：

测试类编写如下：

import cn.edu.ccut.bo.Person;
import cn.edu.ccut.bo.Phone;
import cn.edu.ccut.util.DBUtil;
import org.hibernate.Session;
import org.junit.Test;

public class HibernateTest {

    @Test
    public void testHibernateConfig() throws Exception{
        //创建Session对象
        Session session = DBUtil.getSession();
        Person person = (Person) session.get(Person.class, "40288d81688cb42701688cb428810000");
        System.out.println(person);
        DBUtil.close();
    }
}

 测试类执行效果如下：

可见我们成功了！

多对多的配置请私下自主进行学习，使用注解@ManyToMany 

程序猴jwang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate入门教程学习笔记
02-17
这是一个Hibernate入门学习的不错资源，主要内容包括Hibernate主配置文件的讲解、映射普通属性、映射主键、映射集合、映射关联关系（一对多多对一、多对多、一对一）、HQL查询等内容，最后给出一个综合练习案例
Hibernate入门
yh20144221014的博客
09-16 165
实体类(注解方式映射) package pojo; import org.hibernate.annotations.GenericGenerator; import javax.persistence.*; @Entity @Table(name="public.user") public class User { private Integer userId; private String userName; private String passWord; @I
Hibernate入门（六）Hibernate的注解配置方式
jwang的博客
01-23 327
前言      本章讲解注解方式配置Hibernate 方法 1.概念 我们知道，目前的趋势是注解式开发，所以我们之后的重心将全部投入到注解之中，映射配置文件（XXX.hbm.xml）就不多说了！ 2.使用注解代替映射配置文件 我们之前都是使用XXX.hbm.xml配置实体类与数据库表之间的映射关系，那么对于之后的如关联关系来讲，配置起来还是不太舒服的，所以从今天起，我们一律采用注解的...
Hibernate常用Annotation标签说明
北京-李大鹏
06-28 4044
@ javax.persistence.Entity 实体类定义，该标签表示当前类是一个Hibernate的数据库实体，对应着数据库中的某个表 位置：用于类级别 参数：无 样例：@Entity 注意：导入标签类时可能会有多个，这里使用的是javax.persistence.Entity @javax.persistence.Table 实体类定义，该标签表示当前类是一个H
JPA 自动建表（3）- @Id，@GeneratedValue 与 @GenericGenerator 设置主键生成策略
minihuabei的博客
02-18 1791
@Id，@GeneratedValue 一起使用，设置主键生成策略为： 主键自增 注意：适用于MySql等具备主键自增功能的数据库，因为底层就是借用了MySql的主键自增功能 1 @Entity 2 public class TblTest { 3 4 @Id 5 @GeneratedValue(strategy = GenerationType.IDENTITY) // 设置主键生成策略为：主键自增长，适用于MySQL等部分数据库 6 private Integer
Hibernate 注解
Gardenia_zy的博客
12-07 231
一、导入jar包 1、导入所学要的jar包，在eclipse里面选中项目右击，点击菜单栏中的properties，找到Java Build Path里面的Libraries，点击右侧的Add External JARS…就可导入相应路径的jar包。具体步骤：eclipse->项目->properties->Java Build Path->Libraries->Add External JARS
Hibernate 对象关系映射
10-18
本人在厦门邦初培训时候用的ppt 快速入门文档 内容： 建立一对多的关联关系域模型 建立一对多的参照关系的模型 映射一对多关联关系 通过hibernateAPI级联操作关联对象 其它关系的映射：一对一，多对多
hibernate入门与概述
05-28
hibernate入门与概述。介绍对象-关系 映射基础，映射对象标识符，映射一对多关联关系，操纵持久化对象，hibernate的检索策略。
hibernate介绍
10-08
分5部分进行介绍hibernate，分别为入门及概述、深入详解、关联映射、查询、事务与缓存。
Hibernate3.2官方中文参考手册
07-22
资源名称：Hibernate3.2官方中文参考手册内容简介： Hibernate3.2官方中文参考手册，内容涉及Hibernate入门知识、配置、集合类映射、关联关系映射、组件、事务并发、批量处理、对象事件等知识。资源截图： 资源太大...
Hibernate注解
公子小白有点黑
07-28 320
首先说一下在学习Hibernate注解的时候遇到的坑 （1）@Entity@Table(name="xxx")该注解在hibernate4之后就不再使用，否则获取session出错。 hibernate4之后的版本@Entity(name="xxx") （2）Exception in thread "main" org.hibernate.MappingException...
hibernate自定义主键生成策略（利用雪花算法生成主键id）
m0_61427728的博客
04-06 981
使用Hibernate自定义主键生成策略（雪花算法生成主键id）
Hibernate之HQL左关联配置
菜菜De学习
12-23 167
Hibernate之HQL左关联配置 一般在单表中查询,hql类似于SQL的写法 不过是把字段变成属性名。当两个表关联查询的时候,一般联合查询也不会有问题。当如果需要左关联的时候，HQL就不能直接实现了，必须要配置主从表的关系才能够成功的实现SQL中的左关联！ 现在有一个需求： 供应商表Supplier 与报名表ItemEnroll 现在有一个报名的功能,如果需要供应商登陆，我就会...
Hibernate HQL 左连接 查询 两张表
热门推荐
一笑天
06-19 1万+
由于项目需要，现在需要进行两张表连接查询，但前期hql已经写好，现在只是想在原有的基础之上再加上一个表的连接查询，本来如果用本地sql的方式很容易实现，但是原来已经用hql来写，并且程序本身在取得查询结果后如果查询出来是对象，对后面的操作很方便，故要在原有hql基础之后添加外连接，如下： if("0".equals(orgId)){ //顶级机构查询所有下级 hqlStrBuffer.appe
HQL的左连接
IVON
06-06 7044
最近做一个查询实现把一个表的记录全部显示出来并且显示关联的另外一个表的记录，这当然谁都知道要用到外连接查询，然而过程并不愉快。在Hibernate的映射文件中配置好关联关系之后，查询的时候可以直接使用比如select new map(student.studentID as studentID, student.studentAccount as studentAccount,student.stu
Hibernate04-HQL连接查询和Hibernate注解
weixin_43094361的博客
04-02 3931
一、使用HQL连接查询 和SQL查询一样，HQL也支持多种连接查询，如内连接查询、外连接查询。在SQL中可通过join子句实现多表之间的连接查询。HQL同样提供了连接查询机制，还允许显式指定迫切内连接和迫切左外连接。迫切连接是指不仅指定了连接查询方式，而且显式的指定了关联级别的查询策略。迫切连接使用fetch关键字实现，fetch关键字表明“左边”对象用来与“右边”对象关联的属性会立即被初始化。 ...
Hibernate实战——@Formula注解
实践求真知
09-16 457
一配置文件 <?xml version="1.0" encoding="GBK"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-con...
hibernate关于hql的左外连接查询
Love丶兰的博客
07-22 1万+
hibernate关于hql的左外连接查询,实体映射文件未配置关联关系!
hibernate框架关联关系映射操作
最新发布
05-14
Hibernate框架提供了对象关系映射（ORM）功能，可以将Java对象映射到数据库表中，并且可以使用关联关系映射来描述对象之间的关系。下面是一些常见的Hibernate关联关系映射操作： 1. 一对一映射：在一个实体中定义一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值