学习hibernate（五） -- hibernate映射关系

最新推荐文章于 2024-08-10 16:13:20 发布
最新推荐文章于 2024-08-10 16:13:20 发布
阅读量61 收藏
点赞数
文章标签： java python 数据库
原文链接：https://my.oschina.net/u/2450666/blog/653932
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

组合关系

    在开发时，有一种情况，有一张数据表的数据来自于多个对象。比如，一个computer（电脑）表，其中有电脑的基本信息、CPU信息、显卡信息、主板信息和内存信息等等，对应的实体对象则是电脑对象、CPU对象、显卡对象和内存对象。这种情况下可以使用组合关系映射。

    以电脑与CPU为例，Computer类中包含了一个Cpu类，在*.hbm.xml文件中，使用component来进行组合关系映射。

    看一下这两个实体类的代码和映射文件：

package cn.net.bysoft.model;

public class Computer {
//getter and setter

    private int id;
    private String name;
    private Cpu cpu;
}
package cn.net.bysoft.model;

public class Cpu {

    //getter and setter

    private String name;
}
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.net.bysoft.model">
    <class name="Computer" table="computer">
        <id name="id" type="integer" column="ID">
            <!-- 指定主键的生成方式，native是使用数据库本地的方式 -->
            <generator class="native"></generator>
        </id>
        <property name="name" type="string" column="NAME"></property>
        <!-- 使用组合关系映射，CPU的Name信息存放在Cpu_Name字段中。 -->
        <component name="cpu" class="Cpu">
            <property name="name" type="string" column="CPU_NAME"></property>
        </component>
    </class>
</hibernate-mapping>

    生成的数据表并测试save方法：

@Test
    public void testComponent() throws IOException {
        //    save一个组合关系对象。
        Computer computer = new Computer();
        computer.setName("pc");
        Cpu cpu = new Cpu();
        cpu.setName("Inter");
        computer.setCpu(cpu);
        session.save(computer);
    }

181926_IKI2_2450666.png

一对多与多对一

    一对多与多对一关联，一般用于一个对象包含另一个对象的集合，被包含的对象中存在包含对象的实体，比如一个customer可以有多比订单(order)。在数据表中，order表有customer表的外键。

    在*.hbm中，一的一端使用set标签设置多的一端的集合，在set中加入key与one-to-many。

    多的一端使用<one-to-may>属性配置一对多。

    看一下实体类代码和配置文件：

package cn.net.bysoft.model1;

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

public class Customer {
    getter/setter属性
    
    private int Id;
    private String name;
    //    一对用户可以有多个订单。
    private Set<Order> orders = new HashSet<Order>();
}
package cn.net.bysoft.model1;

public class Order {
    getter/setter属性
    
    private int id;
    private String name;
    //    每个订单都属于一个用户。
    private Customer customer;
}
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.net.bysoft.model1.Customer" table="CUSTOMERS">
        <id name="id" type="integer" column="ID">
            <!-- 指定主键的生成方式，native是使用数据库本地的方式 -->
            <generator class="native"></generator>
        </id>
        <property name="name" type="string" column="NAME"></property>
        <!-- 一对多 -->
        <set name="orders" table="ORDERS">
            <key column="CUSTOMER_ID"></key>
            <one-to-many class="cn.net.bysoft.model1.Order"/>
        </set>
    </class>
</hibernate-mapping>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.net.bysoft.model1.Order" table="ORDERS">
        <id name="id" type="integer" column="ID">
            <!-- 指定主键的生成方式，native是使用数据库本地的方式 -->
            <generator class="native"></generator>
        </id>
        <property name="name" type="string" column="NAME"></property>
        <!-- 多对一 -->
        <many-to-one name="customer" class="cn.net.bysoft.model1.Customer" column="CUSTOMER_ID">
        </many-to-one>
    </class>
