hibernate关联关系(一对多)
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了hibernate关联关系(一对多),小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含13148字,纯文字阅读大概需要19分钟。
内容图文
什么是关联(association)
关联指的是类之间的引用关系。如果类A与类B关联,那么被引用的类B将被定义为类A的属性。例如:
class B{ private String name; } public class A{ private B b = new B; public A(){} }
一对多关系
1.概念
? 一对多关系是关系型数据库中两个表之间的一种关系。通常在数据库层级中,两表之间是有主外键关系的。在ORM中,如何通过对象描述表之间的关系,是ORM核心。
2.Hibernate的一对多关联映射【重点】
2.1表关系的分析
首先我们建立两个表的实体类
Order:
package com.liuwenwu.three.entity; import java.util.ArrayList; import java.util.List; public class Order { private Integer orderId; private String orderNo; // 建立关联关系 一个订单对应多个订单项 private List<OrderItem> orderItems=new ArrayList<>(); private Integer initChildren =0;//0是懒加载 1是falsepublic Integer getInitChildren() { return initChildren; } publicvoid setInitChildren(Integer initChildren) { this.initChildren = initChildren; } public List<OrderItem> getOrderItems() { return orderItems; } publicvoid setOrderItems(List<OrderItem> orderItems) { this.orderItems = orderItems; } public Integer getOrderId() { return orderId; } publicvoid setOrderId(Integer orderId) { this.orderId = orderId; } public String getOrderNo() { return orderNo; } publicvoid setOrderNo(String orderNo) { this.orderNo = orderNo; } @Override public String toString() { return"Order [orderId=" + orderId + ", orderNo=" + orderNo + "]"; } }
OrderItem:
package com.liuwenwu.three.entity; public class OrderItem { private Integer orderItemId; private Integer productId; private Integer quantity; private Integer oid; // 建立关联关系 一个订单项对应一个订单 private Order order; public Order getOrder() { return order; } public void setOrder(Order order) { this.order = order; } public Integer getOrderItemId() { return orderItemId; } publicvoid setOrderItemId(Integer orderItemId) { this.orderItemId = orderItemId; } public Integer getProductId() { return productId; } publicvoid setProductId(Integer productId) { this.productId = productId; } public Integer getQuantity() { return quantity; } publicvoid setQuantity(Integer quantity) { this.quantity = quantity; } public Integer getOid() { return oid; } publicvoid setOid(Integer oid) { this.oid = oid; } @Override public String toString() { return"OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity + ", oid=" + oid + "]"; } }
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.liuwenwu.three.entity.Order" table="t_hibernate_order"> <id name="orderId" type="java.lang.Integer" column="order_id"> <generator class="increment" /> </id> <property name="orderNo" 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.liuwenwu.three.entity.OrderItem"/> </bag> </class> </hibernate-mapping>
OrderItem.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.liuwenwu.three.entity.OrderItem" table="t_hibernate_order_item"> <id name="orderItemId" type="java.lang.Integer" column="order_item_id"> <generator class="increment" /> </id> <property name="productId" type="java.lang.Integer" column="product_id"> </property> <property name="quantity" type="java.lang.Integer" column="quantity"> </property> <!-- 重复映射报错 Repeated column in mapping for entity 放弃对重复列段的维护 --> <property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false"> </property> <many-to-one name="order"class="com.liuwenwu.three.entity.Order" column="oid"></many-to-one> </class> </hibernate-mapping>
配置文件中各个标签中属性的含义:
1 lazy:默认值为true,true延迟加载,false立即加载(一般设置为true,不使用立即加载,因为影响查询性能)
2 outter-join:默认值为false,true使用左外联接查询关联的(但一般不用,因为当我们把该属性设置为true时,所有的查询语句都会默认左外联,那样性能不高)
3 inverse:默认值为false,true表示将对方设置为主控方(一对多双向关联中一般将多方设置为主控方,这样可以减少SQL语句的数量,减少多余的操作)
4 cascade:用来控制如何操作关联的持久化对象的
4.1 none:保存,更新或删除当前对象时,忽略其它关联的对象
4.2 save-update:保存、更新时级联保存所有的临时对象,并且级联更新关联的游离对象
4.3 delete:通过session的delete方法删除当前对象,级联删除关联的对象
4.4 all:等于save-update操作+delete操作
hibernate.cfg.xml主配置文件:
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- 1. 数据库相关 --> <property name="connection.username">root</property> <property name="connection.password">123</property> <property name="connection.url">jdbc:mysql://localhost:3306/t224?useUnicode=true&characterEncoding=UTF-8 </property> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <!-- <property name="dialect">org.hibernate.dialect.MySQLDialect</property> --> <property name="dialect">org.hibernate.dialect.OracleDialect</property> <!-- 配置本地事务(No CurrentSessionContext configured!) --> <property name="hibernate.current_session_context_class">thread</property> <!-- 2. 调试相关 --> <property name="show_sql">true</property> <property name="format_sql">true</property> <!-- 3. 添加实体映射文件 --> <mapping resource="com/liuwenwu/one/entity/User.hbm.xml" /> <!--主键生成策略 --> <mapping resource="com/liuwenwu/two/entity/Student.hbm.xml" /> <mapping resource="com/liuwenwu/two/entity/Worker.hbm.xml" /> <!-- 一对多 --> <mapping resource="com/liuwenwu/three/entity/Order.hbm.xml"/> <mapping resource="com/liuwenwu/three/entity/OrderItem.hbm.xml"/> </session-factory> </hibernate-configuration>
dao方法DemoDao:
package com.liuwenwu.three.dao; import java.util.List; import org.hibernate.Hibernate; import org.hibernate.Session; import org.hibernate.Transaction; import com.liuwenwu.three.entity.Order; import com.liuwenwu.three.entity.OrderItem; import com.liuwenwu.two.util.SessionFactoryUtils; 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.getOrderId()); // 强制加载关联对象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; } /** * z主表的数据不能随便删除,得先删除从表中对应信息,才能删除主表的信息。 * @param order */publicvoid delOrder(Order order) { Session session = SessionFactoryUtils.openSession(); Transaction transaction = session.beginTransaction(); Order order2 = session.get(Order.class, order.getOrderId()); for (OrderItem oi : order2.getOrderItems()) { session.delete(oi); } session.delete(order2); // session.delete(order); transaction.commit(); session.close(); } }
因为要测试的方法比较多 我们建立一个JUnit测试类 DemoDaoTest:
package com.liuwenwu.three.dao; import java.util.List; import org.junit.After; import org.junit.Before; import org.junit.Test; import com.liuwenwu.three.entity.Order; import com.liuwenwu.three.entity.OrderItem; /* * * @Before 每测试一个@Test标记的测试方法,都会在调用之前执行一次 * @After 每测试一个@Test标记的测试方法,都会在调用之后执行一次 * @author ASUS * */ public class DemoDaoTest { private DemoDao demoDao =new DemoDao(); // @Before // public void setUp() throws Exception { // System.out.println("加载资源的"); // } //// @After // public void tearDown() throws Exception { // System.out.println("释放资源的"); // } @Test /** * 测试新增订单与订单项 (级联新增) */publicvoid testAddOrder() { Order order=new Order(); order.setOrderNo("pp3"); OrderItem orderItem=null; for (int i = 0; i < 6; i++) { orderItem =new OrderItem(); orderItem.setProductId(11+i); orderItem.setQuantity(20+i); //维护关联关系 orderItem.setOrder(order); order.getOrderItems().add(orderItem); } demoDao.addOrder(order); } @Test /** * 测试只添加订单项 */publicvoid testAddOrderItem() { OrderItem orderItem=null; for (int i = 0; i < 6; i++) { orderItem =new OrderItem(); orderItem.setProductId(11+i); orderItem.setQuantity(20+i); //维护关联关系 Order order =new Order(); order.setOrderId(3); order.getOrderItems().add(orderItem); orderItem.setOrder(order); demoDao.addOrderItem(orderItem); } } /** * 测试查询订单以及对应的订单项 (联级查询) */ @Test publicvoid testGetOrder() { Order order=new Order(); order.setOrderId(2); order.setInitChildren(1);//想联级查询时设置为1 Order o=this.demoDao.getOrder(order); // failed to lazily initialize a collection of role: // com.liuwenwu.three.entity.Order.orderItems, // could not initialize proxy - no Session // 原因:操作了两次数据库,当lazy=false的时候,会让hibernate执行完两次操作,session才会关闭 // 当lazy=true的时候,hibernate执行完一次操作,session就会关闭 // 从上面看lazy=false更好,但是为什么hibernate默认让它等于true // 出于性能的考虑,所以hibernate3.0之后出现了lazy这个属性,并让他默认等于true,也就是说不加载关联属性 // 但是如果lazy等于true 不加载关联属性 就会报错 所以 List<OrderItem> orderItems = o.getOrderItems(); for (OrderItem orderItem : orderItems) { System.out.println(orderItem); } System.out.println(o); } /** * 测试查询所有订单 */ @Test publicvoid testGetOrderList() { List<Order> orderList = this.demoDao.getOrderList(); for (Order order : orderList) { for (OrderItem orderItem : order.getOrderItems()) { System.out.println(orderItem); } System.out.println(order); } } /** * 测试删除(级联删除) */ @Test publicvoid testDelOrder() { Order order=new Order(); order.setOrderId(2); this.demoDao.delOrder(order); } }
测试新增订单与订单项 (级联新增):只调用了一个新增的dao方法 可以增加两个表的数据
@Test /* * * 测试新增订单与订单项 (级联新增) */ public void testAddOrder() { Order order=new Order(); order.setOrderNo("pp3"); OrderItem orderItem=null; for (int i = 0; i < 6; i++) { orderItem =new OrderItem(); orderItem.setProductId(11+i); orderItem.setQuantity(20+i); //维护关联关系 orderItem.setOrder(order); order.getOrderItems().add(orderItem); } demoDao.addOrder(order); }
这里报错
是以为重复映射问题报错 解决方法 :给重复的列段加上下面的属性
insert="false" update="false"
测试只添加订单项:
@Test /* * * 测试只添加订单项 */ public void testAddOrderItem() { OrderItem orderItem=null; for (int i = 0; i < 6; i++) { orderItem =new OrderItem(); orderItem.setProductId(11+i); orderItem.setQuantity(20+i); //维护关联关系 Order order =new Order(); order.setOrderId(3); order.getOrderItems().add(orderItem); orderItem.setOrder(order); demoDao.addOrderItem(orderItem); } }
懒加载的问题 lazy默认为true hibernate执行完一次操作,session就会关闭 所以联级查询时就会报错
把lazy设置为false时会让hibernate执行完两次操作,session才会关闭 这样就会降低性能 出于性能考虑在hibernate3.0之后出现了lazy这个属性,并让他默认等于true,也就是说不加载关联属性
我们可以在主表实体类中添加一个控制是否使用懒加载的属性:
private Integer initChildren =0;//0是懒加载 1是false
当需要联级查询时 将initChildren属性设置为1: 这样就可以自己控制是否联级查询
order.setInitChildren(1);//想联级查询时设置为1
最后是测试删除(级联删除):调用一个dao方法 可以同时删除两个表的数据(主表的数据不能随便删除,得先删除从表中对应信息,才能删除主表的信息)
/* * * 测试删除(级联删除) */ @Test public void testDelOrder() { Order order=new Order(); order.setOrderId(2); this.demoDao.delOrder(order); }
hibernate框架一对多的执行原理:
<!-- hibernate框架一过多的执行原理 1.对hibernate.cfg.xml进行建模,等到sessionfactory对象,跟数据库建立联系 2.并且拿到了mapping resource里的内容 3.拿到了Order.hbm.xml配置文件 4.可以再次建模,拿到了com.liuwenwu.three.entity.Order,以及 t_hibernate_order 类属性、以及表列段 5.生成动态的sql, select orderId,orderNo from t_hibernate_order 执行sql最终得到meterData源数据模型 orderId,orderNo 1 pp3 3 hh3 6.Order o1 = Class.forName("com.liuwenwu.three.entity.Order").newInstance(0); o1.setOrderId(1); o1.setOrderOn(pp3); .......... 最终得到: List<Order> list = new ArrayList(); list.add(o1) .......... 最终list中的所有order实列都有值了 (这里只是处理了表里面的非外键列段,原理完全和baseDao一样) 7.处理关联关系:orderItems oid com.liuwenwu.three.entity.OrderItem 通过one-to-many这个标签以及class对应的全路径名对应的专属映射文件 也就是找到了Order.item.xml这个文件,拿到了它之后就可以拿到table t_hibernate_order_item 8.select * from t_hibernate_order_item; 最终得到了一个List<OrderItem> orderItems 9.给order的关联关系属性赋值 List<Order> list = new ArrayList(); for(Order o: list){ o.setOrderItems(orderItems); }
原文:https://www.cnblogs.com/liuwenwu9527/p/11191415.html
内容总结
以上是互联网集市为您收集整理的hibernate关联关系(一对多)全部内容,希望文章能够帮你解决hibernate关联关系(一对多)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。