今日分享hibernate框架的简单关联关系

一:关联关系简介

1.1 什么是关联关系

  关联指的是类之间的引用关系。如果类A与类B关联,那么被引用的类B将被定义为类A的属性。

例如:

  class B{
  private String name;
  }

  public class A{
  private B b = new B;
  public A(){}
  }
  hibernate:orm框架、以面向对象的思想操作数据库
  实体类--》表
  属性--》字段

1.2 关联关系分类

关联可以分为一对一、一对多/多对一、多对多关联
关联是有方向的;首先我们来创建两个表讲解一下

订单表

订单项表

他们之间有一个订单id列作为关系列,我们建表的原则就是在多的一方添加外键来描述他们之间的对应关系;

外键在这里有二个用途:查找客户的订单,查找订单对应的客户

二:一对多配置及级联新增

 首先我们根据上面建的表来创建对应的实体类

Order类

package com.ht.three.entity;

import java.util.ArrayList;
import java.util.List; /**
* 订单类
*
* @author Administrator
*
*/
public class Order { private Integer order_id;
private String order_no;
//建立了关联关系 一个订单对应多个订单项
private List<OrderItem> orderItems=new ArrayList<>();
private Integer InitChildren=; //0就是懒加载,1反之
public List<OrderItem> getOrderItems() {
return orderItems;
} public void setOrderItems(List<OrderItem> orderItems) {
this.orderItems = orderItems;
} public Integer getOrder_id() {
return order_id;
} public void setOrder_id(Integer order_id) {
this.order_id = order_id;
} public String getOrder_no() {
return order_no;
} public void setOrder_no(String order_no) {
this.order_no = order_no;
} @Override
public String toString() {
return "Order [order_id=" + order_id + ", order_no=" + order_no + ", orderItems=" + orderItems + "]";
} public Integer getInitChildren() {
return InitChildren;
} public void setInitChildren(Integer initChildren) {
InitChildren = initChildren;
}
}

OrderItme类

package com.ht.three.entity;

/**
* 订单项
*
* @author Administrator
*
*/
public class OrderItem {
private Integer order_item_id;
private Integer product_id;
private Integer oid;
private Integer quantity;
private Order order;//建立关联关系,一个订单项对应的是一个订单
public Integer getOrder_item_id() {
return order_item_id;
} public void setOrder_item_id(Integer order_item_id) {
this.order_item_id = order_item_id;
} public Integer getProduct_id() {
return product_id;
} public void setProduct_id(Integer product_id) {
this.product_id = product_id;
} public Integer getOid() {
return oid;
} public void setOid(Integer oid) {
this.oid = oid;
} public Integer getQuantity() {
return quantity;
} public void setQuantity(Integer quantity) {
this.quantity = quantity;
} public Order getOrder() {
return order;
} public void setOrder(Order order) {
this.order = order;
} @Override
public String toString() {
return "OrderItem [order_item_id=" + order_item_id + ", product_id=" + product_id + ", oid=" + oid
+ ", quantity=" + quantity + ", order=" + order + "]";
} }

然后创建对应的配置文件

Order.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.ht.three.entity.Order" table="t_hibernate_order">
<id name="order_id" type="java.lang.Integer" column="order_id">
<generator class="increment" />
</id>
<property name="order_no" type="java.lang.String" column="order_no">
</property>
<!--
bag标签:
lazy:是否懒加载,默认是懒加载的 true 懒汉模式
name:类的关联属性名
cascade:联极关系 联级新增修改
inverse:关联关系交给对方控制默认true,当前类不维护关联关系 子标签key:
column:主表的主建,从表的外键
子标签one-to-many:
class:外键对应的实体类
-->
<bag lazy="true" name="orderItems" cascade="save-update" inverse="true">
<!-- 从表的外键 -->
<key column="oid"></key>
<one-to-many class="com.ht.three.entity.OrderItem"/>
</bag>
</class> </hibernate-mapping>

OrderItme.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.ht.three.entity.OrderItem" table="t_hibernate_order_item">
<id name="order_item_id" type="java.lang.Integer" column="order_item_id">
<generator class="increment" />
</id>
<property name="product_id" type="java.lang.Integer" column="product_id">
</property>
<property name="quantity" type="java.lang.Integer" column="quantity">
</property>
<!-- -->
<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false">
</property>
<many-to-one name="order" class="com.ht.three.entity.Order" column="oid"></many-to-one>
</class>
</hibernate-mapping>

在hibernate.cfg.xml配置文件中配置映射文件路径

<mapping resource="com/ht/three/entity/Order.hbm.xml" />
<mapping resource="com/ht/three/entity/OrderItem.hbm.xml" />

然后创建Dao层来测试映射关系