</hibernate-mapping>

    新增和删除的时候有一些需要注意的地方，看一段save代码：

    @Test
    public void testOneToManySave() {
        Customer customer = new Customer();
        customer.setName("Kobe");

        Order order1 = new Order();
        order1.setName("buy book");
        Order order2 = new Order();
        order2.setName("buy ball");

        customer.getOrders().add(order1);
        customer.getOrders().add(order2);

        order1.setCustomer(customer);
        order2.setCustomer(customer);

        session.save(customer);
        session.save(order1);
        session.save(order2);

        /**
         * output: Hibernate: 
         * insert into CUSTOMERS (NAME) values (?) 
         * insert into ORDERS (NAME, CUSTOMER_ID) values (?, ?) 
         * insert into ORDERS (NAME, CUSTOMER_ID) values (?, ?)
         * */
    }

    先save一的一端，在save多的一端，会打印三条sql语句，是正常的。如果先保存多的一端在保存一的一端，会输出七条sql语句，其中有4条是update语句，因为先保存多的一端，此时并没有一的一端的主键，等到保存好一的一端后，在回头由两端都进行update。

        session.save(order1);
        session.save(order2);
        session.save(customer);

        /**
         * output: 
         * Hibernate: insert into ORDERS (NAME, CUSTOMER_ID) values (?,?) 
         * Hibernate: insert into ORDERS (NAME, CUSTOMER_ID) values (?, ?)
         * Hibernate: insert into CUSTOMERS (NAME) values (?) 
         * Hibernate: update ORDERS set NAME=?, CUSTOMER_ID=? where ID=? 
         * Hibernate: update ORDERS set NAME=?, CUSTOMER_ID=? where ID=? 
         * Hibernate: update ORDERS set CUSTOMER_ID=? where ID=? 
         * Hibernate: update ORDERS set CUSTOMER_ID=? where ID=?
         * */

    正常来说，不需要两端都进行update维护，要解决该问题需要在一端加入inverse属性，建议由多的一端去控制，所以在Customer.hbm.xml中的set节点中加入：

<set name="orders" table="ORDERS" inverse="true">

    在进行保存时，update语句减少了，只由多的一端维护关系：

175954_WoP5_2450666.png

    再来说说delete。删除时在不设置级联的情况下，不能删除一的一端，因为这一端的主键被关键关联着：

    @Test
    public void testOneToManyDelete() {
        Customer customer = (Customer) session.get(Customer.class, 1);
        session.delete(customer);
        /**
         * output: 
         * INFO: HHH000010: On release of batch it still contained JDBC statements
         * */
    }

    使用级联关系的属性是cascade，该属性有三个值，分别是：

  • delete：删除一的一端，会连带着删除多的一端；

  • delete-orphan：一的一端使用多的一端的集合的clear属性可以删除多的一端；

  • save-update：值保存一的一端，多的一端会自动保存；

    在设置好级联关系后，可直接删除一的一端：

<set name="orders" table="ORDERS" inverse="true" cascade="delete">

    在项目中建议使用手动控制关联关系。

一对一

    有两种情况均为一对一关联关系，一个部门有一个部门经理。可以使用某一个字段做外键，也可以使用主键做外键。先来看看主外键情况做一对一。

    在Manager对象的配置文件中加入<one-to-one>节点，而Dept对象中加入<many-to-one>节点，对该节点加入unique属性进行唯一约束，下面是实体类与配置文件内容：

package cn.net.bysoft.model1;

public class Dept {
    //getter/setter

    private int id;
    private String name;
    private Manager manager;
}
package cn.net.bysoft.model1;

public class Manager {
    //getter/setter
    
    private int id;
    private String name;
    private Dept dept;
}
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.net.bysoft.model1.Dept" table="DEPT">
        <id name="id" type="integer" column="ID">
            <!-- 指定主键的生成方式，native是使用数据库本地的方式 -->
            <generator class="native"></generator>
        </id>
        <property name="name" type="string" column="NAME"></property>
        <!-- 多对一 -->
        <many-to-one name="manager" class="cn.net.bysoft.model1.Manager"
            column="MANAGER_ID" unique="true"></many-to-one>
    </class>
</hibernate-mapping>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.net.bysoft.model1.Manager" table="MANAGER">
        <id name="id" type="integer" column="ID">
            <!-- 指定主键的生成方式，native是使用数据库本地的方式 -->
            <generator class="native"></generator>
        </id>
        <property name="name" type="string" column="NAME"></property>
        <!-- 一对一 -->
        <one-to-one name="dept" class="cn.net.bysoft.model1.Dept" property-ref="manager"></one-to-one>
    </class>
</hibernate-mapping>

    接下来是主键与主键做一对一关系，实体类无需改变，只需要修改dept的配置文件，将id节点的class修改成foreign模式，将many-to-one修改成one-to-one，添加constrained属性等于true，具体如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.net.bysoft.model1.Dept" table="DEPT">
        <id name="id" type="integer" column="ID">
            <!-- 指定主键的生成方式，native是使用数据库本地的方式 -->
            <generator class="foreign">
                <param name="property">manager</param>
            </generator>
        </id>
        <property name="name" type="string" column="NAME"></property>
        <one-to-one name="manager" class="cn.net.bysoft.model1.Manager" constrained="true">
        </one-to-one>
    </class>
</hibernate-mapping>

    增删改查方法的调用与一对多多对一一样。

