hibernate 映射关系—关系映射（一对一）

一对一关系在数据库设计中还是一种比较常见的关系，比如user和userbasic这两个表的关系就是一对一的关系，基于数据库设计上主键的不同配置方式，一对一关系型在hibernate中的实现形式也有不同，主要是有下面两种方式。

1、主键关联

1.数据库设计

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(64) NOT NULL,
  `email` varchar(64) NOT NULL,
  `phone` char(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;

# userbasic的主键既作外键关联user的主键，即两者的主键一致
CREATE TABLE `userbasic` (
  `id` bigint(20) NOT NULL DEFAULT ‘0‘,
  `age` tinyint(4) DEFAULT NULL,
  `address` varchar(128) DEFAULT NULL,
  `sex` bit(1) DEFAULT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `fk_userid` FOREIGN KEY (`id`) REFERENCES `user` (`id`) ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.配置文件

<hibernate-mapping package="com.study.hibernate.hbm">
    <class name="User" table="user" catalog="hibernate">
        <id name="id" type="java.lang.Long">
            <column name="id" />
            <generator class="identity" />
        </id>
        <property name="name" type="string">
            <column name="name" length="64" not-null="true" />
        </property>
        <property name="email" type="string">
            <column name="email" length="64" not-null="true" />
        </property>
        <property name="phone" type="string">
            <column name="phone" length="11" not-null="true" />
        </property>
        <one-to-one name="userbasic" class="Userbasic"></one-to-one>
    </class>
</hibernate-mapping>

<hibernate-mapping package="com.study.hibernate.hbm">
    <class name="Userbasic" table="userbasic" catalog="hibernate">
        <!--注意主键的策略，foreign-->
        <id name="id" type="long">
            <column name="id" />
            <generator class="foreign">
                <param name="property">user</param>
            </generator>
        </id>
        <one-to-one name="user" class="User" constrained="true"></one-to-one>
        <property name="age" type="java.lang.Byte">
            <column name="age" />
        </property>
        <property name="address" type="string">
            <column name="address" length="128" />
        </property>
        <property name="sex" type="java.lang.Boolean">
            <column name="sex" />
        </property>
    </class>
</hibernate-mapping>

3.持久化类

public class User implements java.io.Serializable {
    private Long id;
    private String name;
    private String email;
    private String phone;
    private Userbasic userbasic;

    // 省略get/set方法
}
public class Userbasic implements java.io.Serializable {
    private long id;
    private User user;
    private Byte age;
    private String address;
    private Boolean sex;

    // 省略get/set方法
}

4.总结

get方法

1）user get时默认使用fetch=join的方式获取userbasic，不支持延迟加载userbasic

2）userbasic get时默认使用延迟加载的方式，但是可以设置lazy=false或者设置fetch=join来立即加载

save方法

1）user save时默认可以不设置userbasic对象，若要支持级联save，需要设置cascade属性等于all或者其他属性值

2）userbasic save时必须设置user对象，并且保存的时候必须先保存user再保存userbasic，因为userbasic的主键是从user来获取的，默认情况下是会级联先保存user的，不需要设置cascade属性

delete方法

1）user删除必须同时删除userbasic否则会由于外键约束导致失败，user删除必须级联删除userbasic，有两种方式，一是可以设置数据库的删除约束为cascade属性，二是user设置cascade属性为all

2）userbasic删除默认只删除自己，若要级联删除，可以设置cascade属性为all

update方法

1）默认情况下user更新不影响userbasic，若设置cascade属性为all，则会级联更新userbasic

2）userbasic的更新不会影响到user，即使设置cascade属性为all，也不会影响

2、外键关联

1.数据库设计

# user 表多了一个外键关联userbasic
CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `ubid` bigint(20) NOT NULL,
  `name` varchar(64) NOT NULL,
  `email` varchar(64) NOT NULL,
  `phone` char(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `fk_b` (`ubid`),
  CONSTRAINT `fk_b` FOREIGN KEY (`ubid`) REFERENCES `userbasic` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8;
CREATE TABLE `userbasic` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `age` tinyint(4) DEFAULT NULL,
  `address` varchar(128) DEFAULT NULL,
  `sex` bit(1) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8;

2.配置文件

<hibernate-mapping package="com.study.hibernate.hbm">
    <class name="User" table="user" catalog="hibernate">
        <id name="id" type="java.lang.Long">
            <column name="id" />
            <generator class="identity" />
        </id>
        <!--注意多的一端将外键设置为唯一，这样就能形成一对一的关系-->
        <many-to-one name="userbasic" class="Userbasic" fetch="select">
            <column name="ubid" not-null="true" unique="true"/>
        </many-to-one>
        <property name="name" type="string">
            <column name="name" length="64" not-null="true" />
        </property>
        <property name="email" type="string">
            <column name="email" length="64" not-null="true" />
        </property>
        <property name="phone" type="string">
            <column name="phone" length="11" not-null="true" />
        </property>
    </class>
</hibernate-mapping>
<hibernate-mapping package="com.study.hibernate.hbm">
    <class name="Userbasic" table="userbasic" catalog="hibernate">
        <id name="id" type="java.lang.Long">
            <column name="id" />
            <generator class="identity" />
        </id>
        <property name="age" type="java.lang.Byte">
            <column name="age" />
        </property>
        <property name="address" type="string">
            <column name="address" length="128" />
        </property>
        <property name="sex" type="java.lang.Boolean">
            <column name="sex" />
        </property>
        <!--注意property-ref的使用-->
        <one-to-one name="user" property-ref="userbasic"></one-to-one>
    </class>
</hibernate-mapping>

3.持久化类

public class User implements java.io.Serializable {
    private Long id;
    private Userbasic userbasic;
    private String name;
    private String email;
    private String phone;

    //省略get/set方法
}
public class Userbasic implements java.io.Serializable {
    private Long id;
    private Byte age;
    private String address;
    private Boolean sex;
    private User user;

    // 省略get/set方法
}

4.总结

property-ref的使用

1）主键关联时one-to-one的配置是name=user class=User，外键关联时one-to-one，我们没有使用class而是改成了property-ref。若使用class那么两者进行关联查询时使用的是如下条件代码：

userbasic1_.id=user2_.id

这显然不是正确的关联条件，正确的关联条件是userbasic.id=user.uid。只有将class换为property-ref=userbasic才能得到正确的关联条件，下面是正确的关联条件代码：

userbasic0_.id=user1_.ubid

2）property-ref的作用其实就是与某个对象关联时，指定关联的属性可以是单个字段也可以是对象

get方法

1）get默认情况下两边都是延迟加载的，可以设置lazy=false来立即加载

2）one的一端默认的抓取策略是join，many一端默认的fetch策略是select，可以修改fetch的属性为join

save方法

1）many端save时one端必须存在。当one在数据库中没有记录就是必须支持级联，即cascade需要设置为all等其他属性；当one在数据库中有记录，可以先找出并设置many的属性，然后再save

2）one端save没有限制，可以单独存储，也可以级联存储级联需要设置cascade属性

delete方法

1）userbasic删除必须同时删除user否则会由于外键约束导致失败，则userbasic删除必须级联删除user，可以设置数据库的删除约束为cascade属性或者userbasic设置cascade属性为all

2）user删除默认只删除自己，若要级联删除，可以设置cascade属性为all

update方法

1）user的更新默认只更新自己，设置级联后也会对userbasic进行更新

2）userbasic的更新默认只更新自己，设置级联后也会对userbasic进行更新

3、关联的方向

一对一关系也有两个方向，单向和双向，一般来说单向和双向关联的需求是基于项目的实际需要，我们可以去掉一端的关联关系映射，将其改为基本属性映射，这样就实现了单向关联的功能。

这里建议，若要单向一对一映射建议采用外键关联的方式来实现，比较灵活。

时间： 2024-09-20 16:38:39

hibernate 映射关系—关系映射（一对一）的相关文章

Hibernate多表关系配置——一对一关系映射

两个对象之间是一对一的关系,如Person-IdCard 有两种策略可以实现一对一的关联映射 主键关联:即让两个对象具有相同的主键值,以表明它们之间的一一对应的关系:数据库表不会有额外的字段来维护它们之间的关系,仅通过表的主键来关联 唯一外键关联 外键关联,本来是用于多对一的配置,但是如果加上唯一的限制之后,也可以用来表示一对一关联关系: 1.实体对象 1.1 Person实体对象 package demo.entity; /** * 人实体 * @author Don * @date:日期:2

Hibernate的七种映射关系之七种关联映射（一）

关联映射就是将关联关系映射到数据库里,在对象模型中就是一个或多个引用. 一.Hibernate多对一关联映射:就是在"多"的一端加外键,指向"一"的一端. 比如多个学生对应一个班级,多个用户对应一个级别等等,都是多对一关系. 1."多"端实体加入引用"一"端实体的变量及getter,setter方法. 比如说多个学生对应一个班级,在学生实体类加入:private Grade grade; 2."多"端配置文

javaEE 用户、部门、角色、权限实体的关系设计与hibernate映射配置文件关系总结

文章中的项目文件已经放到Github上,欢迎大家Follow,star, 地址:https://github.com/lawlite19/SmartEducation 一:设计实体,我这里通过uml设计,然后直接可以生成java实体类(方便查看各个类的关系) (1)用户登录类User与用户详细信息类UserDetails为一对一关系: (2)用户详细信息类UserDetails与部门为多对一关系:(一个部门有多个用户) (3)部门类是自关联的,有上级部门: (3)用户详细类UserDetails

Hibernate 的七种映射关系

关联映射就是将关联关系映射到数据库里,在对象模型中就是一个或多个引用. 一.Hibernate多对一关联映射:就是在"多"的一端加外键,指向"一"的一端. 比如多个学生对应一个班级,多个用户对应一个级别等等,都是多对一关系. 1."多"端实体加入引用"一"端实体的变量及getter,setter方法. 比如说多个学生对应一个班级,在学生实体类加入:private Grade grade; 2."多"端配置文

Hibernate之实体关系映射

延迟加载与即时加载 例如Person类和Email类是一对多关系,如果设为即时加载,当加载Person时,会自动加载Email,如果设置为延迟加载,当第一次调用person.getEmails()时才会执行SQL语句加载Email 注解配置时,@OnetToMany(Fetch = FetchType.EAGER)为即时加载,Fetch = FetchType.LAZY为延迟加载 延迟加载和即时加载的策略适用于所有一对多.多对一.多对多等所有的实体关系 一般来说,延迟加载要比即时加载节省资源,但

SSH框架之Hibernate（1）——映射关系

ORM的实现思想就是将关系数据库中表的数据映射成对象,以对象的形式展现,这样开发人员就可以把对数据库的操作转化为对这些对象的操作.Hibernate正是实现了这种思想,达到了方便开发人员以面向对象的思想来实现对数据库的操作. Hibernate在实现ORM功能的时候主要用到的文件有:映射类(*.java).映射文件(*.hbm.xml)和数据库配置文件(*.properties/*.cfg.xml),它们各自的作用如下. 映射类(*.java):它是描述数据库表的结构,表中的字段在类中被描述成属

Hibernate的七种映射关系之七种关联映射（二）

继续上篇博客 七.Hibernate双向一对多关联映射:让多的一端来维护关系. 主要是解决一对多单向关联的缺陷,而不是需求驱动的. 1.在Student.java实体类里添加Classes引用.private Classes classes; 2.Student.hbm.xml里添加many-to-one标签:<many-to-one name="classes" column="classesid"/>.Classes.hbm.xml在例子(六)里的那

Hibernate的映射组成关系

建立域模型(Java的对象模型)和关系数据模型(数据库表模型)有着不同的出发点: 域模型: 由程序代码组成, 通过细化持久化类的的粒度(就是通过把相同的属性,规划为一个类)可提高代码的可重用性, 简化编程 关系模型:在没有数据冗余的情况下, 应该尽可能减少表的数目, 简化表之间的参照关系, 以便提高数据的访问速度 Hibernate 把持久化类的属性分为两种: 值(value)类型: 没有 OID, 不能被单独持久化, 生命周期依赖于所属的持久化类的对象的生命周期 实体(entity)类型: 有

菜鸟学习Hibernate——一对多关系映射

Hibernate中的关系映射,最常见的关系映射之一就是一对多关系映射例如学生与班级的关系,一个班级对应多个学生.如图: Hibernate中如何来映射这两个的关系呢? 下面就为大家讲解一下: 1.创建实体类Classes和实体类Student Classes.java package com.bjpowernode.hibernate; import java.util.Set; public class Classes { private int id; private String nam

hibernate 映射组成关系

建立域模型和关系数据模型有着不同的出发点: 域模型: 由程序代码组成, 通过细化持久化类的的粒度可提高代码的可重用性, 简化编程 在没有数据冗余的情况下, 应该尽可能减少表的数目, 简化表之间的参照关系, 以便提高数据的访问速度 Hibernate 把持久化类的属性分为两种: 值(value)类型: 没有 OID, 不能被单独持久化, 生命周期依赖于所属的持久化类的对象的生命周期 实体(entity)类型: 有 OID, 可以被单独持久化, 有独立的生命周期(如果实体类型包含值类型,这个值类型就