Hibernate ORM 之 双向一对多

最新推荐文章于 2024-11-03 10:06:51 发布
最新推荐文章于 2024-11-03 10:06:51 发布
阅读量284 收藏
点赞数 1
分类专栏： Hibernate 文章标签： hibernate orm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lb565867230/article/details/78176585
版权

Hibernate ORM 之 双向一对多

多方：多方持有一方的引用
@ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)
@JoinColumn(name = “cid”, foreignKey = @ForeignKey(name = “fk_c_o”))

一方：一方持有多方的集合
@OneToMany(fetch = FetchType.LAZY, cascade = {CascadeType.ALL}, mappedBy = “customer”)
其中mappedBy指定由多方维护关联关系，保存实体时将不会产生update语句。如果不指定mappedBy属性，则需要使用@JoinColumn(name = “cid”)，否则hibernate将会生成中间表来维护实体之间的关联关系。

注意：在hibernate5中，标记为mappedBy的关联不能定义像@JoinTable或@JoinColumn这样的数据库映射，通俗来说mappedBy和@JoinColumn、@JoinTable不能同时使用。（貌似hibernate3.3.2之前可以同使用）

1 pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.libill</groupId>
    <artifactId>hibernate-demo</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>hibernate-demo Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.10.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

    </dependencies>
    <build>
        <finalName>hibernate-demo</finalName>
    </build>
</project>
2 hibernate.cfg.xml配置文件
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.url">jdbc:mysql://192.168.145.128:3306/hibernate?useUnicode=true&amp;characterEncoding=utf-8</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>
        <property name="connection.autocommit">false</property>

        <!-- DB schema will be updated if needed -->
        <property name="hbm2ddl.auto">create</property>
        <!-- 显示sql语句 -->
        <property name="show_sql">true</property>
        <!-- 显示sql语句前进行格式化 -->
        <property name="format_sql">true</property>
        <!-- 方言： MySQL55Dialect将会使用InnoDB引擎 -->
        <property name="dialect">org.hibernate.dialect.MySQL55Dialect</property>
        <!-- 双向一对多 -->
        <mapping class="com.libill.one2manysx.Customer"/>
        <mapping class="com.libill.one2manysx.Order"/>
    </session-factory>
</hibernate-configuration>
3 测试方法
package com.libill.one2manysx;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.hibernate.tool.schema.TargetType;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.EnumSet;

@SuppressWarnings(value = {"unused"})
public class One2ManySXTest {

    private SessionFactory sessionFactory;

    private Session session;

    private Transaction transaction;

    private SchemaExport schemaExport;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        sessionFactory = configuration.buildSessionFactory();
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    @After
    public void destroy() {
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

    /**
     * 测试实体对象的保存
     */
    @Test
    public void saveTest() {
        Customer customer = new Customer("张三", "13982502467");
        Order order = new Order("馒头");
        order.setCustomer(customer);
        customer.getOrders().add(order);
        session.save(customer);
    }

    /**
     * 测试根据实体对象生成数据库表，只创建表结构
     */
    @Test
    public void testSchema() {
        ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().configure().build();
        Metadata metadata = new MetadataSources(serviceRegistry).buildMetadata();
        SchemaExport schemaExport = new SchemaExport();
        schemaExport.create(EnumSet.of(TargetType.DATABASE), metadata);
    }

}
实体类（使用@JoinColumn，不使用mappedBy属性）
package com.libill.one2manysx;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "t_customer")
@SuppressWarnings(value = {"all"})
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String name;

    private String phone;

    @OneToMany(fetch = FetchType.LAZY, cascade = {CascadeType.ALL})
    @JoinColumn(name = "cid")
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {
    }

    public Customer(String name, String phone) {
        this.name = name;
        this.phone = phone;
    }

    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 String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Set<Order> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
}
package com.libill.one2manysx;

import javax.persistence.*;

@Entity
@Table(name = "t_order")
@SuppressWarnings(value = {"all"})
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String content;

    @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)
    @JoinColumn(name = "cid", foreignKey = @ForeignKey(name = "fk_c_o"))
    // foreignKey自定义外键名称，如果不写，则hibernate默认创建一个名称，多方或一方有一个指定即可，两方都写也可以。
    private Customer customer;

    public Order() {
    }

    public Order(String content) {
        this.content = content;
    }

    public int getId() {
        return id;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}
