Hibernate学习之关联关系映射

最新推荐文章于 2024-09-29 19:21:13 发布
最新推荐文章于 2024-09-29 19:21:13 发布
阅读量658 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate 关联 person student
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011726984/article/details/45155281
版权

介绍

从单向关系映射开始，然后考虑双向关系映射，逐步讲解典型的案例。

在单向关联的例子中，将用 Student类和 Classes类。

在双向关联的例子中，将用 Person类和 Event类。

单向关联

多对一

单向 many-to-one 关联是最常见的单向关联关系。

Student.java

package com.dfdc.hibernate.domain;

import java.io.Serializable;

public class Student implements Serializable{

    private static final long serialVersionUID = 1L;

    private Long sid;
    private String sname;
    //维护多对一
    private Classes clazz;

    public Classes getClazz() {
        return clazz;
    }
    public void setClazz(Classes clazz) {
        this.clazz = clazz;
    }

    public Long getSid() {
        return sid;
    }
    public void setSid(Long sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }

}

Classes.java

import java.io.Serializable;
import java.util.Set;

public class Classes implements Serializable{

    private static final long serialVersionUID = 1L;

    private Long cid;
    private String cname;       

    public Long getCid() {
        return cid;
    }

    public void setCid(Long cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }   

}

Student.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">

<hibernate-mapping>
    <class name="com.dfdc.hibernate.domain.Student" table="STUDENT">
        <id name="sid" type="java.lang.Long">
            <column name="SID" />
            <generator class="native" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" />
        </property>

        <!-- 多对一，无关联表 -->        
        <many-to-one name="clazz" column="CID" not-null="true"/>
    </class>
</hibernate-mapping>

以下为了代码简洁将省略DTD部分。

Classes.hbm.xml内容

<hibernate-mapping>
<class name="com.dfdc.hibernate.domain.Classes" table="CLASSES">
    <id name="cid" type="java.lang.Long">
        <column name="CID" />
        <generator class="native" />
    </id>
    <property name="cname" type="java.lang.String">
        <column name="CNAME" />
    </property>               
</class>
</hibernate-mapping>

一对一

基于外键关联

基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。

在上面Student.hbm.xml内容的节点增加unique=”true”

基于主键关联

基于主键关联的单向一对一关联通常使用一个特定的 id 生成器。

注释掉student类的clazz属性，并在classes类中增加Student类型的stu属性，即Classes类持有Student的引用。

Student.hbm.xml内容

<id name="sid" type="java.lang.Long">
    <column name="SID" />
    <generator class="native" />
</id>
<property name="sname" type="java.lang.String">
    <column name="SNAME" />
</property>

**Classes.hbm.xml内容**class节点内容改成如下：

<!--  基于主键的单向一对一 -->
<id name="cid" type="java.lang.Long">
    <column name="SID" />
    <generator class="foreign">
        <!-- property只关联对象 --> 
        <param name="property">stu</param>
    </generator>
</id>
<property name="cname" type="java.lang.String">
    <column name="CNAME" />
</property>
   <!-- constrained,通过一个外键引用对主键进行约束。-->
<one-to-one name="stu" constrained="true"/>

一对多

基于外键关联

基于外键关联的单向一对多关联是一种很少见的情况，我们不推荐使用它。

我们认为对于这种关联关系最好使用连接表（关联表）。

基于连接表的单向关联

一对多（one-to-many）

基于连接表的单向一对多关联应该优先被采用。

注意，通过指定unique=”true”，我们可以把多样性从多对多改变为一对多。

student映射文件内容：

<id name="sid" type="java.lang.Long">
<column name="SID" />
<generator class="native" />
</id>
<property name="sname" type="java.lang.String">
<column name="SNAME" />
</property>

classes映射文件内容：

<id name="cid" type="java.lang.Long">
<column name="CID" />
<generator class="native"/> 
</id>
<property name="cname" type="java.lang.String">
<column name="CNAME" />
</property>
<!-- 基于连接表的多对多
    指定unique="true"转换为两个一对多 -->
<set name="students" table="CLASSES_STUDENT">
    <key column="CID"></key>
    <many-to-many column="SID" unique="true" class="com.dfdc.hibernate.domain.Student"></many-to-many>
</set>

注释掉student类的clazz属性，并在classes类中设置Set集合，属性为students。

多对一（many-to-one）

基于连接表的单向多对一关联在关联关系可选的情况下应用也很普遍。

student映射文件内容：

<id name="sid" type="java.lang.Long">
    <column name="SID" />
    <generator class="native" />
</id>
<property name="sname" type="java.lang.String">
    <column name="SNAME" />
</property>

