Hibernate 关联关系（一对多）

1. 什么是关联(association)

1.1 关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。例如:
class B{

private String name;

private List<A> bs = new arraylist();
    }

public class A{
private B b = new B;
public A(){

      }
}
hibernate:orm框架、以面向对象的思想操作数据库

1.2 关联的分类：关联可以分为一对一、一对多/多对一、多对多关联
关联是有方向的

案列：

导入映射文件Order.hbm.xml和OrderItem.hbm.xml

Order.hbm.xm

进行关联关系的维护一对多的关系

OrderItem.hbm.xml

进行关联关系的维护 一对多的关系

hibernate.cfg.xml(核心配置文件)添加映射文件OrderItem.hbm.xml和Order.hbm.xm

 对应映射文件的实体类

Order.hbm.xml

  1. Order 
  1.  package com.MavenHibernate.three.entity;
  2.  
  3.  import java.util.ArrayList;
  4.  import java.util.List;
  5.  
  6.  public class Order {
  7.  
  8.      private Integer orderId;
  9.      private String orderNo;
  10.      private List<OrderItem> orderItems = new ArrayList<>();
  11.  
  12.      public List<OrderItem> getOrderItems() {
  13.          return orderItems;
  14.      }
  15.  
  16.      public void setOrderItems(List<OrderItem> orderItems) {
  17.          this.orderItems = orderItems;
  18.      }
  19.  
  20.      public List<OrderItem> getOrderItem() {
  21.          return orderItems;
  22.      }
  23.  
  24.      public void setOrderItem(List<OrderItem> orderItem) {
  25.          this.orderItems = orderItem;
  26.      }
  27.      @Override
  28.      public String toString() {
  29.          return "Order [orderId=" + orderId + ", orderNo=" + orderNo + ", orderItem=" + orderItems + "]";
  30.      }
  31.      public Integer getOrderId() {
  32.          return orderId;
  33.      }
  34.      public void setOrderId(Integer orderId) {
  35.          this.orderId = orderId;
  36.      }
  37.      public String getOrderNo() {
  38.          return orderNo;
  39.      }
  40.      public void setOrderNo(String orderNo) {
  41.          this.orderNo = orderNo;
  42.      }
  43.      public Order(Integer orderId, String orderNo) {
  44.          super();
  45.          this.orderId = orderId;
  46.          this.orderNo = orderNo;
  47.      }
  48.      public Order() {
  49.          super();
  50.      }
  51.  
  52.  }

OrderItem.hbm.xml

OrderItem

  1.  package com.MavenHibernate.three.entity;
  2.  
  3.  public class OrderItem {
  4.  
  5.      private Integer orderItemId;
  6.      private Integer productId;
  7.      private Integer quantity;
  8.      private Integer oid;
  9.      private Order order;
  10.  
  11.      public Order getOrder() {
  12.          return order;
  13.      }
  14.      public void setOrder(Order order) {
  15.          this.order = order;
  16.      }
  17.      @Override
  18.      public String toString() {
  19.          return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity
  20.                  + ", oid=" + oid + ", order=" + order + "]";
  21.      }
  22.      public Integer getOrderItemId() {
  23.          return orderItemId;
  24.      }
  25.      public void setOrderItemId(Integer orderItemId) {
  26.          this.orderItemId = orderItemId;
  27.      }
  28.      public Integer getProductId() {
  29.          return productId;
  30.      }
  31.      public void setProductId(Integer productId) {
  32.          this.productId = productId;
  33.      }
  34.      public Integer getQuantity() {
  35.          return quantity;
  36.      }
  37.      public void setQuantity(Integer quantity) {
  38.          this.quantity = quantity;
  39.      }
  40.      public Integer getOid() {
  41.          return oid;
  42.      }
  43.      public void setOid(Integer oid) {
  44.          this.oid = oid;
  45.      }
  46.      public OrderItem(Integer orderItemId, Integer productId, Integer quantity, Integer oid) {
  47.          super();
  48.          this.orderItemId = orderItemId;
  49.          this.productId = productId;
  50.          this.quantity = quantity;
  51.          this.oid = oid;
  52.      }
  53.      public OrderItem() {
  54.          super();
  55.      }
  56.  
  57.  }

