Hibernate框架-联合主键映射

最新推荐文章于 2019-05-08 10:41:00 发布
最新推荐文章于 2019-05-08 10:41:00 发布
阅读量422 收藏
点赞数
分类专栏： Java hibernate javaee 文章标签： hibernate java javaweb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mass_effect/article/details/72823288
版权
Java 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
hibernate
7 篇文章 0 订阅
订阅专栏
javaee
5 篇文章 0 订阅
订阅专栏

Hibernate联合主键映射

Hibernate允许直接将实体类的多个属性映射成联合主键，如果需要直接将实体类的多列映射成联合主键，则该实体类必须满足如下条件：

i. 有无参的构造方法
ii. 实现Java.io.Serializable接口
iii. 建议根据联合主键列所映射的属性来重写equals()和hashCode()方法

例：

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name="teacher")
public class Teacher implements Serializable{

    private static final long serialVersionUID = 4938691487727505015L;

    private int id;
    private String name;
    private Title title;
    private Date date;

    @Id //!!
    public int getId() {
        return id;
    }

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

    @Id //!!
    @Column(length=50)
    public String getName() {
        return name;
    }

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

    @Enumerated(EnumType.STRING)
    public Title getTitle() {
        return title;
    }

    public void setTitle(Title title) {
        this.title = title;
    }