<!-- 基于连接表的单向多对一
    table：被连接表的名称。
    optional（可选 — 默认是 false）：如果为true，Hibernate 
        只会在此连接定义的属性非空时插入一行数据，并且总是使用一个外连接来得到这些属性。        
 -->
<join table="CLASSES_STUDENT" optional="true" >
    <key column="SID" unique="true"/>
    <many-to-one name="clazz" column="CID" not-null="true" unique="true"/>
</join>

classes映射文件内容：

<id name="cid" type="java.lang.Long">
    <column name="CID" />
    <generator class="native"/> 
</id>
<property name="cname" type="java.lang.String">
    <column name="CNAME" />
</property>

以上的student类和classes类不变。

一对一（One-to-one）

基于连接表的单向一对一关联也是可行的，但非常少见，就不举例了。

多对多（many-to-many）

最后，这里是一个单向多对多关联的例子。

student映射文件内容：

<id name="sid" type="java.lang.Long">
    <column name="SID" />
    <generator class="native" />
</id>
<property name="sname" type="java.lang.String">
    <column name="SNAME" />
</property>
 <!-- 基于连接表的单向多对多 -->
<set name="clazzSet" table="CLASSES_STUDENT">
    <key column="SID"/>
    <many-to-many column="CID" class="com.dfdc.hibernate.domain.Classes"/>
</set>

classes映射文件内容：

<id name="cid" type="java.lang.Long">
    <column name="CID" />
    <generator class="native"/> 
</id> 
<property name="cname" type="java.lang.String">
    <column name="CNAME" />
</property>

把上面的student类的clazz属性类型改成Set即可。

双向关联

从双向关系映射开始，逐步讲解典型的案例。

在双向关联的例子中，将用 Event 和 Person。

Event.java

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

public class Event {

    private Long id;

    private Date date;

    private Set<Person> personSet = new HashSet<Person>();

    public Set<Person> getPersonSet() {
        return personSet;
    }

    public void setPersonSet(Set<Person> personSet) {
        this.personSet = personSet;
    }

    public Event() {}

        public Long getId() {
        return id;
    }

    //只有hibernate能操作标识符
    private void setId(Long id) {
        this.id = id;
    }

    public Date getDate() {
        return date;
    }

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

}

Person.java

import java.util.HashSet;
import java.util.Set;

public class Person {
    private Long id;
    private int age;

    public Person() {}                         

    public Long getId() {
        return id;
    }

    private void setId(Long id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

}

一对多（one to many)/多对一（many to one）

双向多对一关联，是最常见的关联关系。

person映射文件内容：

<id name="id">
    <column name="PERSON_ID"/>
    <generator class="native"></generator>
</id>

<property name="age"/>
<!-- 双向多对一/一对多 -->

<many-to-one name="events" column="EVENT_ID" class="com.dfdc.hibernate.domain.Event" not-null="true"/>

event映射文件内容：

<id name="id">
    <column name="EVENT_ID" />
    <generator class="increment" />
</id> 
<property name="date" type="timestamp">
    <column name="DATE" />
</property>
<!-- 双向一对多/多对一 -->
<set name="persons" inverse="true">
    <key column="EVENT_ID"/>
    <one-to-many class="com.dfdc.hibernate.domain.Person"/>
</set>

在上面的person类添加Event类型的events属性。

一对一（One-to-one）

基于外键关联

基于外键关联的双向一对一关联也很常见。

person映射文件内容：

<id name="id">
    <column name="PERSON_ID"/>
    <generator class="native"></generator>
</id>

<property name="age"/>
<!-- 基于外键关联双向一对一
    unique，作为 property-ref 引用的目标。这使关联同时具有一对一的效果。
 -->
<many-to-one name="events" column="EVENT_ID" unique="true" not-null="true"/>

event映射文件内容：

<id name="id">
    <column name="EVENT_ID" />
    <generator class="native" />
</id> 
<property name="date" type="timestamp">
    <column name="DATE" />
</property>
 <!-- 基于外键关联双向一对一
    property-ref，被关联到此外键的类中的对应属性的名字。如果没有指定，被关联类的主键将被使用。
 -->
 <one-to-one name="persons" property-ref="events"/>

注释掉Event类的set类型的属性，并添加Person类型的属性persons。

在Person类添加Event类型的属性events。

基于主键关联

person映射文件内容：

