Hibernate 映射多对多关联关系

最新推荐文章于 2021-12-02 15:11:35 发布
最新推荐文章于 2021-12-02 15:11:35 发布
阅读量553 收藏
点赞数 1
分类专栏： Hibernate 文章标签： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzi19933/article/details/50737399
版权

Category（商品类别）和Item（商品）是多对多的关系，在关系数据模型中，无法直接表达CATEGORIES表和ITEMS表之间的多对多，需要创建一个连接表CATEGORY_ITEM，它同时参照CATEGORIES表和ITEMS表。

1.映射单向多对多关联关系

仅建立Category类到Item类的单向多对多关联，在Category类中定义items属性，而在Item类中不定义categories属性。

数据库表：

create table CATEGORIES(
   ID bigint not null,
   NAME varchar(15),
   primary key (ID)
);

create table ITEMS(
  ID bigint not null,
  NAME varchar(15),
  BASE_PRICE double precision,
  primary key(ID)
);

create table CATEGORY_ITEM(
  CATEGORY_ID bigint not null,
  ITEM_ID bigint not null,
  primary key(CATEGORY_ID,ITEM_ID),
  foreign key (CATEGORY_ID) references CATEGORIES(ID),
  foreign key (ITEM_ID) references ITEMS(ID)
);

Category.java： 

public class Category implements Serializable {
    private Long id;
    private String name;
    private Set items=new HashSet();

    constructor()...; getter()...; setter()...;
}
Category.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Category" table="CATEGORIES" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
       
    <set name="items" table="CATEGORY_ITEM"
        lazy="true"
        cascade="save-update">
        <key column="CATEGORY_ID" />
        <many-to-many class="mypack.Item" column="ITEM_ID" />
    </set>
       
  </class>
</hibernate-mapping>

<set>元素的<key>子元素指定 CATEGORY_ITEM表中参照 CATEGORIES表的外键为 CATEGORY_ID， <many-to-many>子元素的class属性指定items集合中存放的是Item对象，column属性指定 CATEGORY_ITEM表中参照ITEMS表的外键是 ITEM_ID。

也可以使用<idbag>、<list>和<map>元素来映射Category类的items集合。

Item.java：

public class Item implements Serializable {
    private Long id;
    private String name;
    private double basePrice;

    constructor()...; getter()...; setter()...;
}
Item.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Item" table="ITEMS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
    <property name="basePrice" column="BASE_PRICE" type="double" />
     
  </class>
</hibernate-mapping>

2.映射双向多对多关联关系

建立Category类到Item类的双向多对多关联，在Category类中定义items属性，而在Item类中也要定义categories属性。

在双向多对多关联中，必须把其中一端的inverse属性设为true。inverse属性为false的一端可以使用<set>、<idbag>、<list>和<map>元素，而在inverse属性为true的一端只能使用<set>和<bag>元素。

<idbag>和<bag>元素的相同点在于都允许在集合中存放重复元素，并且都不支持按索引位置排序，区别在于<idbag>元素要求在连接表中必须定义代理主键，而<bag>元素没有此要求。

2.1.关联两端均使用<set>元素

数据库表：

create table CATEGORIES(
   ID bigint not null,
   NAME varchar(15),
   primary key (ID)
);

create table ITEMS(
  ID bigint not null,
  NAME varchar(15),
  BASE_PRICE double precision,
  primary key(ID)
);

create table CATEGORY_ITEM(
  CATEGORY_ID bigint not null,
  ITEM_ID bigint not null,
  primary key(CATEGORY_ID,ITEM_ID),
  foreign key (CATEGORY_ID) references CATEGORIES(ID),
  foreign key (ITEM_ID) references ITEMS(ID)
);

Category.java： 

public class Category implements Serializable {
    private Long id;
    private String name;
    private Set items=new HashSet();

    constructor()...; getter()...; setter()...;
}
Category.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Category" table="CATEGORIES" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
       
    <set name="items" table="CATEGORY_ITEM"
        lazy="true"
        cascade="save-update">
        <key column="CATEGORY_ID" />
        <many-to-many class="mypack.Item" column="ITEM_ID" />
    </set>
       
  </class>
