hibernate查询不到关联对象列表-fetchType的选择
概述
昨天排查问题的时候,发现使用hibernate关联对象时,订单实体类对象死活无法获取关联的订单明细列表
Order order = orderDao.findById(201L);
//明明数据库表里有关联的订单明细,但是此处的就是查询不到
List<OrderItem> orderImemList = order.getOrderItemList();
原因在于,OrderItem对象中关联了产品对象product,在它头上的注解是这样的:
/**
* 产品
*/
@ManyToOne(optional = false, fetch = FetchType.EAGER)
@JoinColumn(name = "product_id", nullable = false)
private Product product;
fetch = FetchType.EAGER 且 nullable=false,执行 order.getOrderItemList()时,hibernate底层的查询语句是inner join产品表的,但是订单明细中恰好有1个产品id是空的,结果就是本来有3条订单明细,却只查出了2条
select
orderiteml0_.order_id as order3_0_2_,
orderiteml0_.id as id1_2_,
orderiteml0_.id as id1_1_,
orderiteml0_.order_id as order3_1_1_,
orderiteml0_.product_id as product4_1_1_,
orderiteml0_.QUANTITY as QUANTITY1_1_,
product1_.id as id2_0_,
product1_.PRODUCT_NAME as PRODUCT2_2_0_
from
T_ORDER_ITEM orderiteml0_
inner join
T_PRODUCT product1_
on orderiteml0_.product_id=product1_.id
where
orderiteml0_.order_id=?
order by
orderiteml0_.id
fetchType的选择
JPA定义实体之间的关系有如下几种:
- @OneToOne
- @ManyToOne
- @OneToMany
- @ManyToMany
在定义它们的时候可以通过fetch属性指定加载方式,有两个值:
- FetchType.LAZY:延迟加载,等到get的时候才会去查询
- FetchType.EAGER:急加载,在查询主对象的时候就一起查询出来了
问题复现
数据库准备
-- region 创建表
-- 订单表
create table T_ORDER(
id INTEGER PRIMARY KEY
);
COMMENT ON TABLE T_ORDER is '订单表';
COMMENT ON COLUMN T_ORDER.id is '订单id';
-- 订单明细表
create table T_ORDER_ITEM(
id INTEGER PRIMARY KEY,
order_id INTEGER,
product_id INTEGER,
quantity INTEGER
);
COMMENT ON TABLE T_ORDER_ITEM is '订单明细表';
COMMENT ON COLUMN T_ORDER_ITEM.order_id is '订单id';
COMMENT ON COLUMN T_ORDER_ITEM.product_id is '产品id';
COMMENT ON COLUMN T_ORDER_ITEM.quantity is '数量';
-- 产品表
create table T_PRODUCT(
id INTEGER PRIMARY KEY,
product_name varchar2(50)
);
COMMENT ON TABLE T_PRODUCT is '产品表';
COMMENT ON COLUMN T_PRODUCT.product_name is '产品名称';
-- endregion
-- region 插入测试数据
insert into T_PRODUCT(id, product_name) values (101, '产品A');
insert into T_PRODUCT(id, product_name) values (102, '产品B');
insert into T_ORDER (id) values (201);
insert into T_ORDER_ITEM(id, order_id, product_id, quantity) values (301, 201, 101, 10);
insert into T_ORDER_ITEM(id, order_id, product_id, quantity) values (302, 201, 102, 2);
-- 注意:为了复现问题,一条记录的 productId 设置为空,一个设置为不存在的productId
insert into T_ORDER_ITEM(id, order_id, product_id, quantity) values (303, 201, '', 2);
insert into T_ORDER_ITEM(id, order_id, product_id, quantity) values (304, 201, 999, 12);
--endregion
数据表对应的实体类
订单类
@Entity
@DynamicInsert
@DynamicUpdate
@Table(name = "T_ORDER")
public class Order implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE)
private Long id;
/**
* 订单明细
*/
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "order")
@OrderBy(value = "id")
private List<OrderItem> orderItemList = new ArrayList<>();
//...setter 和 getter
}
订单明细类
@Entity
@DynamicInsert
@DynamicUpdate
@Table(name = "T_ORDER_ITEM")
public class OrderItem implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE)
private Long id;
/**
* 订单
*/
@ManyToOne(optional = false, fetch = FetchType.LAZY)
@JoinColumn(name = "order_id", nullable = false)
private Order order;
/**
* 产品
*/
@ManyToOne(optional = false, fetch = FetchType.EAGER)
@JoinColumn(name = "product_id", nullable = false)
private Product product;
/**
* 数量
*/
@Column(name = "QUANTITY")
private int quantity;
//...setter和getter
}
产品类
@Entity
@DynamicInsert
@DynamicUpdate
@Table(name = "T_PRODUCT")
public class Product implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE)
private Long id;
/**
* 产品名称
*/
@Column(name = "PRODUCT_NAME")
private String productName;
//...setter和getter
}
测试
public class App {
private static SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
public static void main(String[] args) {
Long id = 201L;
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
Order order = (Order) session.get(Order.class, id);
//数据表里关联了3条订单明细,但查询结果总是只有2条
System.out.println(order.getOrderItemList().size());
session.getTransaction().commit();
}
}
HibernateUtil 工具类
public class HibernateUtil {
private static final SessionFactory sessionFactory = buildSessionFactory();
private static SessionFactory buildSessionFactory() {
try {
// Create the SessionFactory from hibernate.cfg.xml
return new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
public static void shutdown() {
// Close caches and connection pools
getSessionFactory().close();
}
}
解决
问题点在于订单明细OrderItem属性product的加载方式
/**
* 产品
*/
@ManyToOne(optional = false, fetch = FetchType.EAGER)
@JoinColumn(name = "product_id", nullable = false)
private Product product;
这导致 order.getOrderItemList() 时总是 inner join 产品表,查询SQL如下:
select
orderiteml0_.order_id as order3_0_2_,
orderiteml0_.id as id1_2_,
orderiteml0_.id as id1_1_,
orderiteml0_.order_id as order3_1_1_,
orderiteml0_.product_id as product4_1_1_,
orderiteml0_.QUANTITY as QUANTITY1_1_,
product1_.id as id2_0_,
product1_.PRODUCT_NAME as PRODUCT2_2_0_
from
T_ORDER_ITEM orderiteml0_
inner join
T_PRODUCT product1_
on orderiteml0_.product_id=product1_.id
where
orderiteml0_.order_id=?
order by
orderiteml0_.id
**只需将 FetchType.EAGER 改为 FetchType.LAZY 即可,hibernate的底层查询SQL就会是:*
select
orderiteml0_.order_id as order3_0_1_,
orderiteml0_.id as id1_1_,
orderiteml0_.id as id1_0_,
orderiteml0_.order_id as order3_1_0_,
orderiteml0_.product_id as product4_1_0_,
orderiteml0_.QUANTITY as QUANTITY1_0_
from
T_ORDER_ITEM orderiteml0_
where
orderiteml0_.order_id=?
order by
orderiteml0_.id
扩展
当急加载时,如果 @JoinColumn 的属性nullable 为true时表示可以为空,关联查询时 left outer join ;false则不能为空,关联查询时 inner join
/**
* 产品
*/
@ManyToOne(optional = false, fetch = FetchType.EAGER)
@JoinColumn(name = "product_id", nullable = false)
private Product product;
总结
昨天下午5点多遇到这个问题,知道晚上快8点才找到原因。期间尝试了很多,最后将hibernate的底册执行的SQL打印出来,才发现了问题所在。
hibernate输出SQL的配置如下:
<!-- 输出sql-->
<property name="show_sql">true</property>
<!-- 格式化sql -->
<property name="format_sql">true</property>
演示代码 https://gitee.com/anyway2025/issueDemo/tree/master/hibernate-demo-211202
hibernate查询不到关联对象列表-fetchType的选择的更多相关文章
- Hibernate查询,返回new对象(注意这个新定义的类要有构造函数),使用sql带条件分页查询并且把结果显示到一个对象的集里面的解决方案
IIndexDao package com.ucap.netcheck.dao; import com.ucap.netcheck.combination.beans.IndexCombinat ...
- Hibernate查询对象的方法浅析
Hibernate 查询对象是根据对象的id查询的,只要你有id (id唯一),则无论你是否其他字段与传过来的对象一致,都会查到该id在数据库对应的对象.若是在关联查询中,所关联表的id为空,即所查表 ...
- Hibernate查询方式(补)
-----------------siwuxie095 Hibernate 查询方式 1.对象导航查询 根据已经加载的对 ...
- 【SSH进阶之路】Hibernate映射——一对一双向关联映射(六)
上篇博文[SSH进阶之路]Hibernate映射--一对一单向关联映射(五),我们介绍了一对一的单向关联映射,单向是指仅仅能从人(Person)这端载入身份证端(IdCard),可是反过来.不能从身份 ...
- 【Hibernate步步为营】--双向关联一对一映射具体解释(一)
一对一的映射在对象模型中是常常见到的,为了将对象模型转换为关系模型就必须在映射文件里进行配置,上篇文章讨论了一对一映射的单向关联的情况,重点是<one-to-one>标签的使用,须要在映射 ...
- 【SSH进阶之路】Hibernate映射——一对一单向关联映射(五)
[SSH进阶之路]Hibernate基本原理(一) ,小编介绍了Hibernate的基本原理以及它的核心,採用对象化的思维操作关系型数据库. [SSH进阶之路]Hibernate搭建开发环境+简单实例 ...
- 【Hibernate步步为营】--单向关联一对一映射
上篇文章对多对一的关联映射做了具体的分析,它在实现上能够有两种方式,而且这两种方式实现也非常easy,关键是标签<many-to-one>的使用,它分别指明了多端和一端的映射关系.这样的映 ...
- hibernate关联对象的增删改查------查
本篇博客是之前博客hibernate关联对象的增删改查------查 的后继,本篇代码的设定都在前文已经写好,因此读这篇之前,请先移步上一篇博客 //代码片5 SessionFactory sessi ...
- Django框架基础知识08-表关联对象及多表查询
1.自定义主键字段的创建 AutoFiled(pirmary_key=True) # 一般不会自定义,int类型,自增长 一般不自定义主键. 2.order_by asc desc from djan ...
随机推荐
- Java常用类笔记(学习尚硅谷java基础教程)
一.Java根类Object类1.toString()方法 1)以文本对象返回,故toString()的定义为public String toString() {} 2)默认的字符串输出是:包.类名@ ...
- Python -用虚拟环境保存库文件
如果你同时负责多个 Python 项目,或者想要轻松打包某个项目及其关联的库文件,再或者你担心已安装的库之间可能有冲突,那么你可以安装一个 Python 虚拟环境来分而治之.当一个 Python 库不 ...
- @Transactional注解的失效场景
一口气说出 6种,@Transactional注解的失效场景 计算机java编程 发布时间: 20-03-1912:35优质科技领域创作者 引言 昨天公众号粉丝咨询了一个问题,说自己之前面试被问@Tr ...
- REST 和RPC对比?
1.RPC主要的缺陷是服务提供方和调用方式之间的依赖太强,需要对每一个微服务进行接口的定义,并通过持续继承发布,严格版本控制才不会出现冲突. 2.REST是轻量级的接口,服务的提供和调用不存在代码之间 ...
- python 装饰器函数基础知识
1.装饰器的本质--一个闭包函数 2.装饰器的功能--在不改变原函数及其调用方式情况下对原函数功能进行拓展 3.带参数和返回值的装饰器 def timer(func): @wraps(func) #使 ...
- java-Map集合hei
/* Map集合的特点: Map集合市一个双列集合,一个元素包含两个值:一个key,一个value Map集合中的元素,key和value的数据类型可以相同,也可以不同 Map集合中的元素,key不允 ...
- JAVA DAEMON线程的理解
java线程分两种:用户线程和daemon线程.daemon线程或进程就是守护线程或者进程,但是java中所说的daemon线程和linux中的daemon是有一点区别的. linux中的daemon ...
- 分享一波dubbo mybatis plus百度云链接
https://pan.baidu.com/s/1VtfoVJwan-XPvmQfBIKMhA
- Unsafe Rust 能做什么
在不安全的 Rust 中唯一不同的是,你可以: 对原始指针进行解引用 调用"不安全"的函数(包括 C 函数.编译器的内建指令和原始分配器. 实现"不安全"的特性 ...
- apollo规划控制视频-13 motion planning with autonomous driving