<!-- 1.基于主键关联双向一对一 -->
    <id name="id">
        <column name="EVENT_ID"/>
        <!--
        foreign,获取相关联的对象的标识符。它通常和 <one-to-one> 联合起来使用。
        -->
        <generator class="foreign">
            <!--property，相关联的对象 -->
            <param name="property">events</param>
        </generator>
    </id>

    <property name="age"/>
    <!--constrained="true",开启当前类与关联类之间的外键约束
            将影响级联操作顺序。
     -->
    <one-to-one name="events" class="com.dfdc.hibernate.domain.Event" constrained="true"/>

event映射文件内容：

<id name="id">
    <column name="EVENT_ID" />
    <generator class="native" />
</id> 
<property name="date" type="timestamp">
    <column name="DATE" />
</property>
<!-- 1.基于主键关联双向一对一 -->
<one-to-one name="persons" class="com.dfdc.hibernate.domain.Person"/>

在上面的person类添加Event类型的events属性。

在上面的event类添加Person类型的persons属性，并注释Set类型的persons属性。

主键关联不需要额外的表字段,两个对象通过主键一对一关联，必须确认它们被赋予同样的标识值。

基于连接表的双向关联

一对多（one to many)/多对一（many to one）

下面是一个基于连接表的双向一对多关联的例子。

person映射文件内容：

    <id name="id">
        <column name="PENSON_ID"/>
        <generator class="native"></generator>
    </id>

    <property name="age"/>
    <!-- 4. 基于连接表关联双向多对一/一对多 -->
    <set name="eventSet" table="PERSONEVENT">
        <key column="PERSON_ID"/>
        <many-to-many column="EVENT_ID" unique="true" class="com.dfdc.hibernate.domain.Event"/>
    </set>

event映射文件内容：

<id name="id">
    <column name="EVENT_ID" />
    <generator class="native" />
</id> 
<property name="date" type="timestamp">
    <column name="DATE" />
</property>
<!-- 4. 基于连接表关联双向多对一/一对多 -->
<join table="PERSONEVENT" inverse="true" optional="true">
    <key column="EVETN_ID"/>
    <many-to-one name="persons" column="PERSON_ID" not-null="true"/>
</join>

在上面的Person类（代表一）中定义Set类型的eventSet属性。

在event类（代表多）中注释掉Set类型的persons属性，并添加Person类型的persons属性，即持有Person类的引用。

一对一（one to one）

基于连接表的双向一对一关联也是可行的，但极为罕见。这里就不阐述了。

多对多（many-to-many）

下面是一个双向多对多关联的例子

person映射文件内容：

<id name="id">
    <column name="PENSON_ID"/>
    <generator class="native"></generator>
</id>

<property name="age"/>
<set name="eventSet" table="person_event">
    <key column="PERSON_ID"></key>
    <many-to-many class="com.dfdc.hibernate.domain.Event" column="EVENT_ID"></many-to-many>
</set>

event映射文件内容：

<id name="id">
    <column name="EVENT_ID" />
    <generator class="native" />
</id> 
<property name="date" type="timestamp">
    <column name="DATE" />
</property>
<set name="personSet" table="person_event" inverse="true">
    <key column="EVENT_ID"/>
    <many-to-many column="PERSON_ID" class="com.dfdc.hibernate.domain.Person"/>
</set>

在上面的Person类中定义Set类型的eventSet属性。

以上。。。