package com.ht.three.Dao;
import java.util.List;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.ht.three.entity.Order;
import com.ht.three.entity.OrderItem;
import com.ht.two.util.SessionFactoryUtils; /**
* 测试方法类
* @author Administrator
*
*/
public class DemoDao {
/**
* 为了测试关系型映射文件配置准确
* 讲解insert=false,update=false的用途
* @param order
* @return
*/
public Integer addOrder(Order order) {
Session session = SessionFactoryUtils.openSession();
Transaction transaction = session.beginTransaction();
Integer oid = (Integer)session.save(order);
transaction.commit();
session.close();
return oid;
} public Integer addOrderItem(OrderItem orderItem) {
Session session = SessionFactoryUtils.openSession();
Transaction transaction = session.beginTransaction();
Integer otid = (Integer)session.save(orderItem);
transaction.commit();
session.close();
return otid;
}
/**
* 为了讲解懒加载的问题(hibernate3.0后所有查询方式默认采用的是懒加载方式)
* 1、查单个时存在问题,代理对象已经关闭
* 2、查多个存在问题,有性能的问题
* @param order
* @return
*/
public Order getOrder(Order order) {
Session session = SessionFactoryUtils.openSession();
Transaction transaction = session.beginTransaction();
Order o = session.get(Order.class, order.getOrder_id());
if(o != null && new Integer(1).equals(order.getInitChildren())) {
//强制加载关联对象
Hibernate.initialize(o.getOrderItems());
// System.out.println(o.getOrderItems());
}
transaction.commit();
session.close();
return o;
} public List<Order> getOrderList() {
Session session = SessionFactoryUtils.openSession();
Transaction transaction = session.beginTransaction();
List<Order> list = session.createQuery("from Order").list();
transaction.commit();
session.close();
return list;
} /**
* 主表的数据不能随便删除,得先删除从表中对应信息,才能删除主表的信息。
* @param order
*/
public void delOrder(Order order) {
Session session = SessionFactoryUtils.openSession();
Transaction transaction = session.beginTransaction();
Order order2 = session.get(Order.class, order.getOrder_id());
for (OrderItem oi : order2.getOrderItems()) {
session.delete(oi);
}
// session.delete(order2);
session.delete(order);
transaction.commit();
session.close();
}
}

然后创建一个junit测试类,来一个一个测试方法

package com.ht.three.Dao;

import static org.junit.Assert.*;

import java.util.Iterator;
import java.util.List; import org.junit.After;
import org.junit.Before;
import org.junit.Test; import com.ht.three.entity.Order;
import com.ht.three.entity.OrderItem;
/**
* @Before每测试一个@test测试方法,就会调用之前执行一次
* @After每测试一个@Test标记的测试方法,就会调用之后执行一次
* @author Administrator
*
*/
public class DemoDaoTest {
private DemoDao demedao=new DemoDao();
// @Before
// public void setUp() throws Exception {
// System.out.println("加载资源的");
// }
//
// @After
// public void tearDown() throws Exception {
// System.out.println("释放资源的");
// } @Test
public void testAddOrder() {
Order order=new Order();
order.setOrder_no("h4"); //新增一个订单类型
OrderItem item=null;
//给订单类型新增五条数据进订单项表中
for (int i = 0; i <5; i++) {
item=new OrderItem();
item.setProduct_id(10+i);
item.setQuantity(20+i);
//维护关系
item.setOrder(order);
order.getOrderItems().add(item);
}
demedao.addOrder(order);//调用新增方法
} @Test
public void testAddOrderItem() {
OrderItem item=new OrderItem();
//给对应订单号新增五条数据进订单项表中
for (int i = 0; i <5; i++) {
item=new OrderItem();
item.setProduct_id(10+i);
item.setQuantity(20+i);
//维护关系
Order order=new Order();
//给新增的数据设置一个订单号让他的数据新增进对应订单号的订单项中
order.setOrder_id(2);
order.getOrderItems().add(item);
item.setOrder(order);
demedao.addOrderItem(item);//调用新增方法
}
} @Test
public void testGetOrder() {
Order order=new Order();
order.setOrder_id(3);
Order o=this.demedao.getOrder(order);
//原因:操作了两次数据库,当lazy=false的时候会让hibernate执行两次操作,session才会关闭
// 当lazy=true的时候,会让hibernate执行完一次操作,session就会关闭
// 从上面看lazy=false更好,但是hibernate默认让他等于true
// 出于性能的考虑,所以hibernate3.0出现lazy这个属性,并让它默认等于true,也就是说不加载关联属性
// List<OrderItem> orderItems = o.getOrderItems();
// System.out.println(o);
// for (OrderItem orderItem : orderItems) {
// System.out.println(orderItem);
// }
System.out.println(o);
} @Test
public void testGetOrderList() {
List<Order> oList=this.demedao.getOrderList();
for (Order order : oList) {
for (OrderItem orderItem :order.getOrderItems() ) {
System.out.println(orderItem);
}
System.out.println(order);
}
} /**
* 删除测试
*/
@Test
public void testDelOrder() {
Order order=new Order();
order.setOrder_id(7);
this.demedao.delOrder(order);
} }

