Hibernate中类级别和关联级别加载策略
2017-01-23 19:51
525 查看
抓取策略（优化）
1.检索方式
立即检索：立即查询，在执行查询语句时，立即查询所有的数据。延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）
2.检查策略
类级别检索：当前的类的属性获取是否需要延迟。关联级别的检索：当前类 关联 另一个类是否需要延迟。
3.类级别检索
get：立即检索。get方法一执行，立即查询所有字段的数据。load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询 。 Customer.hbm.xml <class lazy="true |false">
lazy默认值true，表示延迟检索，如果设置false表示立即检索。
1. get/load
get: 立即查询数据库,将数据初始化
load: hbm文件中,class元素的lazy属性决定类级别load方法的加载策略
true:先返回一个代理对象.使用代理对象的属性时,才去查询数据库.
false: 与get一致,会立即加载数据
@Test
public void demo02() {
//类级别
Session session = factory.openSession();
session.beginTransaction();
//1立即
// Customer customer = (Customer) session.get(Customer.class, 1);
//2延迟
Customer customer = (Customer) session.load(Customer.class, 1);
//打印
System.out.println(customer.getCid());
System.out.println(customer.getCname());
session.getTransaction().commit();
session.close();
}case：
package com.itheima.b_lazy;
import org.hibernate.Session;
import org.junit.Test;
import com.itheima.domain.Course;
import com.itheima.domain.Customer;
import com.itheima.domain.Student;
import com.itheima.utils.HibernateUtils;
public class Demo {
@Test
//类级别懒加载
//load方法
// class lazy属性
// 默认值: true load获得时,会返回代理对象,不查询数据库.使用时才查询
public void fun1(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Customer c = (Customer) session.load(Customer.class, 1);
System.out.println(c.getName());
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//类级别懒加载
//load方法
// class lazy属性
// lazy: false load方法执行就会发送sql语句.与get方法一致.
public void fun2(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Customer c = (Customer) session.load(Customer.class, 1);
System.out.println(c.getName());
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
}
4.关联级别检索
(1)一对多或多对多
介绍：l 容器<set> 提供两个属性：fetch、lazy
fetch：确定使用sql格式
lazy：关联对象是否延迟。
l fetch：join、select、subselect
join：底层使用迫切左外连接
select：使用多个select语句（默认值）
subselect：使用子查询
l lazy：false、true、extra
false：立即
true：延迟（默认值）
extra：极其懒惰
fetch="join"
l fetch="join" ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。
@Test
public void demo03() {
//关联级别：一对多，
// * Customer.hbm.xml <set fetch="join">
// *** select语句使用左外连接，一次性查询所有
Session session = factory.openSession();
session.beginTransaction();
//1 查询客户
Customer customer = (Customer) session.get(Customer.class, 1);
System.out.println(customer.getCname());
//2 查询客户订单数
Set<Order> orderSet = customer.getOrderSet();
System.out.println(orderSet.size());
//3 查询客户订单详情
for (Order order : orderSet) {
System.out.println(order);
}
session.getTransaction().commit();
session.close();
}fetch="select"
l 当前对象 和 关联对象 使用多条select语句查询。l lazy="false" , 立即，先查询客户select，立即查询订单select
l lazy="true",延迟，先查询客户select，需要订单时，再查询订单select
l lazy="extra"，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）
fetch="subselect"
l 将使用子查询。注意：必须使用Query否则看不到效果。l lazy= 同上
@Test
public void demo04() {
//关联级别：一对多，
// 演示3：* Customer.hbm.xml <set fetch="subselect">
Session session = factory.openSession();
session.beginTransaction();
//1 查询客户
List<Customer> allCustomer = session.createQuery("from Customer").list();
Customer customer = allCustomer.get(0);
System.out.println(customer.getCname());
//2 查询客户订单数
Set<Order> orderSet = customer.getOrderSet();
System.out.println(orderSet.size());
//3 查询客户订单详情
for (Order order : orderSet) {
System.out.println(order);
}
session.getTransaction().commit();
session.close();
}
关联级别加载策略
在查询有关联关系的数据时,加载一方的数据是否需要将另一方立即查询出.
默认: 与我关联的数据,在使用时才会加载.
集合(一对多):
set
lazy: 是否对set数据使用懒加载
true:(默认值) 对集合使用才加载
false: 集合将会被立即加载
extra: 极其懒惰,如果使用集合时,之调用size方法查询数量, Hibernate会发送count语句,只查询数量.不加载集合内数据.
fetch : 决定加载集合使用的sql语句种类
select: (默认值) 普通select查询
join: 表链接语句查询集合数据
subselect: 使用子查询 一次加载多个Customer的订单数据
case：
配置：
<?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 package="com.itheima.domain" > <class name="Customer" table="t_customer" > <id name="id" column="id" > <generator class="native"></generator> </id> <!-- 告诉Hibernate , 乐观锁的版本号的属性名 --> <version name="version"></version> <property name="name" column="name" type="string" ></property> <!-- lazy : 是否对set数据使用懒加载 fetch : 决定加载集合使用的sql语句种类 --> <set name="orders" batch-size="2" > <!-- key 用来描述外键 column : 外键的值 --> <key column="cid" ></key> <!-- one-to-many 表达, Customer 与orders 的关系是一对多 class: 表达关联的另一方的完整类名 --> <one-to-many class="Order" /> </set> <!-- 局部配置 --> <query name="bcd"><![CDATA[from Order]]></query> </class> <!-- 全局配置 --> <query name="abc"><![CDATA[from Customer]]></query> </hibernate-mapping>
Test：
package com.itheima.b_lazy;
import java.util.List;
import org.hibernate.Session;
import org.junit.Test;
import com.itheima.domain.Customer;
import com.itheima.domain.Order;
import com.itheima.utils.HibernateUtils;
public class Demo2 {
@Test
//关联级别懒加载
//默认: 与我关联的数据,在使用时才会加载.
public void fun1(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Customer c = (Customer) session.get(Customer.class, 1);
for(Order o : c.getOrders()){
System.out.println(o.getName());
}
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//关联级别懒加载
//lazy: false
public void fun2(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Customer c = (Customer) session.get(Customer.class, 1);
for(Order o : c.getOrders()){
System.out.println(o.getName());
}
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//关联级别懒加载
//lazy: false/true
//fetch:join
public void fun3(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Customer c = (Customer) session.get(Customer.class, 1);
for(Order o : c.getOrders()){
System.out.println(o.getName());
}
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//关联级别懒加载
//lazy:true
//fetch:subselect
public void fun4(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
List<Customer> list = session.createQuery("from Customer").list();
for(Customer c:list){
System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
}
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//关联级别懒加载
//lazy:false
//fetch:subselect
public void fun5(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
List<Customer> list = session.createQuery("from Customer").list();
for(Customer c:list){
System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
}
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//关联级别懒加载
//lazy:extra
//fetch:select
public void fun6(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
//查询Customer
Customer c = (Customer) session.get(Customer.class, 1);
//查询Customer下订单 数量
System.out.println(c.getOrders().size());
//真正使用订单中的数据
for(Order o : c.getOrders()){
System.out.println(o.getName());
}
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@SuppressWarnings("unchecked")
@Test
//关联级别懒加载
//lazy:extra
//fetch:subselect
public void fun7(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
List<Customer> list = session.createQuery("from Customer").list();
for(Customer c:list){
System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
}
for(Customer c:list){
for(Order o : c.getOrders()){
System.out.println(c.getName()+"下单名称:"+o.getName());
}
}
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
}(2)多对一
介绍：l <many-to-one fetch="" lazy=""> (<one-to-one>)
l fetch取值：join、select
join：底层使用迫切左外连接
select：多条select语句
l lazy取值：false、proxy、no-proxy
false：立即
proxy：采用关联对象 类级别检索的策略。
订单 关联 客户 （多对一）
订单 立即获得 客户，需要在客户Customer.hbm.xml <class lazy="false">
订单 延迟获得 客户，需要在客户Customer.hbm.xml <classlazy="true">
no-proxy不研究
fetch="join"
l fecth="join" select语句使用左外连接，此时lazy无效。@Test
public void demo05() {
//关联级别：多对一，
// 演示1：* Order.hbm.xml <set fetch="join"> lazy无效
// * 注意：检查Customer.hbm.xml 和 Order.hbm.xml 没有额外的配置
Session session = factory.openSession();
session.beginTransaction();
//1 查询订单
Order order = (Order) session.get(Order.class, 1);
System.out.println(order.getPrice());
//2 查询订单客户信息
Customer customer = order.getCustomer();
System.out.println(customer.getCname());
session.getTransaction().commit();
session.close();
}fetch="select"
l 将采用多条select语句，lazy="proxy"是否延迟，取决关联对象 类级别检索策略。l lazy="false"
l lazy="proxy"
多对一:
lazy
false
加载订单时,会立即加载客户
proxy
看客户对象的类加载策略来决定
no-proxy : 不做研究.
fetch=
select : (默认值)使用普通select加载
join : 使用表链接加载数据
case：
配置：
<?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 package="com.itheima.domain" > <class name="Order" table="t_order" > <id name="id" column="id" > <generator class="native"></generator> </id> <property name="name" column="name" type="string" ></property> <!-- lazy false proxy no-proxy : 不做研究. fetch= select join --> <many-to-one name="customer" column="cid" class="Customer" ></many-to-one> </class> </hibernate-mapping>
Test：
package com.itheima.b_lazy;
import java.util.List;
import org.hibernate.Session;
import org.junit.Test;
import com.itheima.domain.Customer;
import com.itheima.domain.Order;
import com.itheima.utils.HibernateUtils;
//多对一检索策略
public class Demo3 {
@Test
//fetch: select
//lazy: false
public void fun1(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Order o = (Order) session.get(Order.class, 2);
System.out.println(o.getCustomer().getName());
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//fetch: select
//lazy: proxy
// Customer lazy:false
public void fun2(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Order o = (Order) session.get(Order.class, 2);
System.out.println(o.getCustomer().getName());
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//fetch: select
//lazy: proxy
// Customer lazy:true
public void fun3(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Order o = (Order) session.get(Order.class, 2);
System.out.println(o.getCustomer().getName());
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
@Test
//fetch: join
//lazy: proxy|false
public void fun4(){
Session session = HibernateUtils.openSession();
session.beginTransaction();
//------------------------------------------------
Order o = (Order) session.get(Order.class, 2);
System.out.println(o.getCustomer().getName());
//------------------------------------------------
session.getTransaction().commit();
session.close(); // 游离状态
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 【JavaWeb-21】多对多关系、类和关联级别的加载策略、HQL查询详解、Hibernate连接池配置、Hibernate里悲观锁乐观锁使用
- SSH与SSM学习之hibernate23——关联级别加载策略之集合关联加载策略
- Hibernate懒加载、关联级别加载策略
- SSH与SSM学习之hibernate24——关联级别加载策略之属性关联加载策略
- SSH与SSM学习之hibernate22——类级别加载策略
- [原创]java WEB学习笔记91：Hibernate学习之路-- -HQL 迫切左外连接,左外连接，迫切内连接，内连接，关联级别运行时的检索策略 比较。理论，在于理解
- hibernate关联策略 查询优化之关联级别查询
- hibernate之多态关联(多态的多对一,利用any,使用每个具体类一张表的策略)
- hibernate04 懒加载、抓取策略、二者结合、session详解、一级缓存、二级缓存、查询缓存
- hibernate的抓取策略和懒加载
- Hibernate中双向关联加载排序的解决方案
- Hibernate关联映射之延迟加载
- Hibernate检索策略之5.2多对一单向关联检索策略——Hibernate4究竟怎么玩
- Hibernate性能调优--关联实体的延迟加载
- [原创]java WEB学习笔记93：Hibernate学习之路---Hibernate 缓存介绍，缓存级别，使用二级缓存的情况，二级缓存的架构集合缓存，二级缓存的并发策略，实现步骤，集合缓存，查询缓存，时间戳缓存
- hibernate中对象视图导航查询|加载策略---【小白系列】0基础到熟练应用hibernate框架(十四)
- Hibernate检索策略之5.3.1一对一单向（外键）关联检索策略——Hibernate4究竟怎么玩
- day35_hibernate懒加载&抓取策略&常见错误分析
- Hibernate检索策略之5.4一对多单向关联检索策略——Hibernate4究竟怎么玩
- Hibernate 关联映射 之多对一关联（二） 懒加载