使用@JoinColumn的结果
Hibernate: 
    insert 
    into
        t_customer
        (name, phone) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        t_order
        (content, cid) 
    values
        (?, ?)
Hibernate: 
    update
        t_order 
    set
        cid=? 
    where
        id=?

可以看到，除了两条插入语句，还有一条update语句。

实体类（使用mappedBy，不使用@JoinColumn）
package com.libill.one2manysx;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "t_customer")
@SuppressWarnings(value = {"all"})
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String name;

    private String phone;

    @OneToMany(fetch = FetchType.LAZY, cascade = {CascadeType.ALL}, mappedBy = "customer")
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {
    }

    public Customer(String name, String phone) {
        this.name = name;
        this.phone = phone;
    }

    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 String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Set<Order> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
}
package com.libill.one2manysx;

import javax.persistence.*;

@Entity
@Table(name = "t_order")
@SuppressWarnings(value = {"all"})
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String content;

    @ManyToOne(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER)
    @JoinColumn(name = "cid", foreignKey = @ForeignKey(name = "fk_c_o"))
    private Customer customer;

    public Order() {
    }

    public Order(String content) {
        this.content = content;
    }

    public int getId() {
        return id;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}
使用mappedBy属性结果
Hibernate: 
    insert 
    into
        t_customer
        (name, phone) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        t_order
        (content, cid) 
    values
        (?, ?)

从结果可以看出，只执行了两条插入语句，没有更新语句。

