Hibernate入门06_多对多映射

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

一、多对多映射有单向多对多和双向多对多

项目文件目录

二、实现

商品有很多种，每个商品拿来分类，一个商品可以属于多个类别，一种分类下有多重商品

三、代码

共用的类

public class Category {
    private Integer id;
    private String name;
    private Set<Item> items = new HashSet<>();
    //set/get...
}

配置文件hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>

    <!-- 配置链接数据库的基本信息 -->
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate01</property>

        <!-- hibernate的基本信息 -->
        <!-- hibernate使用的数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 执行操作时是否在控制台打印sql语句 -->
        <property name="show_sql">true</property>
        <!-- 是否对sql进行格式化 -->
        <property name="format_sql">true</property>
        <!-- 指定自动生成数据表的策略 -->
        <property name="hbm2ddl.auto">create</property>
        <!-- 设置hibernate的隔离级别 -->
        <property name="connection.isolation">2</property>
        <!-- 删除对象后，设置其OID为null -->
        <property name="use_identifier_rollback">true</property>

        <!-- 配置C3P0数据源 -->
        <property name="c3p0.max_size">100</property>
        <property name="c3p0.min_size">5</property>
        <property name="c3p0.acquire_increment">2</property>
        <property name="c3p0.idle_test_period">2000</property>
        <property name="c3p0.timeout">2000</property>
        <property name="c3p0.max_statements">10</property>

        <!-- 设置JDBC的statement读取数据库的时候每次从数据库中读取记录条数，这个值100合适，太大会损耗内存，小了速度慢 -->
        <property name="jdbc.fetch_size">100</property>
        <!-- 设置数据库进行批量删除，更新，插入的时候批次的大小，30比较合适 -->
        <property name="jdbc.batch_size">30</property>

        <!-- 指定关联的hbm.xml文件 -->
        <!-- 单向多对多 -->
        <!-- 
        <mapping resource="com/hibernate/n2n/single/Category.hbm.xml"/>     
        <mapping resource="com/hibernate/n2n/single/Item.hbm.xml"/> 
         -->
        <!-- 双向多对多 -->  
        <mapping resource="com/hibernate/n2n/doubles/Category.hbm.xml"/>        
        <mapping resource="com/hibernate/n2n/doubles/Item.hbm.xml"/>    


    </session-factory>
</hibernate-configuration>
1、双向多对多
public class Item {
    private Integer id;
    private String name;
    private Set<Category> categories = new HashSet<>();
    //get/set...
}

Item.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">
<!-- Generated 2017-3-27 21:23:17 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.hibernate.n2n.doubles">
    <class name="Item" table="ITEMS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <set name="categories" table="CATEGORYS_ITEMS">
            <key column="I_ID"></key>
            <many-to-many class="com.hibernate.n2n.doubles.Category" column="C_ID"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

Category.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">
<!-- Generated 2017-3-27 21:23:17 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.hibernate.n2n.doubles">
    <class name="Category" table="CATEGORYS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <!-- table-指定中间表 -->
        <set name="items" table="CATEGORYS_ITEMS" inverse="true">
            <key>
                <column name="C_ID" />
            </key>
            <!-- column-Set集合中的持久类在中间表的外键列的名称 -->
            <many-to-many class="Item" column="I_ID" />
        </set>
    </class>
</hibernate-mapping>

Test

import static org.junit.Assert.*;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class HibernateTest {
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;

    @Test
    public void testN2NSave() {

        Category category1 = new Category();
        category1.setName("AA1");
        Category category2 = new Category();
        category2.setName("AA2");

        Item item1 = new Item();
        item1.setName("BB1");
        Item item2 = new Item();
        item2.setName("BB12");

        category1.getItems().add(item1);
        category1.getItems().add(item2);
        category2.getItems().add(item1);
        category2.getItems().add(item2);

        item1.getCategories().add(category1);
        item1.getCategories().add(category2);
        item2.getCategories().add(category1);
        item2.getCategories().add(category2);

        // 设定关联关系
        session.save(category1);
        session.save(category2);
        session.save(item1);
        session.save(item2);
    }
    @Test
    public void testGet(){
        Category category1 = (Category) session.get(Category.class, 3);
        System.out.println(category1.getName());
        Set<Item> items = category1.getItems();
        System.out.println(items.size());
//      session.delete(category1);
    }



    @Before
    public void init() {
        System.out.println("HibernateTest.init()");

        // 1.创建一个sessionFactory对象
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                .buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);

        // 2.创建一个session对象
        session = sessionFactory.openSession();

        // 3.开启事务
        transaction = session.beginTransaction();

    }

    @After
    public void destroy() {
        System.out.println("HibernateTest.destroy()");
        // 5.提交事务
        transaction.commit();
        // 6.关闭session
        session.close();
        // 7.关闭SessionFactory
        sessionFactory.close();

    }

}
2、单向多对多
public class Item {
    private Integer id;
    private String name;
    //get/set...
}