测试：

  1. DemoDao 
  1.  package com.MavenHibernate.three.Dao;
  2.  
  3.  import java.util.List;
  4.  
  5.  import org.hibernate.Session;
  6.  import org.hibernate.Transaction;
  7.  
  8.  import com.MavenHibernate.three.entity.Order;
  9.  import com.MavenHibernate.three.entity.OrderItem;
  10.  import com.MavenHibernate.two.util.SessionFactoryUtils;
  11.  
  12.  public class DemoDao {
  13.      /**
  14.       * 为了测试关系型映射文件配置准确
  15.       *     讲解insert=false，update=false的用途
  16.       * @param order
  17.       * @return
  18.       */
  19.      public Integer addOrder(Order order) {
  20.          Session session = SessionFactoryUtils.openSession();
  21.          Transaction transaction = session.beginTransaction();
  22.          Integer oid = (Integer)session.save(order);
  23.          transaction.commit();
  24.          session.close();
  25.          return oid;
  26.      }
  27.  
  28.      public Integer addOrderItem(OrderItem orderItem) {
  29.          Session session = SessionFactoryUtils.openSession();
  30.          Transaction transaction = session.beginTransaction();
  31.          Integer otid = (Integer)session.save(orderItem);
  32.          transaction.commit();
  33.          session.close();
  34.          return otid;
  35.      }
  36.  
  37.      /**
  38.       * 为了讲解懒加载的问题（hibernate3.0后所有查询方式默认采用的是懒加载方式）
  39.       *     1、查单个时存在问题，代理对象已经关闭
  40.       *     2、查多个存在问题，有性能的问题
  41.       * @param order
  42.       * @return
  43.       */
  44.      public Order getOrder(Order order) {
  45.          Session session = SessionFactoryUtils.openSession();
  46.          Transaction transaction = session.beginTransaction();
  47.          Order o = session.get(Order.class, order.getOrderId());
  48.  //        if(o != null && new Integer(1).equals(order.getInitChildren())) {
  49.  //            Hibernate.initialize(o.getOrderItems());
  50.  ////            System.out.println(o.getOrderItems());
  51.  //        }
  52.          transaction.commit();
  53.          session.close();
  54.          return o;
  55.      }
  56.  
  57.      public List<Order> getOrderList() {
  58.          Session session = SessionFactoryUtils.openSession();
  59.          Transaction transaction = session.beginTransaction();
  60.          List<Order> list = session.createQuery("from Order").list();
  61.          transaction.commit();
  62.          session.close();
  63.          return list;
  64.      }
  65.  
  66.      /**
  67.       * z主表的数据不能随便删除，得先删除从表中对应信息，才能删除主表的信息。
  68.       * @param order
  69.       */
  70.      public void delOrder(Order order) {
  71.          Session session = SessionFactoryUtils.openSession();
  72.          Transaction transaction = session.beginTransaction();
  73.          Order order2 = session.get(Order.class, order.getOrderId());
  74.          for (OrderItem oi : order2.getOrderItems()) {
  75.              session.delete(oi);
  76.          }
  77.          session.delete(order2);
  78.  //        session.delete(order);
  79.          transaction.commit();
  80.          session.close();
  81.      }
  82.  }

利用junit进行DemoDao测试

DemoDaoTest

  1.  package com.MavenHibernate.three.Dao;
  2.  
  3.  import static org.junit.Assert.*;
  4.  
  5.  import org.junit.Before;
  6.  import org.junit.Test;
  7.  
  8.  import com.MavenHibernate.three.entity.Order;
  9.  import com.MavenHibernate.three.entity.OrderItem;
  10.  
  11.  public class DemoDaoTest {
  12.  
  13.      private DemoDao demoDao=new DemoDao();
  14.  
  15.      @Before
  16.      public void setUp() throws Exception {
  17.      }
  18.  
  19.      @Test
  20.      public void testAddOrder() {
  21.          Order order = new Order();
  22.          order.setOrderNo("226");
  23.          OrderItem oi=null;
  24.          for (int i = 0; i < 3; i++) {
  25.              oi = new OrderItem();
  26.              oi.setProductId(10+i);
  27.              oi.setQuantity(20+i);
  28.              oi.setOrder(order);
  29.              order.getOrderItems().add(oi);
  30.  
  31.          }
  32.          demoDao.addOrder(order);
  33.      }
  34.  
  35.      //订单项
  36.      @Test
  37.      public void testAddOrderItem() {
  38.          Order order = new Order();
  39.          order.setOrderId(5);
  40.          OrderItem oi=null;
  41.          for (int i = 0; i < 3; i++) {
  42.              oi = new OrderItem();
  43.              oi.setProductId(10+i);
  44.              oi.setQuantity(20+i);
  45.              oi.setOrder(order);
  46.              order.getOrderItems().add(oi);
  47.              demoDao.addOrderItem(oi);
  48.  
  49.          }
  50.      }
  51.  
  52.  }

结果：