2010其实你不懂
关注
专栏目录
Hibernate关联关系 之 一对多
qq_44641053的博客
07-15 252
Hibernate关联关系 之 一对多Hibernate关联关系Hibernate 一对多关联案例操作数据库实体类 entityxml 配置DemoDaoDemoDaoTestHibernate框架一对多的执行原理 Hibernate关联关系 什么是关联? (association) 关联指的是类之间的引用关系。 如果类A与类B关联，那么被引用的类B将被定义为类A的属性。 例如: class B...
Hibernate ORM - 一对多双向关联关系
03-28
这个压缩包文件“HibernateORM”很可能包含了关于如何在实际项目中设置和使用Hibernate一对多双向关联的示例代码、配置文件或者详细教程。通过学习这些材料，开发者能够深入理解如何在Java应用中利用Hibernate来处理...
quarkus数据库篇之一：比官方demo更简单的基础操作
程序员欣宸的博客
05-14 3206
《quarkus数据库篇》系列的开篇，编码实战最基础的数据库增删改查，数据库用的是PostgreSQL，在官方demo基础上进一步精简，极速入门quarkus数据库操作
在K8S上部署Web与数据库应用
03-24 2987
数据库的搭建，选择Postgresql 11.15版本 下载镜像 docker pull postgres:11.15-alpine3.15 在主机上设置一个PG的数据目录 mkdir ~/pg_data 运行PG镜像测试 docker run --name my_postgres -v /home/roy/data/pg_volume:/var/lib/postgresql/data -e POSTGRES_PASSWORD=roy2000 -p 5555:5432 -d postgres
Hibernate入门篇 - ORM真香
非真非假，非零非一
10-06 1074
文章目录Hibernate ORMHibernate架构配置对象SessionFactory对象Session对象Transaction对象Query对象Criteria引入Hibernate手动引入mavenhibernate.cfg.xml配置文件几个重要的配置属性数据库方言简单的XML映射文件hibernate type预设值原始类型日期和时间类型二进制和大型数据类型JDK相关类型映射注解@Entity@Table@Id@GeneratedValue@Column@DynamicUpdate和@Dyn
11 DB操作 -02 Hibernate 基本使用
Tong_Rui的博客
03-28 731
Hibernate 相信Java程序员都挺熟悉的了，不过应该国内的程序员都喜欢用MyBatis,老外更喜欢用Hibernate这种ORM框架。目前Quarkus只支持了Hibernate，包括响应式的方式目前也有了实现。本章简单介绍如何整合Hibernate。 1 本章目标 整合Hibernate 实现一个基本的CRUD 多数据源如何使用 schema管理工具介绍 2 搭建项目 2.1 引入依赖 <dependency> <groupId>io.quarkus<
hibernate ORM映射：双向多对一
无道圣教主
04-11 319
概念 ①双向1-n和双向n-1是完全相同的情况，只是表述方式不同。 ②要求： [1]从one的一端访问many的一端：one.getManySet(); [2]从many的一端访问one的一端：many.getOne(); 创建持久化类 one的一端 many的一端创建hbm.xml映射文件 one的一端 <set name ="orders" tabl
Hibernate ORM映射多对一
无道圣教主
04-11 335
多对一 生活中有很多数据直接是多对一的关联关系，例如：多个Order对应一个Customer。 关联的方向 关联是有方向的。如果从Order对象中能够获取到Customer对象，而从Customer对象中不能获取到Order对象，则关联是单向的。如果从Order和Customer对象中都能够获取到对方，则关联是双向的。我们首先来看单向的多对一关联关系。 创建持久化类 ①one：Custom
hibernateORM映射：双向多对一
jc_zhibaobao的博客
07-10 233
第05章 ORM映射：双向多对一    1 映射关系总览 ①单类→单表 ②单向n对1 ③双向1对n ④1对1基于外键 ⑤1对1基于主键 ⑥单向多对多 ⑦双向多对多   1 概念 ①双向1-n和双向n-1是完全相同的情况，只是表述方式不同。 ②要求： [1]从one的一端访问many的一端：one.getManySet(); [2]从many的一端访问one的一端：m
Hibernate ORM - 一对多双向组合关联关系
10-19 185
  　　对于一对多的关联关系方式还有一种比较特殊的做法就是将多方视为一方的组合元素，这样多方并不会在数据库中存在相应的数据表，而是由表征两者一对多关联关系的连接表来存储多方的数据，并且该连接表的主键标识符即是对建立与一方一对多关联关系的外键标识。   　　一。Husband   package com.orm.model; import java.util.List; /**...
Hibernate ORM - 一对多双向连接表关联关系
03-28
"HibernateORM"可能是包含有关Hibernate ORM框架的详细信息的文件夹或压缩包，里面可能包含示例代码、教程文档或其他资源，用于辅助学习和理解Hibernate ORM的一对多双向关联。 **知识点详解：** 1. **Hibernate ...
Hibernate ORM - 多对多双向连接表关联关系
03-28
本文将深入探讨Hibernate ORM中的一个关键概念——多对多双向连接表关联关系。这种关联关系在实际业务场景中非常常见，比如用户与角色、课程与学生等例子，都需要用到多对多的关系来描述它们之间的复杂联系。 首先...
Hibernate ORM - 一对一主键关联关系
03-28
综上所述，Hibernate ORM 的一对一主键关联关系是通过共享主键或外键约束来实现两个实体间的唯一对应。在实际应用中，开发者需要根据需求选择合适的关联方式，并注意关联带来的性能影响。通过理解并熟练掌握这些配置...
web安全测试渗透案例知识点总结（上）——小白入狱
专研计算机网络，数据通信，网络安全，系统集成
11-03 1023
SQL注入（SQL Injection）概念：SQL注入通过在SQL查询中注入恶意代码，使攻击者能够读取、修改数据库中的数据。原理：服务器直接使用用户输入构建SQL语句，导致未经过滤的特殊字符被当成SQL指令执行。防御措施：使用参数化查询（Prepared Statement）、ORM框架，过滤特殊字符。跨站脚本（XSS）概念：通过注入脚本代码使得用户浏览器执行，常用于窃取用户信息或操控用户账户。原理：攻击者在网站中注入恶意代码，代码被受害者浏览器执行，造成数据泄露或操控。防御措施。
macOS_Sequoia_15.1.password(imacos.top).rdr.split.016
11-09
macOS_Sequoia_15.1.password(imacos.top).rdr.split.016
【java毕业设计】小区物业管理系统（springboot+vue+mysql+说明文档）.zip
最新发布
11-09
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
里面全部都是浪漫的爱心特效，有html和python编写的，大概几十种，欢迎下载，收藏
11-09
里面全部都是浪漫的爱心特效，有html和python编写的，大概几十种，欢迎下载，收藏
Hibernate配置：一对多双向关联映射实战解析
双向一对多映射的实现通常需要在两个实体类中都进行配置。在`Orgnization`类中，除了上述的`children`集合，还应有一个`Parent`属性，通过`@ManyToOne`注解来实现反向引用。同时，`Parent`的类也需要有`Set...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值