18. Hibernate_检索策略(lazy、fetch、batch-size等)
来源：互联网 发布：无锡服务器数据恢复 编辑：程序博客网 时间：2024/05/17 04:03
类级别的检索策略
无论 元素的 lazy 属性是 true 还是 false, Session 的 get() 方法及 Query 的 list() 方法在类级别总是使用立即检索策略
若 元素的 lazy 属性为 true 或取默认值, Session 的 load() 方法不会执行查询数据表的 SELECT 语句, 仅返回代理类对象的实例, 该代理类实例有如下特征:
由 Hibernate 在运行时采用 CGLIB 工具动态生成
Hibernate 创建代理类实例时, 仅初始化其 OID 属性
在应用程序第一次访问代理类实例的非 OID 属性时, Hibernate 会初始化代理类实例
1.类级别的检索策略,一般就是用懒加载,(懒加载在用load函数加载的时候,只会用oid来填充代理类,只有使用其他的属性的时候,才会发送sql查询语句,用查询结果来填充代理类对象)
class com.hgh.hibernate.stragery.Customer_$$_javassist_11Hibernate: select customer0_.CUSTOMER_ID as CUSTOMER1_0_0_, customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ from CUSTOMER customer0_ where customer0_.CUSTOMER_ID=?,设置lazy=false只会,就会立即调用sql查询,不在代理
Hibernate: select customer0_.CUSTOMER_ID as CUSTOMER1_0_0_, customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ from CUSTOMER customer0_ where customer0_.CUSTOMER_ID=?class com.hgh.hibernate.stragery.Customer111<!-- 设置:lazy="false"之后,用load函数加载,则会立即加载,而不再是代理 --> <class name="com.hgh.hibernate.stragery.Customer" table="CUSTOMER" lazy="false">一对多和多对多的检索策略
一般set中的lazy属性也默认设置为false,true和extra作为了解即可
在延迟检索(lazy 属性值为 true) 集合属性时, Hibernate 在以下情况下初始化集合代理类实例
应用程序第一次访问集合属性: iterator(), size(), isEmpty(), contains() 等方法
通过 Hibernate.initialize() 静态方法显式初始化
因为平常我们的lazy都是false的,所以要立即对其初始化的话,多是用
Hibernate.initialize(customer.getOrder1s()); //---------------set 的 lazy 属性------------------ //1. 1-n 或 n-n 的集合属性默认使用懒加载检索策略. //2. 可以通过设置 set 的 lazy 属性来修改默认的检索策略. 默认为 true //并不建议设置为 false. //3. lazy 还可以设置为 extra. 增强的延迟检索. 该取值会尽可能的延迟集合初始化的时机!@Test public void testManyToOneLevelStrategy(){ Customer customer = (Customer) session.get(Customer.class, 1); System.out.println(customer.getCustomerName()); System.out.println(customer.getOrder1s().size()); Order1 order = new Order1(); order.setOrderId(1); System.out.println(customer.getOrder1s().contains(order)); //Hibernate.initialize(customer.getOrder1s()); } <!-- 映射 1 对多的那个集合属性 --> <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 --> <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 --> <!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理:delete,save-update. --> <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名 --> <set name="order1s" table="ORDERS" inverse="true" cascade="delete" order-by="ORDER_NAME DESC"> <!-- 执行多的表中的外键列的名字 --> <key column="CUSTOMER_ID"></key> <!-- 指定映射类型 --> <one-to-many class="com.hgh.hibernate.stragery.Order1"/> </set> 元素的 batch-size 属性
元素有一个 batch-size 属性, 用来为延迟检索策略或立即检索策略设定批量检索的数量. 批量检索能减少 SELECT 语句的数目, 提高延迟检索或立即检索的运行性能.
<!-- batch-size="5" 指定集合一次初始化多少个 不然会有多个sql,一个个的查 select order1s0_.CUSTOMER_ID as CUSTOMER3_0_1_, order1s0_.ORDER_ID as ORDER_ID1_1_1_, order1s0_.ORDER_ID as ORDER_ID1_1_0_, order1s0_.ORDER_NAME as ORDER_NA2_1_0_, order1s0_.CUSTOMER_ID as CUSTOMER3_1_0_ from ORDERS order1s0_ where order1s0_.CUSTOMER_ID in ( ?, ?, ?, ? ) order by order1s0_.ORDER_NAME desc --> <set name="order1s" table="ORDERS" inverse="true" cascade="delete" order-by="ORDER_NAME DESC" lazy="false" batch-size="2"> <!-- 执行多的表中的外键列的名字 --> <key column="CUSTOMER_ID"></key> <!-- 指定映射类型 --> <one-to-many class="com.hgh.hibernate.stragery.Order1"/> </set>@Test public void testSetBacthSize(){ ////set 元素的 batch-size 属性: 设定一次初始化 set 集合的数量. List<Customer> customers = session.createQuery("FROM Customer").list(); System.out.println(customers.size()); }fetch: 取值为 “select” 或 “subselect” 时, 决定初始化 orders 的查询语句的形式; 若取值为”join”, 则决定 orders 集合被初始化的时机
若把 fetch 设置为 “join”, lazy 属性将被忽略
元素的 fetch 属性: 取值为 “select” 或 “subselect” 时, 决定初始化 orders 的查询语句的形式; 若取值为”join”, 则决定 orders 集合被初始化的时机.默认值为 select
当 fetch 属性为 “subselect” 时
假定 Session 缓存中有 n 个 orders 集合代理类实例没有被初始化, Hibernate 能够通过带子查询的 select 语句, 来批量初始化 n 个 orders 集合代理类实例
batch-size 属性将被忽略
子查询中的 select 语句为查询 CUSTOMERS 表 OID 的 SELECT 语句
<!-- fetch:指定填充set的方式. fetch="select" fetch="subselect" select order1s0_.CUSTOMER_ID as CUSTOMER3_0_1_, order1s0_.ORDER_ID as ORDER_ID1_1_1_, order1s0_.ORDER_ID as ORDER_ID1_1_0_, order1s0_.ORDER_NAME as ORDER_NA2_1_0_, order1s0_.CUSTOMER_ID as CUSTOMER3_1_0_ from ORDERS order1s0_ where order1s0_.CUSTOMER_ID in ( select customer0_.CUSTOMER_ID from CUSTOMER customer0_ ) order by order1s0_.ORDER_NAME desc fetch="join": select order1s0_.CUSTOMER_ID as CUSTOMER3_0_1_, order1s0_.ORDER_ID as ORDER_ID1_1_1_, order1s0_.ORDER_ID as ORDER_ID1_1_0_, order1s0_.ORDER_NAME as ORDER_NA2_1_0_, order1s0_.CUSTOMER_ID as CUSTOMER3_1_0_ from ORDERS order1s0_ where order1s0_.CUSTOMER_ID in ( ?, ? ) order by order1s0_.ORDER_NAME desc --> <set name="order1s" table="ORDERS" inverse="true" cascade="delete" order-by="ORDER_NAME DESC" lazy="false" batch-size="2" fetch="join"> <!-- 执行多的表中的外键列的名字 --> <key column="CUSTOMER_ID"></key> <!-- 指定映射类型 --> <one-to-many class="com.hgh.hibernate.stragery.Order1"/> </set>@Test public void testFetch(){ List<Customer> customers = session.createQuery("FROM Customer").list(); System.out.println(customers.size()); for (Customer customer : customers) { if (null != customer.getOrder1s()) { System.out.println(customer.getOrder1s().size()); } } //set 集合的 fetch 属性: 确定初始化 orders 集合的方式. //1. 默认值为 select. 通过正常的方式来初始化 set 元素 //2. 可以取值为 subselect. 通过子查询的方式来初始化所有的 set 集合. 子查询 //作为 where 子句的 in 的条件出现, 子查询查询所有 1 的一端的 ID. 此时 lazy 有效. //但 batch-size 失效. //3. 若取值为 join. 则 //3.1 在加载 1 的一端的对象时, 使用迫切左外连接(使用左外链接进行查询, 且把集合属性进行初始化)的方式检索 n 的一端的集合属性 //3.2 忽略 lazy 属性. //3.3 HQL 查询忽略 fetch=join 的取值 } @Test public void testFetch2(){ /** * select customer0_.CUSTOMER_ID as CUSTOMER1_0_1_, customer0_.CUSTOMER_NAME as CUSTOMER2_0_1_, order1s1_.CUSTOMER_ID as CUSTOMER3_0_3_, order1s1_.ORDER_ID as ORDER_ID1_1_3_, order1s1_.ORDER_ID as ORDER_ID1_1_0_, order1s1_.ORDER_NAME as ORDER_NA2_1_0_, order1s1_.CUSTOMER_ID as CUSTOMER3_1_0_ from CUSTOMER customer0_ left outer join ORDERS order1s1_ on customer0_.CUSTOMER_ID=order1s1_.CUSTOMER_ID where customer0_.CUSTOMER_ID=? order by order1s1_.ORDER_NAME desc */ Customer customer = (Customer) session.get(Customer.class, 1); System.out.println(customer.getOrder1s().size()); }多对一和一对一关联的检索策略
和 一样, 元素也有一个 lazy 属性和 fetch 属性.
若 fetch 属性设为 join, 那么 lazy 属性被忽略
迫切左外连接检索策略的优点在于比立即检索策略使用的 SELECT 语句更少.
无代理延迟检索需要增强持久化类的字节码才能实现
@Test public void testManyToOneStrategy() {// Order1 order1 = (Order1) session.get(Order1.class, 1);// System.out.println(order1.getOrderName()); // 1. lazy 取值为 proxy 和 false 分别代表对应对应的属性采用延迟检索和立即检索 // 2. fetch 取值为 join, 表示使用迫切左外连接的方式初始化 n 关联的 1 的一端的属性 // 忽略 lazy 属性. // 3. batch-size, 该属性需要设置在 1 那一端的 class 元素中: // <class name="Customer" table="CUSTOMERS" lazy="true" batch-size="5"> // 作用: 一次初始化 1 的这一段代理对象的个数. List<Order1> order1s = session.createQuery("FROM Order1 o").list(); for (Order1 order1 : order1s) { if (order1.getCustomer() != null) { System.out.println(order1.getCustomer().getCustomerName()); } } }
0 0
- 18. Hibernate_检索策略(lazy、fetch、batch-size等)
- Hibernate 检索策略 lazy fetch batch-size
- Hibernate学习之检索策略（lazy，fetch，batch-size等）
- Hibernate 检索策略 （lazy,batch-size,fetch属性）
- hibernate抓取策略fetch / batch-size
- 【Hibernate】Hibernate的检索策略：lazy、fetch
- Hibernate】Hibernate的检索策略：lazy、fetch
- hibernate batch size & fetch
- Hibernate_检索策略
- Hibernate_检索策略
- Tuning Lazy Fetching (batch size)
- hibernate_抓取策略-检索配置
- hibernate_关于fetch的lazy与eager的说明
- hibernate的抓取策略(fetch和lazy)
- lazy fetch
- Hibernate的检索策略等
- hibernate_检索方式
- hibernate_检索(查询)简介
- 3.依赖倒置原则
- 【MATLAB】fileparts函数
- Webrtc 回声消除 三（NS、VAD、AEC、AGC设备端终结篇）
- java多线程问题
- Abaqus简单部件受力分析
- 18. Hibernate_检索策略(lazy、fetch、batch-size等)
- 界面适配华为手机的虚拟按键的解决方案
- android 不同型号的终端的UI适配--一种解决方法
- SGU 438 动态网络流，SGU挂了，我也不知道A没A
- 网站性能体验34守则
- 参考了 网上 部分 代码 单链表
- iOS跳转微信朋友圈和扫一扫页面(已废弃)
- 一个简单的Makefile教程
- qrcode.js生成二维码
