标签：create 应用 多次 public nat select on() 需要 抓取策略
时间：2017-1-23 19:08
——区分延迟和立即检索
1、立即检索
当执行某行代码时，会马上发出SQL语句进行查询。
例如：get()
2、延迟检索
当执行某行代码时，不会马上发出SQL语句，只有当真正使用对象时，才会向数据库发出SQL语句。
例如：load()
3、示例代码
/*
* 区分立即检索和延迟检索
*/
public void fun1(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
// 立即检索
Customer customer = (Customer) session.get(Customer.class, 1);
System.out.println(customer);
/*
* 延迟检索
* 当持久化类设置为final之后，延迟检索就失效了，因为不能生成代理对象
* 在Customer.hbm.xml的<class>标签上配置lazy="false"，表示不支持延迟检索
*/
Customer customer2 = (Customer) session.load(Customer.class, 1);
// 初始化代理对象
System.out.println(customer2);
Hibernate.initialize(customer2); // 会立即检索
tx.commit();
session.close();
}
——类级别检索和关联级别检索
1、类级别的检索：
1）类级别可选的检索策略包括立即检索和延迟检索，默认为延迟检索。
2）类级别的检索策略可以通过<class>元素的lazy属性进行设置。
3）如果程序加载一个对象的目的是为了访问它的属性，可以采取立即检索的方式，如果程序加载一个持久化对象的目的仅仅是为了获得它的引用，可以采用延迟检索。
4）无论<class>元素的lazy属性是true还是false，Session的get()方法以及Query的list()方法在类级别总是使用立即检索的策略。
5）若<class>元素的lazy属性为true或取默认值，Session的load()方法不会执行查询数据表的select语句，而是仅返回代理对象的实例，该代理对象实例有如下特征：
* 由Hibernate在运行时采用javassist工具动态生成
* Hibernate创建代理对象实例时，仅初始化其OID属性
* 在应用程序第一次访问代理实例的非OID属性时，Hibernate会初始化代理类实例。
2、关联级别的检索
1）在映射文件中，用<set>元素来配置一对多关联及多对多关联关系，<set>元素中有lazy和fetch属性：
2）lazy：主要决定orders集合被初始化的时机，即是否在Customer对象初始化时被加载，还是在程序访问orders集合时被初始化。
3）fetch：取值为select或subselect时，决定初始化orders的查询语句的形式，若取值为join，则决定orders集合被初始化的时机。
4）若把fetch设置为“join”，lazy属性将被忽略。
——一方关联多方的情况
在<set>元素中包含fetch和lazy属性：
* fetch：控制SQL语句的类型
> join：采用迫切左外连接查询
> select：默认值
> subselect：发送子查询来查询关联对象
* lazy：控制关联对象的检索是否采用延迟
> true：默认值，查询关联对象采用延迟检索
> false：查询关联对象不使用延迟检索
> extra：特懒
join：一次查完
select：分多次查完
lazy="true"：延迟查询
lazy="false"：不延迟查询
如果fetch="join"，那么lazy属性将被忽略。
示例代码：
1）<set>集合中没有配置fetch和lazy的情况
默认值：fetch="select" lazy="true"
// 只发送查询客户的SQL语句，没有发送查询订单的SQL
Customer customer = (Customer) session.get(Customer.class, 1);
// 使用客户订单信息的时候，才会发送查询订单的SQL语句
System.out.println(customer.getOrders().size());
SQL：
Hibernate:
select
customer0_.cid as cid0_0_,
customer0_.cname as cname0_0_
from
customer customer0_
where
customer0_.cid=?
Hibernate:
select
orders0_.cid as cid0_1_,
orders0_.oid as oid1_,
orders0_.oid as oid1_0_,
orders0_.addr as addr1_0_,
orders0_.cid as cid1_0_
from
order_table orders0_
where
orders0_.cid=?
2）在<set>标签中配置fetch="join"，lazy会被忽略
* 只要fetch设置为join，会采用迫切左外连接进行查询
// 直接发送一条迫切左外连接查询，查询全部数据，包括订单信息
Customer customer = (Customer) session.get(Customer.class, 1);
System.out.println(customer.getOrders().size());
SQL：
Hibernate:
select
customer0_.cid as cid0_1_,
customer0_.cname as cname0_1_,
orders1_.cid as cid0_3_,
orders1_.oid as oid3_,
orders1_.oid as oid1_0_,
orders1_.addr as addr1_0_,
orders1_.cid as cid1_0_
from
customer customer0_
left outer join
order_table orders1_
on customer0_.cid=orders1_.cid
where
customer0_.cid=?
3）在<set>标签中配置fetch="select" lazy="extra"
* lazy="extra" 极其懒惰
// 只查询Customer的信息，不查询关联对象信息
Customer customer = (Customer) session.get(Customer.class, 1);
// 当查询数量时，只会发送：select count(*) from order_table where oid = ?
System.out.println(customer.getOrders().size());
// 当查询订单时，才会查询全部订单信息：selecg * from order_table
System.out.println(customer.getOrders());
SQL：
Hibernate:
select
customer0_.cid as cid0_0_,
customer0_.cname as cname0_0_
from
customer customer0_
where
customer0_.cid=?
Hibernate:
select
count(oid)
from
order_table
where
cid =?
Hibernate:
select
orders0_.cid as cid0_1_,
orders0_.oid as oid1_,
orders0_.oid as oid1_0_,
orders0_.addr as addr1_0_,
orders0_.cid as cid1_0_
from
order_table orders0_
where
orders0_.cid=?
4）在<set>标签中配置fetch="subselect" lazy="true"
* 使用subselect的时候需要使用Query接口进行测试，因为需要查询多个客户，才能看到子查询的效果
* 查询一个客户和查询多个客户有什么区别？
* > 如果只有一个客户会使用：=
* > 如果有多个客户会使用：in
List<Customer> list = session.createQuery("from Customer").list();
for(Customer c : list){
System.out.println(c.getOrders().size());
}
SQL：
Hibernate:
select
customer0_.cid as cid0_,
customer0_.cname as cname0_
from
customer customer0_
Hibernate:
select
orders0_.cid as cid0_1_,
orders0_.oid as oid1_,
orders0_.oid as oid1_0_,
orders0_.addr as addr1_0_,
orders0_.cid as cid1_0_
from
order_table orders0_
where
orders0_.cid in (
select
customer0_.cid
from
customer customer0_
)
——多方关联一方的情况
1、多对一和一对一关联的检索策略，和<set>一样，<many-to-one>元素也有一个lazy属性和fetch属性：
* 若fetch属性设为join，那么lazy属性被忽略。
* 迫切左外连接检索策略的优点在于比立即检索策略使用的select语句更少。
* 无代理延迟检索需要增强持久化类的字节码才能实现。
2、Query的list()方法会忽略映射文件配置的迫切左外连接检索策略，而采用延迟检索或立即检索策略，根据Customer类级别的lazy属性进行检索，lazy="true"为延迟检索，lazy="false"为立即检索。
3、如果在关联级别使用了延迟加载或立即加载检索策略，可以设定批量检索的大小，以帮助提高延迟检索或立即检索的运行性能。
4、<many-to-one>
* fetch：控制SQL语句发送格式
> join：使用迫切左外连接查询，lazy会被忽略
> select：发送多条SQL检索对象
* lazy：关联对象检索的时候，是否采用延迟
> false：不延迟
> proxy：使用代理，检索订单时是否马上检索客户，由Customer对象的映射文件中<class>元素的lazy属性来决定
> no-proxy：不使用代理
示例代码：
1）没有在<many-to-one>标签上进行配置
* 发送多条SQL来查询订单中的信息
// 只查询订单的记录，拿到的是关联Customer的引用
Order order = (Order) session.get(Order.class, 1);
// 使用订单的Customer对象时，会发送一条SQL查询订单关联的客户对象的信息
System.out.println(order.getCustomer().getCname());
SQL：
Hibernate:
select
order0_.oid as oid1_0_,
order0_.addr as addr1_0_,
order0_.cid as cid1_0_
from
order_table order0_
where
order0_.oid=?
Hibernate:
select
customer0_.cid as cid0_0_,
customer0_.cname as cname0_0_
from
customer customer0_
where
customer0_.cid=?
2）在<many-to-one>标签上进行配置
* fetch="join" lazy会被忽略
* 发送迫切左外连接
// 发送一条迫切左外连接，将全部信息都获取到，并且封装到对象中
Order order = (Order) session.get(Order.class, 1);
System.out.println(order.getCustomer().getCname());
SQL：
Hibernate:
select
order0_.oid as oid1_1_,
order0_.addr as addr1_1_,
order0_.cid as cid1_1_,
customer1_.cid as cid0_0_,
customer1_.cname as cname0_0_
from
order_table order0_
left outer join
customer customer1_
· on order0_.cid=customer1_.cid
where
order0_.oid=?
3）在<many-to-one>标签上设置
* fetch="select" lazy="false"
// 发送多条SQL，不延迟，一次查完
Order order = (Order) session.get(Order.class, 1);
System.out.println(order.getCustomer().getCname());
SQL：
Hibernate:
select
order0_.oid as oid1_0_,
order0_.addr as addr1_0_,
order0_.cid as cid1_0_
from
order_table order0_
where
order0_.oid=?
Hibernate:
select
customer0_.cid as cid0_0_,
customer0_.cname as cname0_0_
from
customer customer0_
where
customer0_.cid=?
——批量抓取
1、从一方批量抓取多方记录
在Customer.hbm.xml的<set>标签上配置batch-size="2"
* 表示一次查询两个
示例代码：
List<Customer> list = session.createQuery("from Customer").list();
for(Customer customer : list){
for(Order order : customer.getOrders()){
System.out.println(order.getAddr());
}
}
SQL：
Hibernate:
select
customer0_.cid as cid0_,
customer0_.cname as cname0_
from
customer customer0_
Hibernate:
select
orders0_.cid as cid0_1_,
orders0_.oid as oid1_,
orders0_.oid as oid1_0_,
orders0_.addr as addr1_0_,
orders0_.cid as cid1_0_
from
order_table orders0_
where
orders0_.cid in (
?, ?
)
奎文3
奎文4
奎文1
奎文7
奎文2
奎文0
奎文8
奎文6
奎文9
奎文5
高新2
高新9
高新3
高新8
高新1
高新4
高新0
高新5
高新6
高新7
Hibernate:
select
orders0_.cid as cid0_1_,
orders0_.oid as oid1_,
orders0_.oid as oid1_0_,
orders0_.addr as addr1_0_,
orders0_.cid as cid1_0_
from
order_table orders0_
where
orders0_.cid=?
潍城4
潍城5
潍城6
潍城1
潍城7
潍城0
潍城9
潍城2
潍城3
潍城8
2、从多方批量抓取一方记录
不能在多方设置batch-size属性，需要在一方的<class>标签上设置batch-size。
——总结
1、立即检索
2、延迟检索
配置fetch和lazy属性
* 配置立即检索
> lazy="false"
> 持久化类设置为final
> 在调用方法的时候，初始化代理对象
3、延迟
类级别的延迟：
<class>元素上设置lazy
关联级别的延迟：
<set> / <many-to-many> / <one-to-one>
4、fetch属性
* <set>集合上的fetch：
> join：强制使用迫切左外连接
> select：默认值，会发送多条SQL语句
> subselect：使用子查询
* 在<many-to-one>标签上使用
> select：默认值，发送多条SQL
> join：强制使用迫切左外连接
5、lazy属性
* <set>
> true：默认值，延迟
> false：不采用延迟
> extra：极其懒惰
* <many-to-one>
> proxy：根据另一方的<calss>元素配置的lazy来确定是否使用延迟。
> false：不采用延迟。
> no-proxy
6、batch-size批量抓取
默认情况下只会检索一条记录，如果想要批量抓取多条记录，可以使用batch-size进行检索。
Hibernate之抓取策略
标签：create 应用 多次 public nat select on() 需要 抓取策略
原文地址：http://www.cnblogs.com/wwwwyc/p/6375466.html