</hibernate-mapping>

Item.java： 

public class Item implements Serializable {
    private Long id;
    private String name;
    private double basePrice;
    private Set categories=new HashSet();

    constructor()...; getter()...; setter()...;
}
Item.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Item" table="ITEMS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
    <property name="basePrice" column="BASE_PRICE" type="double" />
    
    <set name="categories" table="CATEGORY_ITEM"
        lazy="true"
        inverse="true"
        cascade="save-update">
        <key column="ITEM_ID" />
        <many-to-many class="mypack.Category" column="CATEGORY_ID" />
    </set>
 
  </class>
</hibernate-mapping>

2.2.在inverse端使用<bag>元素

假如在Category类中已经定义了List类型的items集合，并在Item类中定义了List类型的categories集合，只有在non-inverse的一端可以使用<list>元素，那么在inverse的一端使用什么元素，显然不能使用<set>，因为<set>不能映射<list>类型的集合，为此，Hibernate提供了<bag>元素。

数据库表：

create table CATEGORIES(
   ID bigint not null,
   NAME varchar(15),
   primary key (ID)
);

create table ITEMS(
  ID bigint not null,
  NAME varchar(15),
  BASE_PRICE double precision,
  primary key(ID)
);

create table CATEGORY_ITEM(
  POSITION bigint not null,
  CATEGORY_ID bigint not null,
  ITEM_ID bigint not null,
  primary key(POSITION,CATEGORY_ID),
  foreign key (CATEGORY_ID) references CATEGORIES(ID),
  foreign key (ITEM_ID) references ITEMS(ID)
);

Category.java： 

public class Category implements Serializable {
    private Long id;
    private String name;
    private List items=new ArrayList();

    constructor()...; getter()...; setter()...;
}
Category.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Category" table="CATEGORIES" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
       
 <list name="items" table="CATEGORY_ITEM"
        lazy="true"
        cascade="save-update">
        <key column="CATEGORY_ID" />
        <index column="POSITION" />
        <many-to-many class="mypack.Item" column="ITEM_ID" />
 </list>
      
  </class>
</hibernate-mapping>

Item.java： 

public class Item implements Serializable {
    private Long id;
    private String name;
    private double basePrice;
    private List categories=new ArrayList();

    constructor()...; getter()...; setter()...;
}
Item.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Item" table="ITEMS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
    <property name="basePrice" column="BASE_PRICE" type="double" />
    
    <bag name="categories" table="CATEGORY_ITEM"
        lazy="true"
        inverse="true"
        cascade="save-update">
        <key column="ITEM_ID" />
        <many-to-many class="mypack.Category" column="CATEGORY_ID" />
    </bag>
 
  </class>
</hibernate-mapping>

2.3.使用组件类集合

Item和Order之间也是多对多的关联关系，可以通过专门的组件类LineItem来描述Order与Item的关联关系。

LineItem类作为组件类没有OID，LINEITEMS表为连接表。

数据库表：

create table ORDERS(
   ID bigint not null,
   ORDER_NUMBER varchar(15),
   primary key (ID)
);

create table ITEMS(
  ID bigint not null,
  NAME varchar(15),
  BASE_PRICE double precision,
  primary key(ID)
);

create table LINEITEMS(
  ORDER_ID bigint not null,
  ITEM_ID bigint not null,
  BASE_PRICE double precision not null,
  QUANTITY  int not null,
  primary key(ORDER_ID,ITEM_ID,BASE_PRICE,QUANTITY),
  oreign key (ORDER_ID) references ORDERS(ID),
  foreign key (ITEM_ID) references ITEMS(ID)
);

Order.java： 

public class Order implements Serializable {
    private Long id;
    private String orderNumber;
    private double price;
    private Set lineItems=new HashSet();

