hibernate教程--抓取策略

Hibernate的抓取策略

1.1、 区分延迟和立即检索:

立即检索:

* 当执行某行代码的时候,马上发出SQL语句进行查询.

* get()

延迟检索:

* 当执行某行代码的时候,不会马上发出SQL语句进行查询.当真正使用这个对象的时候才会发送SQL语句.

* load();

1.2、类级别检索和关联级别检索:

类级别的检索:

* ＜class>标签上配置lazy

关联级别的检索:

* <set>/<many-to-one>上面的lazy.

1.2.1、从一的一方关联多的一方:

* <set>

* fetch:控制sql语句的类型

* join:发送迫切左外连接的SQL查询关联对象.fetch=”join”那么lazy被忽略了.

* select:默认值,发送多条SQL查询关联对象.

* subselect:发送子查询查询关联对象.(需要使用Query接口测试)

* lazy:控制关联对象的检索是否采用延迟.

* true:默认值, 查询关联对象的时候使用延迟检索

* false:查询关联对象的时候不使用延迟检索.

* extra:及其懒惰.

如果fetch是join的情况,lazy属性将会忽略.

1.2.2、在多的一方关联一的一方:

* <many-to-one>

* fetch:控制SQL语句发送格式

* join:发送一个迫切左外连接查询关联对象.fetch=”join”,lay属性会被忽略.

* select:发送多条SQL检索关联对象.

* lazy:关联对象检索的时候,是否采用延迟

* false:不延迟

* proxy:使用代理.检索订单额时候,是否马上检索客户 由Customer对象的映射文件中<class>上lazy属性来决定.

* no-proxy:不使用代理

测试：

package com.sihai.hibernate3.test;

import java.util.List;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.sihai.hibernate3.demo1.Customer;
import com.sihai.hibernate3.demo1.Order;
import com.sihai.utils.HibernateUtils;

/**
 * Hibernate的抓取策略
 * 
 * @author sihai
 * 
 */