多对多

    用数据表描述多对多，需要有三张表，A表，B表，A-R-B表。

    用对象描述多对多，A对象中有B对象的集合，B对象中也有A对象的集合。

    举个例子，现在有订单类与商品类，一个订单中可以有多个商品，而一个商品也可以属于多个订单。看一下实体类的代码：

package cn.net.bysoft.model1;

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

public class Orders {

    //getter and setter

    private int id;
    private String name;
    private Set<Products> products = new HashSet<Products>();
}
package cn.net.bysoft.model1;

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

public class Products {
    //getter and setter

    private int id;
    private String name;
    private Set<Orders> orders = new HashSet<Orders>();
}

    两个对象的配置文件也很像，每个配置文件中都有set节点，但是在多对多中，必须有一个set的inverse=true，具体如下：

235947_cUT3_2450666.png

235948_3L4k_2450666.png

    使用方式与一对多多对一相同。

转载于:https://my.oschina.net/u/2450666/blog/653932

weixin_33923762
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate实现many-to-many的映射关系
08-26
在Java的持久化框架Hibernate中，映射关系是对象关系映射（ORM）的重要组成部分，它使得数据库中的表格数据能够与Java对象模型进行对应。在本文中，我们将深入探讨如何使用Hibernate来实现多对多（many-to-many）的...
Hibernate报错：On release of batch it still contained JDBC statements
momo_mo520的博客
04-16 3461
错误现象：Project和User使用注解多对一单向关联(@ManyToOne) // Project 类 @ManyToOne @JoinColumn(name = "user_id", nullable = false) private User user; 1 2 3 4 先new一个Project对象，并从数据库中取出User对象放入Project对象 ...
hibernate save数据到 oracle 问题之一：On release of batch it still contained JDBC statements
alinekang的博客
10-23 2182
要读取某个文件的数据存储到oracle 数据库，真的是，各种问题频繁而出啊。 在save操作的时候，报错 “On release of batch it still contained JDBC statements” 网上搜了一下，说是 Hibernate的删除和更新操作，只对persistence对象有效，即这些对象已存在于数据库中（可以是你通过查找操作从数据库中刚取出的对象）。而不能用n...
hibernate5--3.映射关系
03-10
在Java世界中，Hibernate是一个非常流行的ORM（对象关系映射）框架，它允许开发者使用面向对象的方式来操作数据库。本文将深入探讨Hibernate5中的映射关系，主要包括多对多（Many-to-Many）和一对多（One-to-Many）...
HibernateTools-3.2.4
04-27
4. **JPA注解工具**：允许将传统的Hibernate映射文件转换为Java Persistence API（JPA）的注解形式，方便使用JPA标准进行开发。 5. **Eclipse插件**：Hibernate Tools可以作为Eclipse的插件安装，提供图形化的界面...
Hibernate稳定版（hibernate-release-5.3.23.Final.zip）
01-07
Hibernate稳定版（hibernate-release-5.3.23.Final.zip），Hibernate ORM 是一个为应用程序、库和框架提供对象/关系映射 (ORM) 支持的库。它还提供了 JPA 规范的实现，这是 ORM 的标准 Java 规范。
hibernate-release-5.2.10
08-22
Hibernate是Java平台上的一款开源对象关系映射（ORM）框架，它允许开发者用面向对象的方式处理数据库操作。在SSH（Spring、Struts、Hibernate）框架中，Hibernate作为持久层的解决方案，极大地简化了数据库操作的...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1255
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 330
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 236
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 255
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 276
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Java：继承，this，super
最新发布
m0_75257168的博客
08-10 279
可以同名，但参数列表不能相同（有参无参构造）
JVM 加载阶段 Class对象加载位置是在 堆中还是方法区？
萧曳丶
08-06 386
Class对象的加载位置：Class对象本身是加载到堆区中的。类的类型信息加载位置：类的类型信息（元数据）是加载到方法区（或元空间）中的。因此，对于问题“jvm 加载阶段 Class加载到堆中还是方法区”，答案是：Class对象加载到堆中，而类的类型信息加载到方法区（或元空间）中。这两个区域在JVM的类加载过程中都扮演着重要的角色，共同支持着Java程序的运行。
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 202
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
log4j反序列化-流程分析
无
08-06 1138
JDK8u141依赖</</</</</</</</</
Hibernate对象-关系映射实战与解析
"Hibernate在行动——深入理解对象-关系映射技术" 在《Hibernate In Action》一书中，作者探讨了对象-关系持续性这一核心概念，特别是在Java应用开发中的重要性。对象-关系不匹配是软件工程中普遍存在的问题，由于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值