抓取策略（优化）
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.hcx.b_lazy;
import org.hibernate.Session;
import org.junit.Test;
import com.hcx.domain.Course;
import com.hcx.domain.Customer;
import com.hcx.domain.Student;
import com.hcx.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)一对多或多对多
介绍：
容器<set> 提供两个属性：fetch、lazy
fetch：确定使用sql格式
lazy：关联对象是否延迟。
fetch：join、select、subselect
join：底层使用迫切左外连接
select：使用多个select语句（默认值）
subselect：使用子查询
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"
当前对象 和 关联对象 使用多条select语句查询。
lazy="false" , 立即，先查询客户select，立即查询订单select
lazy="true",延迟，先查询客户select，需要订单时，再查询订单select
lazy="extra"，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）
fetch="subselect"
将使用子查询。注意：必须使用Query否则看不到效果。
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的订单数据
在查询有关联关系的数据时,加载一方的数据是否需要将另一方立即查询出.
默认: 与我关联的数据,在使用时才会加载.
集合(一对多):
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.hcx.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.hcx.b_lazy;
import java.util.List;
import org.hibernate.Session;
import org.junit.Test;
import com.hcx.domain.Customer;
import com.hcx.domain.Order;
import com.hcx.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)多对一
介绍：
<many-to-one fetch="" lazy=""> (<one-to-one>)
fetch取值：join、select
join：底层使用迫切左外连接
select：多条select语句
lazy取值：false、proxy、no-proxy
false：立即
proxy：采用关联对象 类级别检索的策略。
订单 关联 客户 （多对一）
订单 立即获得 客户，需要在客户Customer.hbm.xml <class lazy="false">
订单 延迟获得 客户，需要在客户Customer.hbm.xml <classlazy="true">
no-proxy不研究
fetch="join"
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"
将采用多条select语句，lazy="proxy"是否延迟，取决关联对象 类级别检索策略。
lazy="false"
lazy="proxy"
多对一:
lazy
false 加载订单时,会立即加载客户
proxy 看客户对象的类加载策略来决定
no-proxy : 不做研究.
fetch=
select : (默认值)使用普通select加载
join : 使用表链接加载数据
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.hcx.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.hcx.b_lazy;
import java.util.List;
import org.hibernate.Session;
import org.junit.Test;
import com.hcx.domain.Customer;
import com.hcx.domain.Order;
import com.hcx.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(); // 游离状态
}
}
139
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