Item.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">
<!-- Generated 2017-3-27 21:23:17 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.hibernate.n2n.sibgle.Item" table="ITEMS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
    </class>
</hibernate-mapping>

Category.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">
<!-- Generated 2017-3-27 21:23:17 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.hibernate.n2n.single">
    <class name="Category" table="CATEGORYS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <!-- table-指定中间表 -->
        <set name="items" table="CATEGORYS_ITEMS">
            <key>
                <column name="C_ID" />
            </key>
            <!-- column-Set集合中的持久类在中间表的外键列的名称 -->
            <many-to-many class="Item" column="I_ID" />
        </set>
    </class>
</hibernate-mapping>

Test

import static org.junit.Assert.*;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class HibernateTest {
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;

    @Test
    public void testN2NSave() {

        Category category1 = new Category();
        category1.setName("AA1");
        Category category2 = new Category();
        category2.setName("AA2");

        Item item1 = new Item();
        item1.setName("BB1");
        Item item2 = new Item();
        item2.setName("BB12");

        category1.getItems().add(item1);
        category1.getItems().add(item2);
        category2.getItems().add(item1);
        category2.getItems().add(item2);

        // 设定关联关系
        session.save(category1);
        session.save(category2);
        session.save(item1);
        session.save(item2);
    }
    @Test
    public void testGet(){
        Category category1 = (Category) session.get(Category.class, 3);
        System.out.println(category1.getName());
        Set<Item> items = category1.getItems();
        System.out.println(items.size());
//      session.delete(category1);
    }



    @Before
    public void init() {
        System.out.println("HibernateTest.init()");

        // 1.创建一个sessionFactory对象
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                .buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);

        // 2.创建一个session对象
        session = sessionFactory.openSession();

        // 3.开启事务
        transaction = session.beginTransaction();

    }

    @After
    public void destroy() {
        System.out.println("HibernateTest.destroy()");
        // 5.提交事务
        transaction.commit();
        // 6.关闭session
        session.close();
        // 7.关闭SessionFactory
        sessionFactory.close();

    }

}
Mr_LGZ
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Hibernate步步为营】--多对多映射详解
航帆远洋
05-27 5933
上篇文章详细讨论了一对多映射，在一对多映射中单向的关联映射会有很多问题，所以不建议使用如果非要采用一对多的映射的话可以考虑使用双向关联来优化之间的关系，一对多的映射其实质上是在一的一端使用<many-to-one>标签来标明它们之间的关系，另外还需要在一的一端的对象中使用set标明集合映射。
Hibernate映射多对多
Keepsmileq的博客
03-07 320
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
8.多对多的关系映射
zhangyan的博客
01-19 545
多对多的关系映射 员工和角色是多对多的关系，一个员工可以分配多个角色，一个角色可以分配给多个员工 类图： 表关系：（需要有一个中间表） EmpNo    ename                               empNo            roleId                                 roleId       roleName ...
java一对多关联映射_Hibernate之关联关系映射(一对多和多对一映射，多对多映射)...
weixin_32829465的博客
02-28 247
~~~接着之前的Hibernate框架接着学习(上篇面试过后发现真的需要学习一下框架了，不然又被忽悠让去培训。)~~~1：Hibernate的关联映射，存在一对多和多对一映射，多对多映射：1.1：一对多和多对一映射，举例说明：学生和老师：一个老师可以教多个学生 【一对多映射】多个学生可以被一个老师教【多对一映射】部门与员工：一个部门有多个员工【一对多映射】多个员工属于一个部门【多对一映射】1.2：...
【MyBatis】映射一对多和多对多关系配置（看完这篇不吃亏）
无法自律的人的博客
08-27 4193
resultMap 允许我们定义复杂的映射规则，将结果集中的多个字段映射到一个对象中。因为我们是一对多的所以我们再编写vo类的时候，里面是使用list集合。建立我们给的sql文件，运行它用这里面的表，让我们更好的示例操作。在我们的配置文件里面配置我们需要的几个表，自动生成所需文件。当然我们要先建立这个包里面的类才能更好的下一步。在原本的基础的sql上我们增加一个一对多的sql。在上面我们已经写好了sql，我们生成对应的。在我们的里面添加一个sql的方法编写。在生成的接口类里面编写对应的接口方法。
多对多关系映射
超胆孤侠
12-20 449
域模型和关系模型 关系表单向多对多 n-n 的关联必须使用连接表 与 1-n 映射类似，必须为 set 集合元素添加 key 子元素，指定 CATEGORIES_ITEMS 表中参照 CATEGORIES 表的外键为 CATEGORIY_ID. 与 1-n 关联映射不同的是，建立 n-n 关联时, 集合中的元素使用 many-to-many. many-to-many 子元素的 class 属性
Hibernate映射一对多
Keepsmileq的博客
03-07 278
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
hibernate 映射关系学习入门 多对多实体映射
08-27
本教程将带你入门Hibernate的多对多实体映射，帮助你理解如何通过源码来实现这种复杂的关系映射。 一、Hibernate概述 Hibernate是一个对象关系映射（ORM）框架，它允许我们将Java对象（实体）与数据库表进行映射，...
hibernate学习入门一对多实体映射源码
08-27
在这个“hibernate学习入门之一对多实体映射源码”教程中，我们将深入探讨如何在Hibernate中设置和管理一对多的关系。 一、Hibernate简介 Hibernate是Java开发人员用于处理数据库操作的强大工具，通过它，我们可以...
hibernate-tutorials_java_hibernate_Eclipse_fallenweg_
10-02
本教程将详细介绍如何使用`@Entity`、`@Table`、`@Id`等注解，以及如何进行一对一、一对多、多对多等关联映射。 9. **查询语言（HQL）与 Criteria API** Hibernate提供了自己的查询语言HQL（Hibernate Query ...
hibernate_one_to_one映射简单入门例子
09-29
**一、Hibernate一对一映射简介** 在Java编程中，Hibernate是一个强大的对象关系映射（ORM）框架，它允许开发者将数据库操作转化为面向对象的方式。在数据表之间，有一种常见的关联关系是一对一（One-to-One），即...
hibernate 映射关系学习入门 一对一映射
08-27
本文将深入探讨 Hibernate 中的一对一映射关系，并以"hibernate 映射关系学习入门 一对一映射Eclipse源码"为主题，详细解析其概念、配置以及实际应用。 一对一映射是Hibernate中的一种关联关系，它表示两个实体之间...
Hibernate入门到精通
11-22
"Hibernate入门到精通" Hibernate 是一个基于Java的ORM（Object-Relational Mapping，对象关系映射）框架，它提供了一种简洁高效的方式来访问和操作关系数据库。下面是 Hibernate 的主要知识点： Hibernate 简介 ...
hibernate多表操作实例代码
08-28
本篇将深入探讨如何在Hibernate中进行多表操作，特别是多对多关系的实例。 **一、多对多关系简介** 在数据库设计中，多对多关系是指两个实体之间存在一对多的双向关系。例如，员工可以属于多个部门，部门也可以...
【Mybatis高级映射】一对一映射、一对多映射、多对多映射
01-02 517
前言 当我们学习heribnate的时候，也就是SSH框架的网上商城的时候，我们就学习过它对应的高级映射，一对一映射，一对多映射，多对多映射。对于SSM的Mybatis来说，肯定也是差不多的。既然开了头了，我们就也来简单说一些Mybatis的高级映射。当然说到这些东西的时候，最简单也最常用的就是级联查询，所以我们就以几个简单的级联查询为例，分别说一下Mybatis的一对一...
Hibernate多对多的关系映射，详解（代码+图解）与应用 举个栗子，搞的清楚
最新发布
2401_84409711的博客
04-18 833
外链图片转存中…(img-JVIdQqx3-1713382780713)][外链图片转存中…(img-6KeZowrn-1713382780714)][外链图片转存中…(img-tV1lyeIK-1713382780714)]
多对多映射
发飙的蜗牛
09-29 440
1、创建三张表，工程表 、 员工表 、 关系表 一个工程对应多个员工，一个员工也可能参与多个工程开发，即为多对多 create table t_project( pro_Id int primary key auto_increment, proName varchar(20) )DEFAULT charset=utf8; create table t_developer(
Hibernate入门教程：从映射到多对一与主键关联
多对一（Many-to-One）和一对一（One-to-One）关联映射在第03008和009-010章分别介绍，包括它们的关系模型、映射文件编写，以及如何处理级联操作（cascade），如数据同步和加载。此外，还有存储和加载测试，以及针对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值