方法都在上面咯,现在我们来一个一个测试它

新增:

这是两个新增方法,分别新增不同的两个表里数据效果

@Test
public void testAddOrder() {
Order order=new Order();
order.setOrder_no("h4"); //新增一个订单类型
OrderItem item=null;
//给订单类型新增五条数据进订单项表中
for (int i = 0; i <5; i++) {
item=new OrderItem();
item.setProduct_id(10+i);
item.setQuantity(20+i);
//维护关系
item.setOrder(order);
order.getOrderItems().add(item);
}
demedao.addOrder(order);//调用新增方法
} @Test
public void testAddOrderItem() {
OrderItem item=new OrderItem();
//给对应订单号新增五条数据进订单项表中
for (int i = 0; i <5; i++) {
item=new OrderItem();
item.setProduct_id(10+i);
item.setQuantity(20+i);
//维护关系
Order order=new Order();
//给新增的数据设置一个订单号让他的数据新增进对应订单号的订单项中
order.setOrder_id(2);
order.getOrderItems().add(item);
item.setOrder(order);
demedao.addOrderItem(item);//调用新增方法
}
}

记住!!一定一定不要忘记在xml中增加属性,不然就会报错

<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false">
</property>

注意:运行JUnit时,绿色就代表成功,红色就代表有错误

效果:

上面也写了删除方法,效果就是根据订单id去删除对应的订单项。

三:懒加载以及hibernate中如何形成sql语句

@Test
public void testGetOrder() {
Order order=new Order();
order.setOrder_id(3);
Order o=this.demedao.getOrder(order);
List<OrderItem> orderItems = o.getOrderItems();
System.out.println(o);
for (OrderItem orderItem : orderItems) {
System.out.println(orderItem);
}
System.out.println(o);
} @Test
public void testGetOrderList() {
List<Order> oList=this.demedao.getOrderList();
for (Order order : oList) {
for (OrderItem orderItem :order.getOrderItems() ) {
System.out.println(orderItem);
}
System.out.println(order);
}
}

这里不需要联表查询,只需要根据订单id,去查对应的订单项,但是我们就需要把lazy属性改成false

  原因:操作了两次数据库,当lazy=false的时候会让hibernate执行两次操作,session才会关闭
当lazy=true的时候,会让hibernate执行完一次操作,session就会关闭
从上面看lazy=false更好,但是hibernate默认让他等于true
出于性能的考虑,所以hibernate3.0出现lazy这个属性,并让它默认等于true,也就是说不加载关联属性 所以我们要自己自定义一个lazy列段来控制这个属性
我是在Order类中定义的
private Integer InitChildren=0;  //0就是懒加载,1反之
public Integer getInitChildren() {
return InitChildren;
} public void setInitChildren(Integer initChildren) {
InitChildren = initChildren;
}

在DomeDao中也有对应的方法


/**
* 为了讲解懒加载的问题(hibernate3.0后所有查询方式默认采用的是懒加载方式)
* 1、查单个时存在问题,代理对象已经关闭
* 2、查多个存在问题,有性能的问题
* @param order
* @return
*/
public Order getOrder(Order order) {
Session session = SessionFactoryUtils.openSession();
Transaction transaction = session.beginTransaction();
Order o = session.get(Order.class, order.getOrder_id());
if(o != null && new Integer(1).equals(order.getInitChildren())) {
//强制加载关联对象
Hibernate.initialize(o.getOrderItems());
// System.out.println(o.getOrderItems());
}
transaction.commit();
session.close();
return o;
}

最后我们再来理清一下Hibernate框架运行一对思路

.对hibernate.cfg.xml建模,等到sessionfactory对象
.并且拿到mapping resource里的内容
.拿到了Order.hbm.xml配置文件
.可以再次建模,拿到类,类属性,列段
.生成动态的sql:最终拿到数据源模型
最终list的所有order实例都有值:(这里只是处理表面的非外键列段,原理和baseDao一样)
.处理关联关系:
order item oid 以及类
通过one-to-many 这个标签以及 class对应的全路径名会找到class对应的专属映射文件
也就是找到了Order item.xml这个文件,拿到了之后就可以拿到表
. select * from order item
最终得到了一个list<orderItem> orderItems
.给order的关联关系属性赋值 for (OrderItem orderItem : orderItems) {
System.out.println(orderItem);
}

