initOrderItems = 0;//0代表懒加载 1代表立即加载
在订单项的实体类中需要添加一个属性:Order order
定义一对多的关系时需要采用接口方式
1、在Order.hbm.xml中需要添加(建立订单对订单项的一对多的关系)
2、在OrderItem.hbm.xml中需要添加(建立订单项对订单多对一的关系)
三、级联新增、级联查询,普通删除
pom.xml
org.springframework.data
spring-data-jpa
2.1.5.RELEASE
org.hibernate
hibernate-core
5.3.7.Final
org.springframework
spring-test
5.1.5.RELEASE
junit
junit
4.12
mysql
mysql-connector-java
5.1.47
com.mchange
c3p0
0.9.5.2
org.springframework
spring-aspects
5.1.5.RELEASE
com.querydsl
querydsl-jpa
4.1.4
方法:
package com.four.dao;
import java.util.List;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.four.entity.Order;
import com.four.entity.OrderItem;
import com.two.util.SessionFactoryUtil;
public class OrderDao {
//订单项新增
public Integer addOrderItem(OrderItem orderItem) {
Session session = SessionFactoryUtil.getSession();
Transaction transaction = session.beginTransaction();
Integer otid = (Integer) session.save(orderItem);
transaction.commit();
session.close();
return otid;
}
//订单新增
public Integer addOrder(Order order) {
Session session = SessionFactoryUtil.getSession();
Transaction transaction = session.beginTransaction();
Integer otid = (Integer) session.save(order);
transaction.commit();
session.close();
return otid;
}
//查单个
public Order getOrder(Order order) {
Session session = SessionFactoryUtil.getSession();
Transaction transaction = session.beginTransaction();
Order o = session.get(Order.class, order.getOrderId());
if(o != null && new Integer(1).equals(order.getInitOrderItems())) {
Hibernate.initialize(o.getOrderItems());
}
transaction.commit();
session.close();
return o;
}
//查所有
public List getOrderList(){
Session session = SessionFactoryUtil.getSession();
Transaction transaction = session.beginTransaction();
List list = session.createQuery(“from Order”).list();
transaction.commit();
session.close();
return list;
}
//删除(hibernate需要先删从表(订单项)再删主表(订单))
public void delOrder(Order order) {
Session session = SessionFactoryUtil.getSession();
Transaction transaction = session.beginTransaction();
Order o = session.get(Order.class, order.getOrderId());
for (OrderItem ot : o.getOrderItems()) {
session.delete(ot);
}
session.delete(o);
transaction.commit();
session.close();
}
}
JUnit测试
package com.four.dao;
import java.util.Iterator;
import java.util.List;
import org.junit.Test;
import com.four.entity.Order;
import com.four.entity.OrderItem;
public class OrderDaoTest {
private OrderDao orderDao = new OrderDao();
/**
-
Repeated column in mapping for entity:
-
com.zking.four.entity.OrderItem column: oid
-
(should be mapped with insert=“false” update=“false”)
-
同一个字段被映射了两次
*/
@Test
public void testAddOrderItem() {//订单项新增
OrderItem orderItem = new OrderItem();
// orderItem.setOid(7);//普通新增
orderItem.setProductId(89);
orderItem.setQuantity(78);
Order order = new Order();
order.setOrderId(5);
orderItem.setOrder(order);
this.orderDao.addOrderItem(orderItem);
}
//提交一个具有6个订单项的订单
// addOrder 1
// addOrderItem 6
@Test
public void testAddOrder() {//订单新增
Order order = new Order();
order.setOrderNo(“P8”);
OrderItem orderItem;
for (int i = 1; i < 7; i++) {
orderItem = new OrderItem();
orderItem.setProductId(i);
orderItem.setQuantity(i);
order.getOrderItems().add(orderItem);
orderItem.setOrder(order);
}
this.orderDao.addOrder(order);
}
@Test
public void testGetOrder() {//查单个
Order order = new Order();
order.setOrderId(8);
order.setInitOrderItems(1);
Order o = this.orderDao.getOrder(order);
System.out.println(o.getOrderNo());
System.out.println(o.getOrderItems().size());
for (OrderItem ot : o.getOrderItems()) {
System.out.println(ot.getProductId());
}
}
@Test
public void testGetOrderList() {//查所有
List list = this.orderDao.getOrderList();
for (Order o : list) {
System.out.println(o.getOrderNo());
System.out.println(o.getOrderItems().size());
for (OrderItem ot : o.getOrderItems()) {
System.out.println(ot.getProductId());
}
}
}
@Test
public void testDelOrder() {//删除
Order order = new Order();
order.setOrderId(8);
this.orderDao.delOrder(order);
}
}
=========================================================================
=================================================================================
========================================================================
================================================================
首先我们先理解一对多的什么意思,在数据库A表上的一条数据,可以映射B表的多条数据库,也就是站在A表的角度,就被B表的都跳数据引用,
hiberante就认为A表拥有一个B表的集合,所以配置如下
package com.xingxue.entity;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
//关联我们的表
@Entity //该类被hibernate当做实体给管理
@Table(name=“xx_plat_role”) //对应数据库的表
public class Role {
@Id //配置主键
@GeneratedValue(strategy=GenerationType.IDENTITY) //自增策略
@Column(name=“role_id”) //关联字段名和数据类型
private int id;
@Column(name=“role_name”) //关联字段名和数据类型
private String name;
@Column(name=“role_status”) //关联字段名和数据类型
private String status;
@Column(name=“createdate”, columnDefinition=“DATETIME”) //关联字段名和数据类型
private Date createdate;
@OneToMany //一对多配置,
@JoinColumn(name=“admin_role”) // 外键的名字
private Set admins = new HashSet();
}
此处一对多配置,只配置1端,多端不用管理,所以Admin不需要任何配置
测试代码:
public boolean add(Admin param, int roleId) {
Session session = this.sessionFactory.openSession();
//开启事务
Transaction t = session.beginTransaction();
//get我们的role对象,让hibernate管理起来
Role role = (Role) session.get(Role.class, roleId);
//关联role和admin的关系
role.getAdmins().add(param);
int result = (Integer) session.save(param);
//提交事务
t.commit();
//关闭回话
session.close();
return result > 0;
}
结果如下
根据测试结果我们发现,如果我们想要关联两张表的关系,:
1、hibernate配置了关联关系
2、当操作数据的时候,两个关联对象被hibernate管理起来,
3、两个对象之间必须建立关联关系
查询数据测试
@Override
public List list() {
Session session = this.sessionFactory.openSession();
String SQL = “select * from xx_plat_role”;
List list = session.createSQLQuery(SQL).addEntity(Role.class).list();
return list;
}
我们发现在查询role的时候,实际上hibernate自动帮我们查询了当前role下面的所有admin信息,并且封装到了set里面,也就是数据已经包装好了。省去了我们以前的链接查询的操作。
但是通过测试我们发现,在查admin的时候没有把admin相关的role给查询出来,那是因为admin没有配置映射关系,多对一,所以admin无效果,
懒加载设置
其实有的时候我们不需要查询admin信息,所以关联数据hiberante默认使用懒加载机制,所谓的懒加载就是我们需要使用这个数据他 才去查询,你不使用,H就不查询,但是必须建立在session不关闭的情况下,
@OneToMany(fetch=FetchType.EAGER) //没有懒加载,
@OneToMany(fetch=FetchType.LAZY) //使用懒加载,
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
他 才去查询,你不使用,H就不查询,但是必须建立在session不关闭的情况下,
@OneToMany(fetch=FetchType.EAGER) //没有懒加载,
@OneToMany(fetch=FetchType.LAZY) //使用懒加载,
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-Verzx0Dv-1715690890570)]
[外链图片转存中…(img-0XyoFWoa-1715690890570)]
[外链图片转存中…(img-3vcvVTWS-1715690890571)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!