订单项

2.懒加载

DemoDaoTest

运行时控制台会报一个这样的错误：

处理方式：（第一种）
在对应实体映射文件中的关联关系的维护中添加 lazy="false"

处理方式：（第二种）
   在一对多的实体类中添加属性是否打开懒加载

 在order实体类中

 DemoDao中的懒加载方法

 DemoDaoTest

  1.  package com.MavenHibernate.three.Dao;
  2.  
  3.  import static org.junit.Assert.*;
  4.  
  5.  import java.util.List;
  6.  
  7.  import org.junit.Before;
  8.  import org.junit.Test;
  9.  
  10.  import com.MavenHibernate.three.entity.Order;
  11.  import com.MavenHibernate.three.entity.OrderItem;
  12.  
  13.  public class DemoDaoTest {
  14.  
  15.      private DemoDao demoDao=new DemoDao();
  16.  
  17.       public void setUp() throws Exception {
  18.      }
  19.  
  20.      @Test
  21.      public void testAddOrder() {
  22.          Order order = new Order();
  23.          order.setOrderNo("226");
  24.          OrderItem oi=null;
  25.          for (int i = 0; i < 3; i++) {
  26.              oi = new OrderItem();
  27.              oi.setProductId(10+i);
  28.              oi.setQuantity(20+i);
  29.              oi.setOrder(order);
  30.              order.getOrderItems().add(oi);
  31.  
  32.          }
  33.          demoDao.addOrder(order);
  34.      }
  35.  
  36.      //订单项
  37.      @Test
  38.      public void testAddOrderItem() {
  39.          Order order = new Order();
  40.          order.setOrderId(5);
  41.          OrderItem oi=null;
  42.          for (int i = 0; i < 3; i++) {
  43.              oi = new OrderItem();
  44.              oi.setProductId(10+i);
  45.              oi.setQuantity(20+i);
  46.              oi.setOrder(order);
  47.              order.getOrderItems().add(oi);
  48.              demoDao.addOrderItem(oi);
  49.  
  50.          }
  51.      }
  52.  
  53.      /**
  54.       * 关于懒加载的问题
  55.       * hibernate3之后出现的
  56.       *  failed to lazily initialize a collection of role:
  57.       *   com.MavenHibernate.three.entity.Order.orderItems, could not initialize proxy - no Session
  58.       *   * orderNo数据来源于t_hibernate_order表
  59.       * orderItems数据来源于t_hibernate_order_item表
  60.       *
  61.       * 因为两表有关联关系所以不可以分开查询，
  62.       * 而hibernate默认的策略是不查询关联关系对应关联表数据的
  63.       *
  64.       * 处理方式：（第一种）
  65.       * 在对应实体映射文件中的关联关系的维护中添加  lazy="false"
  66.       * 如：<bag lazy="false" name="orderItems"  cascade="save-update" inverse="true">
  67.       */
  68.  
  69.      @Test
  70.      public void testGetOrder() {
  71.          Order order = new Order();
  72.          order.setOrderId(10);
  73.          //关闭懒加载
  74.          order.setInitChildren(0);
  75.          Order o = this.demoDao.getOrder(order);
  76.          System.out.println(o.getOrderNo());
  77.          System.out.println(o.getOrderItems());
  78.      }
  79.  
  80.      /**
  81.       * 查询多个
  82.       * 在查询单个中懒加载问题的解决方案
  83.       * 会导致在查询多个的时候sql语句也会增多，
  84.       * 当查询数据过多的时候导致代码性能变低
  85.       *
  86.       * 总：如果将懒加载的功能关闭，即：lazy=false，
  87.       * 那么在查询多条订单数据的情况下是非常影响性能的
  88.       *
  89.       * 查单个需要关闭懒加载    目的是需要加载出关联表的数据
  90.       * 查多个不能关闭懒加载    加载关联表的数据的查询次数过多
  91.       *
  92.       * 处理方式：（第二种）
  93.       * 在一对多的实体类中添加属性是否打开懒加载
  94.       *
  95.       */
  96.      @Test
  97.      public void testGetOrderList() {
  98.          List<Order> orderList = this.demoDao.getOrderList();
  99.          for (Order order : orderList) {
  100.              System.out.println(order.getOrderNo());
  101.  //            System.out.println(order.getOrderItems());
  102.          }
  103.      }
  104.      /**
  105.       * 删除订单，关联关系同时删除
  106.       */
  107.      @Test
  108.      public void testDelOrder() {
  109.          Order order = new Order();
  110.          order.setOrderId(10);
  111.          this.demoDao.delOrder(order);
  112.      }
  113.  
  114.  }