    constructor()...; getter()...; setter()...;
}
Order.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Order" table="ORDERS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="orderNumber" column="ORDER_NUMBER" type="string" />
    
    <property name="price" formula=
        "(select  sum(line.BASE_PRICE*line.QUANTITY)  from LINEITEMS line where line.ORDER_ID=ID)" />

    <set name="lineItems" lazy="true" table="LINEITEMS" >
        <key column="ORDER_ID" />
        <composite-element class="mypack.LineItem" >
          <parent name="order" />
          <many-to-one name="item" class="mypack.Item" column="ITEM_ID" not-null="true"/>
          <property name="quantity" column="QUANTITY" type="int" not-null="true" />
          <property name="basePrice" column="BASE_PRICE" type="double" not-null="true" />
         </composite-element>
    </set>
     
  </class>
</hibernate-mapping>

Order类的price属性被映射为了派生属性，因此在ORDERS表中不必定义PRICE字段。

Item.java：

public class Item implements Serializable {
    private Long id;
    private String name;
    private double basePrice;
    private Set lineItems=new HashSet();
    constructor()...; getter()...; setter()...;
}

Item.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Item" table="ITEMS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
    <property name="basePrice" column="BASE_PRICE" type="double" />
    
     <set name="lineItems" lazy="true" inverse="true" table="LINEITEMS" >
        <key column="ITEM_ID" />
        <composite-element class="mypack.LineItem" >
          <parent name="item" />
          <many-to-one name="order" class="mypack.Order" column="ORDER_ID" not-null="true"/>
          <property name="quantity" column="QUANTITY" type="int" not-null="true" />
          <property name="basePrice" column="BASE_PRICE" type="double" not-null="true" />
         </composite-element>
    </set>
 
  </class>
</hibernate-mapping>

LineItem.java： 

public class LineItem implements Serializable {
    private Item item;
    private Order order;
    private double basePrice;
    private int quantity;

    constructor()...; getter()...; setter()...;
}

2.4.把多对多关联分解为两个一对多关联

对于Order与Item的多对多关联，也可以把它分解为两个一对多关联。LineItem为独立的实体类，有单独的OID。Order类与LineItem类，以及Item类与LineItem类都是一对多的双向关联关系。

LINEITEMS表作为连接表，LINEITEMS表有单独的ID代理主键。

数据库表：

create table ORDERS(
   ID bigint not null,
   ORDER_NUMBER varchar(15),
   primary key (ID)
);

create table ITEMS(
  ID bigint not null,
  NAME varchar(15),
  BASE_PRICE double precision,
  primary key(ID)
);

create table LINEITEMS(
  ID bigint not null,
  ORDER_ID bigint not null,
  ITEM_ID bigint not null,
  BASE_PRICE double precision,
  QUANTITY  int,
  primary key(ID),
  foreign key (ORDER_ID) references ORDERS(ID),
  foreign key (ITEM_ID) references ITEMS(ID)
);

Order.java： 

public class Order implements Serializable {
    private Long id;
    private String orderNumber;
    private double price;
    private Set lineItems=new HashSet();

    constructor()...; getter()...; setter()...;

    public void setLineItems(Set lineItems) {
        this.lineItems = lineItems;
        calculatePrice();
    }

    private void calculatePrice(){
      double totalPrice=0;
      if(lineItems==null) return;
      Iterator it=lineItems.iterator();
      while(it.hasNext()){
        LineItem line=(LineItem)it.next();
        totalPrice=totalPrice+line.getUnitPrice();
      }
      setPrice(totalPrice);
    }
}
在setLineItems()方法中自动为price属性赋值，因此无需在Order.hbm.xml中映射price属性，也无须在ORDERS表中定义PRICE字段。setLineItems()方法调用calculatePrice()方法计算price属性值。

Order.hbm.xml：

<hibernate-mapping >
  <class name="mypack.Order" table="ORDERS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

   <property name="orderNumber" column="ORDER_NUMBER" type="string" />
    
   <set name="lineItems" lazy="true" inverse="true" cascade="save-update">
        <key column="ORDER_ID" />
        <one-to-many  class="mypack.LineItem" />
   </set>
     
  </class>
</hibernate-mapping>

Item.java： 

public class Item implements Serializable {
    private Long id;
    private String name;
    private double basePrice;
    private Set lineItems=new HashSet();