public class HibernateTest4 {
	@SuppressWarnings("unchecked")
	@Test
	// 批量抓取:
	// 从订单批量抓取客户
	// 在Customer.hbm.xml中<class>标签上设置batch-size=""
	public void demo9(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		// 查询所有的订单:
		List<Order> list = session.createQuery("from Order").list();
		for (Order order : list) {
			System.out.println(order.getCustomer().getCname());
		}
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 批量抓取:
	// 从客户批量抓取订单
	// <set>标签上设置batch-size=""
	public void demo8(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		// 查询所有客户
		List<Customer> list = session.createQuery("from Customer").list();
		for (Customer customer : list) {
			for (Order order : customer.getOrders()) {
				System.out.println(order.getAddr());
			}
		}
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 在Order.hbml.xml中<many-to-one>标签上配置fetch和lazy
	public void demo7(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		/**
		 * fetch="select",lazy="false"
		 */
		// 查询一号订单
		//Order order = (Order) session.get(Order.class, 1);// 发送多条SQL查询关联对象
		// 查询一号订单所属客户的名称:
		//System.out.println("客户名称:"+order.getCustomer().getCname());// 不发送SQL
		
		/**
		 * fetch="select",lazy="proxy"
		 * proxy:查询关联对象的时候,是否采用延迟,由另一端的类级别延迟来决定.
		 * 	* Customer的<class>上配置的是lazy="true".检索的时候采用延迟
		 * 	* Customer的<class>上配置的是lazy="false".检索的时候不采用延迟
		 */
		// 查询一号订单
		Order order = (Order) session.get(Order.class, 1);// 发送多条SQL查询关联对象
		// 查询一号订单所属客户的名称:
		System.out.println("客户名称:"+order.getCustomer().getCname());// 不发送SQL
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 在Order.hbml.xml中<many-to-one>标签上配置fetch和lazy
	public void demo6(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		/**
		 * fetch="join",lazy被忽略.
		 */
		// 查询一号订单
		Order order = (Order) session.get(Order.class, 1);// 发送一条迫切左外连接查询关联对象.
		// 查询一号订单所属客户的名称:
		System.out.println("客户名称:"+order.getCustomer().getCname());
		
		tx.commit();
		session.close();
	}
	
	@SuppressWarnings("unchecked")
	@Test
	// 在Customer.hbm.xml的<set>标签上配置fetch和lazy
	// fetch="subselect" 子查询
	public void demo5(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		/**
		 * 配置fetch="subselect" lazy="true"
		 */
//		List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL
//		for (Customer customer : list) {
//			System.out.println("客户订单数量:"+customer.getOrders().size());// 发送一个子查询去查询关联对象.
//		}
		
		// 使用子查询 查询多个的情况.
		/*Customer customer = (Customer) session.get(Customer.class, 1);
		System.out.println("客户订单数量:"+customer.getOrders().size());*/
		
		/**
		 * 配置fetch="subselect" lazy="false"
		 */
//		List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL,发送一个子查询查询订单
//		for (Customer customer : list) {
//			System.out.println("客户订单数量:"+customer.getOrders().size());// 不发送SQL
//		}
		
		/**
		 * 配置fetch="subselect" lazy="extra"
		 */
		List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL
		for (Customer customer : list) {
			System.out.println("客户订单数量:"+customer.getOrders().size());// 只发送统计客户订单数量的sql
			for (Order order : customer.getOrders()) {
				System.out.println(order.getAddr());
			}
		}
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 在Customer.hbm.xml的<set>标签上配置fetch和lazy
	// fetch="select"
	public void demo4() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();

		/**
		 * 配置fetch="select" lazy="true"
		 * * 发送多条SQL.默认值就是fetch="select" lazy="true"
		 */
		// 查询一号客户
		// Customer customer = (Customer) session.get(Customer.class, 1);//发送一条查询客户的SQL
		// 查看一号客户的订单的数量:
		// System.out.println("订单的数量:" + customer.getOrders().size());//又发送一条查询订单的SQL
		
		/**
		 * 配置fetch="select" lazy="false"
		 */
		// 查询一号客户
		//Customer customer = (Customer) session.get(Customer.class, 1);//发送多条SQL查询
		// 查看一号客户的订单的数量:
		//System.out.println("订单的数量:" + customer.getOrders().size());//不发送SQL
		
		/**
		 * 配置fetch="select" lazy="extra"
		 * * extra:及其懒惰的.
		 */
		// 查询一号客户
		Customer customer = (Customer) session.get(Customer.class, 1);// 发送一条查询客户的SQL
		// 查看一号客户的订单的数量:
		System.out.println("订单的数量:" + customer.getOrders().size());// 查询订单的数量:select count(oid) from orders o where o.cid = ? 
		
		for (Order order : customer.getOrders()) {
			System.out.println(order);
		}
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 在Customer.hbm.xml的<set>标签上配置fetch和lazy
	// fetch="join",lazy的取值就会被忽略.
	public void demo3() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();

		// 查询一号客户
		Customer customer = (Customer) session.get(Customer.class, 1);// 发送了一条迫切左外连接的SQL
		
		// 查看一号客户的订单的数量:
		System.out.println("订单的数量:" + customer.getOrders().size());// 不发送SQL.
		
		tx.commit();
		session.close();
	}

	@Test
	// 默认的情况下 没有配置任何信息
	// 发送多条SQL查询其关联对象.
	public void demo2() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();

		// 查询一号客户
		Customer customer = (Customer) session.get(Customer.class, 1);// 发送一条查询客户的SQL.

		// 查看一号客户的订单的数量:
		System.out.println("订单的数量:" + customer.getOrders().size());// 使用订单的时候,又会发送一条SQL查询

		tx.commit();
		session.close();
	}

	@Test
	// 区分立即和延迟检索
	public void demo1() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();

		// 立即检索
		// Customer customer = (Customer) session.get(Customer.class, 1);

		// System.out.println(customer.getCname());

		// 延迟检索:
		Customer customer = (Customer) session.load(Customer.class, 1);

		Hibernate.initialize(customer);

		System.out.println(customer.getCname());

		tx.commit();
		session.close();
	}
}