Hibernate 关联关系（一对多）的更多相关文章

  1. hibernate关联关系(一对多)

    什么是关联(association)关联指的是类之间的引用关系.如果类A与类B关联,那么被引用的类B将被定义为类A的属性.例如: class B{ private String name; } pub ...

  2. hibernate关联关系一对多

    1. 什么是关联(association) 1.1 关联指的是类之间的引用关系.如果类A与类B关联,那么被引用的类B将被定义为类A的属性 首先建2个实体类 Order.java package com ...

  3. hibernate 的一对多关联关系映射配置

    hibernate 是操作实体类: 表是一对多的关系,当创建这2个实体的时候 在一的一方定义一个多的一方的集合 在多的一方定义一个一的一方的对象 表是多对多的关系,当创建这2个实体的时候 在互相中都有 ...

  4. hibernate关联关系的crud2

    hibernate关联关系的CRUD操作,解释都在注释里了,讲了fetchType.cascade. User类: package com.oracle.hibernate; import javax ...

  5. Hibernate 单项一对多的关联映射

    在上一篇中我们简单介绍了多对一的关联映射,本文介绍hibernate中一对多的关联映射. 1.设计表结构 虽然关联关系由多对一变为一对多,但是我们表结构不会发生改变,只是指向变了. 2.创建stude ...

  6. hibernate关联关系（多对多）

    数据库的多对多数据库中不能直接映射多对多 处理:创建一个桥接表(中间表),将一个多对多关系转换成两个一对多 注:数据库多表联接查询 永远就是二个表的联接查询 注2:交叉连接 注3:外连接:left(左 ...

  7. Hibernate关联关系的映射

    实体之间的关系 实体之间有三种关系 一对多:一个用户,生成多个订单,每一个订单只能属于一个用户 建表原则:在多的一方创建一个字段,作为外键,指向一的一方的主键 多对多:一个学生可以选择多门课程,一个课 ...

  8. hibernate关联关系笔记

    Hibernate关联关系笔记 单向N:1 *  有连接表:在N方使用<join>/<many-to-one>.1方无需配置与之关联的持久化类. *  没有连接表:在N方使用& ...

  9. 用户、角色、权限三者多对多用hibernate的一对多注解配置

    用户.角色.权限三者多对多用hibernate的一对多注解配置 //权限表@Table(name = "p")public class P { @Id @GeneratedValu ...

随机推荐

  1. ng的动画过渡

    动画过渡两种方法 1.使用angular+animation实现 在app-module.ts中引入 BrowserAnimationsModule 1.import { BrowserAnimati ...

  2. POJ 1146 ID Codes 用字典序思想生成下一个排列组合

    ID Codes Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 7644   Accepted: 4509 Descript ...

  3. 关于source insight 置顶窗口或者处于前台挡住窗口解决办法

    两个办法,分别如下: 1.重启source insight: 2.按两次F11:

  4. golang --strings 下常用函数api

    1. func Compare(a, b string) int {} 比较返回一个按字典顺序比较两个字符串的整数.如果a == b则结果为0,如果a <b则结果为-1,如果a> b则结果 ...

  5. RabbitMQ系列（二）环境搭建

    参考: https://www.cnblogs.com/ericli-ericli/p/5902270.html https://blog.csdn.net/weixin_30619101/artic ...

  6. python 排序冒泡排序与双向冒泡排序

    冒泡排序: 冒泡排序就是每次找出最大(最小)元素,放在集合最前或最后,这是最简单的排序算法 def bubble_sort(collection): #升序排列 length=len(collecti ...

  7. 跟随腾讯WeTest一起来2019Unreal Open Day！

      WeTest 导读 Unreal Open Day 是由 Epic Games 中国一年一度倾力打造的面向虚幻引擎开发者的技术分享活动,是引擎行业规格最高.规模最大.阵容最强的年度盛会之一. 自从 ...

  8. MUI下拉菜单样式

    <div class="mui-input-row my_select"> <label style="width: 47px;padding-righ ...

  9. [转]C++ 堆栈溢出的原因以及可行的解决方法

    栈溢出(stackoverflow)的原因及解决办法 大家都知道,Windows程序的内存机制大概是这样的:全局变量(局部的静态变量本质也属于此范围)存储于堆内存,该段内存较大,一般不会溢出: 函数地 ...

  10. Guava工具类学习

    目录 一.介绍 二.Optional类 1.定义 2.java8自带Optional 3.使用 三.Preconditions类 1.定义 2.使用 四.Ordering类 1.定义 2.使用 五.R ...