今日分享到此结束!!!谢谢观看!!!

 

Hibernate之关联关系(一对多)的更多相关文章

  1. hibernate之关联关系一对多

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

  2. Hibernate在关于一对多,多对一双向关联映射

    [Hibernate]之关于一对多,多对一双向关联映射 因为一对多.和多对一的双向关联映射基本上一样,所以这里就一起写下来! Annotations配置 @Entity @Table(name=&qu ...

  3. Hibernate JPA 关联关系

    Hibernate JPA 关联关系: 使用cascade做级联操作(只有在满足数据库约束时才会生效): CascadeType.PERSIST: 级联保存,只有调用persist()方法,才会级联保 ...

  4. 框架之 hibernate之关联关系映射

    案例:完成CRM的联系人的保存操作 需求分析 1. 因为客户和联系人是一对多的关系,在有客户的情况下,完成联系人的添加保存操作 技术分析之Hibernate的关联关系映射之一对多映射(重点) 1. J ...

  5. (转)Hibernate关联映射——一对多(多对一)

    http://blog.csdn.net/yerenyuan_pku/article/details/70152173 Hibernate关联映射——一对多(多对一) 我们以客户(Customer)与 ...

  6. Hibernate的关联关系映射

    技术分析之Hibernate的关联关系映射之一对多映射(重点)        1. JavaWEB中一对多的设计及其建表原则        2. 先导入SQL的建表语句                 ...

  7. hibernate有关联关系删除子表时可能会报错,可以用个clear避免错误

    //清除子表数据 public SalesSet removeSalesSetDistributor(SalesSet salesSet ){ List<SalesSetDistributor& ...

  8. Hibernate之关联关系映射(一对一主键映射和一对一外键映射)

    1:Hibernate的关联关系映射的一对一外键映射: 1.1:第一首先引包,省略 1.2:第二创建实体类: 这里使用用户信息和身份证信息的关系,用户的主键编号既可以做身份证信息的主键又可以做身份证信 ...

  9. Hibernate 一对一关联关系

    双向一对一关联关系: 域模型: 例如,部门只有一个部门经理,一个经理也只能管理一个部门.即,Department 中有一个Manager的引用,Manager 中又有一个Department 的引用. ...

随机推荐

  1. opencv VS C++ 配置

    包含目录 $(OPENCV)\include\ $(OPENCV)\include\opencv\ $(OPENCV)\include\opencv2\   即: D:\opencv\opencv\b ...

  2. CodeForces - 1175D Array Splitting(数组划分+后缀和+贪心)

    You are given an array a1,a2,…,ana1,a2,…,an and an integer kk. You are asked to divide this array in ...

  3. 【Oracle/Maven】Maven导入oracle11g 自携带jdbc驱动包ojdbc6.jar到本地库

    Maven需要下载解压并添加到classpath,如果不明可以参考https://www.cnblogs.com/xiandedanteng/p/11403480.html 然后在命令行窗口执行: m ...

  4. 如何配置 VirtualBox 中的客户机与宿主机之间的网络连接

    如何配置 VirtualBox 中的客户机与宿主机之间的网络连接 作者: Aaron Kili 译者: LCTT rusking | 2017-03-01 13:40   评论: 3 收藏: 3 当你 ...

  5. <HTML/CSS>BFC原理剖析

    本文讲了BFC的概念是什么: BFC的约束规则:咋样才能触发生成新的BFC:BFC在布局中的应用:防止margin重叠(塌陷,以最大的为准): 清除内部浮动:自适应两(多)栏布局. 1. BFC是什么 ...

  6. Qt编写控件属性设计器3-拉伸控件

    一.前言 插件控件加载了,拖曳控件也实现了,接下来就是一个最难点了,跟QtDesigner或者其他开发环境一样,能够任意自由的拉伸控件大小,移动位置,为了这个功能,还特别编写了一个控件来实现这个功能, ...

  7. js往标签下插入标签的方法

    js="document.getElementsByClassName('CodeMirror-line')[0].innerHTML = 'xxxxxx'"dr.execute_ ...

  8. PHP上传文件 Error 6解决方法 (转)

    按:我采用phpstudy2016,编辑php.ini ,“upload_tmp_dir没放开,直接放开,并指向 /tmp 就OK 上传文件,$_FILES["file"][&qu ...

  9. laravel门面DB返回数组配置

    在数据库配置文件中添加 'fetch' => PDO::FETCH_ASSOC, //但是这个配置好像是全局的,不能针对单个数据库连接进行配置 也可以在方法内使用php内置函数get_objec ...

  10. Java多线程——线程池使用示例

    示例代码: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public cla ...