一大三千
关注
专栏目录
hibernate一对多关联映射学习小结
08-29
Hibernate一对多关联映射学习小结 Hibernate是一种流行的Java持久层框架，它提供了强大的对象关系映射（ORM）功能，能够将Java对象与关系数据库中表之间建立映射关系。Hibernate的关联映射是其核心功能之一，可以将...
Hibernate映射解析之关联映射详解
08-31
Hibernate是Java开发中常用的持久层框架，它简化了数据库操作，其中关联映射是实现对象关系映射的关键部分。关联映射允许我们将对象之间的关联关系映射到数据库的表结构中，使得对象模型和数据库模型能够无缝对接。...
hibernate外键关联————一个小错，弄一下午
571500581的博客
12-08 277
很简单的一个外键关联，把上面写成Set examRole = new HashSet junit 测试：一直都是can‘t not load applicationContext
Hibernate实体关联关系映射
皮一下很开心的猴头
08-03 2966
一、什么是Hibernate中的关联映射？ 　　简单来说Hibernate是ORM映射的持久层框架，全称是（Object Relational Mapping），即对象关系映射。 　　它将数据库中的表映射成对应的对象，以对象的形式展现，这样我们就可以通过映射的对象来对数据库中的数据进行间接的操作。 　　关联映射是将数据库中的表映射成与之相对应的对象，当你对这个对象进行操作的时候，Hibern...
Hibernate的关联关系映射之一对多映射
u011301372的博客
10-18 499
JavaWEB中一对多的设计及建表原则 导入SQL的建表语句 创建数据库：create database hibernate_day03 编写客户和联系人的JavaBean程序（注意一对多的编写规则） 客户的JavaBean如下 public class Customer { private Long cust_id; private String cust_name; p...
Hibernate关联关系映射(双向篇)
JavaSheng的专栏
05-12 6403
Hibernate关联关系可分为单向关联和双向关联两大类。单向关联可以分为一对一、一对多、多对一和多对多4种关联方式，而多向关联可以分为一对一、一对多和多对多3种关联方式。Hibernate连接管理类HibernateUtil.Javapublic class HibernateUtil { private static SessionFactory sessionFactory; p
15.Hibernate 多对多关联映射
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-25 1438
本节课，咱们一起继续聊聊多对多关联映射。多对多关联映射的实现；双向多对多关联映射的实现。
Hibernate多表关联查询记录映射
小蜜蜂1010的博客
08-26 1463
通常情况下，单表的查询比较简单，在hibernate中可以将查询记录直接映射到具体的实体类，因为通常会通过JPA注解将数据表和实体类建立映射关系，在查询数据，保存数据时，可以直接操作java实体类，但是涉及到多表查询，查询的多条记录，如果也要和java的类建立关系映射，需要做一些处理。 hibernate查询支持多种，如使用基本实体类对象查询，HQL查询，QBC(Query By Criteria)以及原生sql语句查询 我个人在复杂查询时候还是喜欢用原生sql查询，因为HQL查询，操作的是实体类对象，
SSH：Hibernate框架（七种关联关系映射及配置详解）
热门推荐
流年少年
11-27 1万+
概念          基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。   分类                                关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。
Hibernate各种关联映射关系梳理
SteveJrong's Blog
09-02 2255
Hibernate各种关联映射关系梳理 多对一的单向关联关系 1.      了解表结构及其关系 采用两张表作为今天的样表：   2.      了解类结构和映射文件： 有两个类： Street类的映射文件： Street类的类结构：   District类的映射文件： District类的类结构： 梳理关系： Dist
Hibernate，JPA 对象关系映射之关联关系映射策略
来啊 快活啊
04-03 755
关联关系映射关联关系映射，是映射关系中比较复杂的一种映射关系，总的说来有一对一、一对多和多对多几种关系。细分起来他们又有单向和双向之分。下面我们逐一介绍一下。单向 OneToOne单向一对一是关联关系映射中最简单的一种，简单地说就是可以从关联的一方去查询另一方，却不能反向查询。我们用下面的例子来举例说明，清单 1 中的 Person 实体类和清单 2 中的 Address 类就是这种单向的一对一关系
Mybatis之关联关系映射
m0_53151031的博客
12-17 1385
一、一对多 二、多对多
Hibernate_实体关联关系映射--学习总结
10-05
Hibernate的实体关联映射是其核心功能之一，它通过灵活的配置来适应不同场景下的数据持久化需求。通过对一对一、一对多、多对多等映射关系的熟练掌握和灵活运用，可以有效地处理复杂的实体关系，提高开发效率和应用...
Hibernate注解 关联关系映射注解.docx
06-19
在Java的持久化框架Hibernate中，注解是用于简化对象关系映射（ORM）的一种方式。本篇文章将详细探讨在Hibernate中如何使用注解来处理各种关联关系，特别是`mappedBy`属性的用法。 首先，`@OneToMany`注解用于表示...
Web安全 - 跨站点请求伪造CSRF（Cross Site Request Forgery）
小工匠
09-29 1333
CSRF (Cross-Site Request Forgery，跨站请求伪造) 是一种攻击方式，攻击者诱导用户在不知情的情况下发起非授权的请求。例如，用户在登录某个站点后，攻击者通过社交工程等手段诱使用户点击包含恶意请求的链接，利用用户已登录的状态，发起用户意图之外的操作，如转账、修改账户设置等。：在每次受保护的请求中，服务器生成一个唯一的CSRF Token，注入到表单或请求头中。：对于敏感操作，可以要求用户进行额外的身份验证，如验证码或短信验证，防止攻击者即便利用用户的认证状态，也无法完成关键操作。
I2C总线接口技术的应用.zip
10-07
硬件接口+总线+教程资料
fraps2.6.1.zip
最新发布
10-07
fraps2.6.1.zip
Hibernate实体关联关系映射实战与总结
3. **学习Hibernate关联关系映射的重要性**： 学习和掌握Hibernate的ORMapping是深入理解Hibernate的关键，这有助于开发者充分利用其提供的便利，提高开发效率。尽管初期可能觉得某些关系映射用不上，但随着技术的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值