    constructor()...; getter()...; setter()...;
}
Item.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.Item" table="ITEMS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="name" column="NAME" type="string" />
    <property name="basePrice" column="BASE_PRICE" type="double" />
    
     <set name="lineItems" lazy="true" inverse="true" cascade="save-update">
        <key column="ITEM_ID" />
        <one-to-many  class="mypack.LineItem" />
     </set>
 
  </class>
</hibernate-mapping>

LineItem.java： 

public class LineItem implements Serializable {
    private Long id;
    private Item item;
    private Order order;
    private double basePrice;
    private int quantity;

    constructor()...; getter()...; setter()...;
}
LineItem.hbm.xml： 

<hibernate-mapping >
  <class name="mypack.LineItem" table="LINEITEMS" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>

    <property name="quantity" column="QUANTITY" type="int" />
    <property name="basePrice" column="BASE_PRICE" type="double" />
    
    <many-to-one name="order" column="ORDER_ID" class="mypack.Order" not-null="true" />
    <many-to-one name="item" column="ITEM_ID" class="mypack.Item" not-null="true" />
 
  </class>
</hibernate-mapping>


所有的多对多关联都可以分解为两个一对多关联，按照这种方式映射多对多关联，会使域模型和关系数据模型具有更好的可扩展性。

wangziustc
关注
专栏目录
hibernate一对多关联映射学习小结
08-29
在Hibernate中，一对多关联映射和多对一关联映射的区别在于维护的关系不同。多对一关联映射中，多的一端维护一的一端的关系，在加载多的一端时，可以将一的一端加载上来。一对多关联映射中，一的一端维护多的一端的...
hibernate多对多关联映射
04-05
在Java的持久化框架Hibernate中，多对多关联映射是一种常见的关系数据库模型映射方式，用于处理两个实体之间存在多个实例互相关联的情况。本文将深入探讨Hibernate如何实现多对多关联映射，并通过实际例子解析相关...
Hibernate多对多关系映射
Hi~Future
03-20 2094
多对多关系并不是两张表的关系，而是三张表的关系，而且要求必须有一个中间表，中间表必须只有两个字段，必须为复合主键，必须包含外键。 如果以上条件都满足，MyEclipse在三张表一起选择时，就可以生成多对多关系映射。   类一般只生成两个类，例如：学生选课中，只生成学生和课程类，关系使用以下方式描述： 1）  学生类中保存着该学生选择的所有课程对象，使用Set集合来保存。 2）  课程类中
精通Hibernate——建立双向一对多关联
路漫漫，水迢迢
08-04 707
当类与类之间建立了关联，就可以方便的从一个对象导航到另一个对象或者一组与他关联的对象。 对象位于内存中，在内存中从一个对象导航到另一个对象显然比到数据库中查询数据速度快多了。类与类之间到底建立双向还是单向都是由业务决定。以Customer和Order为例，如果软件应用有大量这样的需求： 根据客户可以查询该客户所有的订单 根据给定的订单可以查询发出订单的客户 以上需求就需要我们为Custome
05.Hibernate多对多关联
weixin_33901641的博客
02-08 115
前言：本文讲解使用Hibernate映射多对多关联关系，并使用多种方式映射多对多关联。1.数据库表的多对多关系 本文根据学生信息表(tb_student)和教师信息表(tb_teacher)来说明多对多映射关系，一个学生有多个老师，一个老师也有多个学生，其数据库模型图如下： 根据以上图，对应的建表语句如下：CREATE TABLE tb_student( ...
多对多关联映射
lkfmiaomiao的博客
10-30 327
多对多关联映射 两个实体型之间的联系 多对多联系 定义 如果对于实体集A中的每一个实体，实体集B中有n个实体（n≥0）与之联系，反之，对于实体集B中的每一个实体，实体集A中也有m个实体（m≥0）与之联系，则称实体集A与实体B具有多对多联系，记为m:n。 在实体中实现多对多联系的设计 在需要关联的实体中设计关联对象的集合 数据库中实现多对多联系的设计 可是使用第三方表 该表中会生成...
hibernate系列九:多对多关联配置及案例(一)
御前两把刀的专栏
11-29 447
前面已介绍了映射一对多和多对一关联关系的方法，这是软件开发中最常见的关联关系。下面将介绍另一种关联关系的映射：多对多关联。 以Course（课程）与Student（学生）类的关系为例，介绍映射多对多关联。一门课程需要多位学生参与，一位学生可能选修多门课程，构成了课程和学生之间的多对多的关系。Course表（课程）、Student表（学生）如图6.4所示。在关系数据模型中，无法直接表达Course
角色（使用hibernate映射多对多的关系）.zip
最新发布
07-24
"角色（使用hibernate映射多对多的关系）.zip"这个压缩包文件提供了一个实例，展示了如何利用Hibernate来映射数据库中的多对多关联。在这个案例中，"角色"可能是一个典型的业务对象，它可能与多个其他实体有关系，...
hibernate（多对多关系映射）
07-19
在Java的持久化框架Hibernate中，多对多（Many-to-Many）关系映射是一种常见的数据库交互模式，它用于表示两个实体之间复杂的关系。在这个场景中，一个实体可以与多个其他实体相关联，反之亦然。例如，在学生和课程...
详解hibernate双向多对多关联映射XML与注解版
08-30
在Hibernate框架中，多对多关联映射可以通过XML配置或注解方式进行。本文将深入探讨这两种方式。 首先，理解多对多关联的基本原理。在员工和角色的例子中，一个员工可以拥有多个角色，同时一个角色也可以被多个员工...
多对多关联映射(双向)
weixin_34355715的博客
11-15 386
关联映射方面的最后一篇了，我觉得映射文件的编写是使用hibernate的基础，而关联映射又是基础的基础，所以这方面分的细一些，罗嗦一些，说明白就好，呵呵。 多对多关联(双向)，相对单向，在实体上就是一端也保持另一端的对象集合，在映射文件中也配置上。但是要注意两边配置文件中指定的外键一定要对应。 1.对象模型： 2.关系模型：...
Hibernate对象关系映射-- 多对多关联关系映射
小小小森屿的博客
04-30 448
在关系型数据库中，如果表与表之间存在多对多的关系，是不符合关系型数据库设计范式的。一般需要把一个多对多关系映射为一张关联双方的表，这张表叫做连接表。 不管是单向映射还是双向映射，多对多关系都是基于连接表实现的。 下面通过用户(User)和角色(Role)来讲解多对多的关联映射。一个用户(User)有多个角色(Role)，一个角色对应多个用户，因此用户和角色之间构成多对多的关联关系。
多对多关联映射原理
北漂的IT小白菜
02-04 1202
在生活中也常常需要多对多的关系，例如多个学生对应多门课程，或者多个用户对应多个角色，那他们之间的关系如何维护呢？ 这时候就需要第三方来维护两者之间的关系。例如：      简单的说点就是多对多的关系需要一张关系表来维护。通过一张关系表分别建立与另外两张表的一对多的关系就OK了。例如用户和角色之间，通过用户角色关系表分别建立了与用户表、角色表之间的关系。如此看多对多的关系其实就是演化了的
EntityFrameWork Core从零开始,(四)双向多对多关联的配置
jamenu的博客
12-02 2226
Hibernate 的映射类型
wangziustc的博客
02-01 1312
1.Hibernate的内置映射类型 在对象-关系映射文件中，Hibernate采用映射类型作为Java类型和SQL类型的桥梁。 1.1.Java基本类型的Hibernate映射类型 Hibernate映射类型 Java类型 标准SQL类型 大小和取值范围 integer 或者 int int 或者 Integer INTEGER 4字节，-2^31 ~
Hibernate 创建 sessionFatory
wangziustc的博客
01-13 594
老版本： Configuration config = new Configuration(); config.addClass(XXX.class); SessionFactory sessionFactory = config.buildSessionFactory(); 或 SessionFactory sessionFactory = new Configuration().
Hibernate映射多对多关联关系详解
"这篇资料主要介绍了在Hibernate框架中如何映射多对多关联关系，并提到了hbm2ddl.auto的四个取值含义以及1-1关联的延迟加载策略。" 在Java开发中，Hibernate是一个非常流行的持久化框架，它简化了数据库操作。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值