    @Temporal(TemporalType.DATE)
    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }


    @Override
    //重写equals()方法，根据id, name进行判断
    public boolean equals(Object obj) {
        if(obj == null) {
            return false;
        }

        if(obj instanceof TeacherPk) {
            TeacherPk pk = (TeacherPk) obj;
            if(this.id == pk.getId() && this.name.equals(pk.getName())) {
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.getName().hashCode();
    }
}

测试方法：

    @Test
    public void Teacher() {
        Teacher teacher = new Teacher();
        teacher.setId(1);
        teacher.setName("teacher");
        teacher.setTitle(Title.A);
        teacher.setDate(new Date());


        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        Session session = sessionFactory.openSession();

        Transaction transaction = session.beginTransaction();
        session.save(teacher);
        transaction.commit();
        session.close();
        HibernateUtil.close();
    }

控制台日志
这里写图片描述

这里写图片描述

尝试插入相同的记录
这里写图片描述

传统方式

如果使用传统方式来开发Hibernate实体类，则实体类的设计不同于单一主键时：要将属于联合主键的字段从实体类中分离，单独建立一个主键类，这个主键类要求拥有无参的构造方法、实现**Java.io.Serializable**接口和重写**equals()**和**hashCode()**方法，因为数据库是要根据不同的字段的值判断是否为唯一主键的，那么判断机制肯定不能够和以往基于单一主键的判断机制相同。

实体类

public class Student {

    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
XML方式：

现在要改造为联合主键（id和name字段）

首先将id和name分离出去，建立主键类

//主键类
import java.io.Serializable;

public class StudentPk implements Serializable{

    private static final long serialVersionUID = 8538253779495022662L;

    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {

        if(obj == null) {
            return false;
        }

        if(obj instanceof StudentPk) {
            StudentPk pk = (StudentPk) obj;
            if(this.id == pk.getId() && this.name.equals(pk.getName())) {
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }

}

新的实体类

public class Student {

    private StudentPk pk = null;

    private int age;


    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public StudentPk getPk() {
        return pk;
    }
    public void setPk(StudentPk pk) {
        this.pk = pk;
    }
}

student.hbm.xml文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="pers.msidolphin.hibernate.domain">

    <class name="Student" table="_STUDENT">
        <!--这个name属性指定的是主键对象在实体类中的属性名 class当然是主键类对应的完整类名-->
        <composite-id name="pk" class="pers.msidolphin.hibernate.domain.StudentPk">
            <!--映射联合主键里的各个属性-->
            <key-property name="id" column="ID"></key-property>
            <key-property name="name" column="NAME" length="50"></key-property>
        </composite-id>
        <property name="age" column="AGE"/>
    </class>

</hibernate-mapping>

测试方法：

    @Test
    public void Student() {
        Student stu = new Student();
        StudentPk pk = new StudentPk();
        pk.setId(1);
        pk.setName("admin");
        stu.setAge(21);
        stu.setPk(pk);

        Configuration cfg = new Configuration();

        cfg = cfg.configure();


        SessionFactory  sf = HibernateUtil.getSessionFactory();

        Session session = sf.openSession();

        Transaction transaction = session.beginTransaction();
        session.save(stu);
        transaction.commit();
        session.close();
        sf.close();
    }

控制台日志打印出的建表语句，primary key(id, name)说明以id和name字段建立了联合主键
这里写图片描述

查看插入结果：
这里写图片描述

尝试插入相同的记录
这里写图片描述



注解(Annotation)方式：

有三种：

i. **@Embeddable**：将主键类注解为@Embeddable，并将实体类的主键类对象属性加上@Id注解

ii. **@EmbeddedId**：直接把实体类的主键类对象属性加上此注解

iii. **@IdClass**：在实体类加上@IdClass注解，并且将该实体类中所有属于主键的属性都注解为@Id（这种方式在实体类中保留了主键字段，但是还是要依赖主键类）

@Embeddable方式：

实体类：

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Id;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name="teacher1")
public class Teacher {


    private TeacherPk pk = null;
    private Title title;
    private Date date;

    @Id //！！
    public TeacherPk getPk() {
        return pk;
    }
    public void setPk(TeacherPk pk) {
        this.pk = pk;
    }
    @Enumerated(EnumType.STRING)
    public Title getTitle() {
        return title;
    }
    public void setTitle(Title title) {
        this.title = title;
    }
    @Temporal(TemporalType.DATE)
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
}

主键类:

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable //！！
public class TeacherPk implements Serializable{

    private static final long serialVersionUID = 1084438907442149399L;

    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(length=50)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == null) {
            return false;
        }

        if(obj instanceof TeacherPk) {
            TeacherPk pk = (TeacherPk) obj;
            if(this.id == pk.getId() && this.name.equals(pk.getName())) {
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

测试结果：
这里写图片描述

@EmbeddedId方式：
实体类：

import java.util.Date;

import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;


@Table(name="teacher2")
public class Teacher2 {

    private TeacherPk2 pk = null;
    private Title title;
    private Date date;

    @EmbeddedId //！！
    public TeacherPk2 getPk() {
        return pk;
    }
    public void setPk(TeacherPk2 pk) {
        this.pk = pk;
    }
    @Enumerated(EnumType.STRING)
    public Title getTitle() {
        return title;
    }
    public void setTitle(Title title) {
        this.title = title;
    }
    @Temporal(TemporalType.DATE)
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
}

主键类：

import java.io.Serializable;

import javax.persistence.Column;

public class TeacherPk2 implements Serializable{

    private static final long serialVersionUID = 1084438907442149399L;

    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(length=50)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == null) {
            return false;
        }

        if(obj instanceof TeacherPk2) {
            TeacherPk2 pk = (TeacherPk2) obj;
            if(this.id == pk.getId() && this.name.equals(pk.getName())) {
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

测试结果：
这里写图片描述

@IdClass方式：
实体类：

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity()
@Table(name="teacher3")
@IdClass(TeacherPk3.class) //！！
public class Teacher3 {

    private int id;
    private String name;
    private Title title;
    private Date date;

    @Id //！！
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Id //！！
    @Column(length=50)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Enumerated(EnumType.STRING)
    public Title getTitle() {
        return title;
    }
    public void setTitle(Title title) {
        this.title = title;
    }
    @Temporal(TemporalType.DATE)
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
}

主键类：
这里写图片描述

msidolphin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate 框架详解
06-07
触发器实现的主键生成器（Primary keys assigned by triggers） 6.1.5. composite-id 6.1.6. 鉴别器（discriminator） 6.1.7. 版本（version）(可选) 6.1.8. timestamp (optional) 6.1.9. property 6.1.10. ...
Hibernate联合主键详解
wuseyukui的专栏
11-07 1945
Hibernate联合主键映射  1. 实现方式一：将复合主键对应的属性与实体其他普通属性放在一起  2. 实现方式二：将主键属性提取到一个主键类中，实体类只需包含主键类的一个引用  联合主键的映射规则 1） 类中的每个主键属性都对应到数据表中的每个主键列。 Hibernate要求具有联合主键的实体类实现Serializable接口
Hibernate联合主键
红桃峰峰 的博客
07-14 1032
在实际开发中，数据库表之间关系有很多种情况，其中共有一个是联合主键，就是中由两个以上的属性同时担任主键， 今天我们就来学习一下，联合主键怎么设计实体类，以及怎么写实体类对应的配置文件*.hbm.xml， 新建一个项目名称为：06hibernate_composite_id，结构如下： 项目以分数实体类为例， 导入jar包，参见《Hibernate环境搭建和配置》
hibernate 联合主键
u014164005的博客
04-19 317
Hibernate 联合主键有三种写法 ： 第一种：使用 @Embeddable注解    import java.io.Serializable; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class TestPerson implements Serializ...
单元测试---Hibernate支持联合主键
congbaobei的博客
09-20 181
出现未实现序列化的错误原因 在定义实体类的时候未实现序列化 测试时，单元测试并未报错，数据库却没插入数据，是因为没有开启事务，本身openSession()是向数据库村入新数据是不需要开启事务的，但是联合主键是需要的 此时数据新增成功！ 需要注意的事项是在新增数据的过程不要超出你自己定义的数据类型的范围，否则同样不会成功。
hibernate4从入门到大神（备java基础，mysql，javaee经典框架）
06-08
ORM思想，hibernate介绍，hibernate.cfg.xml配置，hbm.xml映射文件详解，主键生成策略使用，PO对象状态及状态的转换分析、一级缓存，Hibernate数据检索技术，Hibernate映射技术，Hibernate多表联合查询， Hibernate...
精通 Hibernate：Java 对象持久化技术详解(第2版).part2
06-12
　15.1.2 按照主键映射 　15.2 映射单向多对多关联 　15.3 映射双向多对多关联关系 　15.3.1 关联两端使用元素 　15.3.2 在inverse端使用元素 　15.3.3 使用组件类集合 　15.3.4 把多对多关联分解为两个一对多关联 ...
Hibernate笔记 马士兵
12-04
第1课 课程内容 6 第2课 Hibernate UML图 6 第3课 风格 7 第4课 资源 7 第5课 环境准备 7 ...三、 联合主键 24 1、xml方式 24 2、annotation方式 27 第14课 Hibernate核心开发接口(重点) 29 ........
Hibernate复合主键
06-03
一个简单的复合主键的做关联类的例子
Hibernate联合主键的例子
05-02
Hibernate联合主键，MyEclipse的例子
java hibernate使用注解来定义联合主键
08-31
主要介绍了java hibernate使用注解来定义联合主键的相关资料,需要的朋友可以参考下
hiberante中使用复合主键
上海夜未眠
07-31 770
对于新系统的设计开发而言，我们应尽量避免在库表中引入与业务逻辑相关的主键关系。将业务逻辑主键引入库表，以后业务逻辑的变化，将很可能对底层数据库结构产生连带影响。复合主键的引入，很大程度上意味着业务逻辑已经侵入到数据存储逻辑之中。因此，应尽量避免。但实际情况中，我们必须面对遗留系统的旧表开发，这时，对现有复合主键的支持就非常必要。hibernate中，通过composite-id节点对复合主
hibernate的联合主键
u011526599的专栏
04-15 774
hibernate的联合主键探究
Hibernate 联合主键
weixin_39892530的博客
03-19 195
第一种方法：比如有一个Student类，想用id和name两者联合作为这个类的主键。那么可以定义一个StudentPK类，其私有变量包括name和id。对于这个外部类，有以下三点要求：①加上注解@Embeddable  ②必须要实现序列化，也就是Serializable接口③要重写equals和hashcode函数。要实现序列化是因为对象需要在内存里存储，为了以后内存满了方便从当前内存转移到另一个...
hibernate 联合主键 composite-id
weixin_30376163的博客
05-08 210
如果表使用联合主键（一个表有两个以上的主键），你可以映射类的多个属性为标识符属性。如:<composite-id>元素接受<key-property> 属性映射（单表映射）和<key-many-to-one>属性映射作为子元素（多表映射）。 <composite-id> <key-property name...
怎么在hibernate中配置联合主键
最新发布
05-17
在 Hibernate 中配置联合主键，可以通过使用 @IdClass 或 @EmbeddedId 注解来实现。 1. 使用 @IdClass 注解： 首先，需要创建一个用于表示联合主键的类，该类需要实现 Serializable 接口，并且需要包含所有联合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值