package cn.itcast.test; import java.util.List; import org.hibernate.Hibernate; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import cn.itcast.utils.HibernateUtils; import cn.itcast.vo.Customer; import cn.itcast.vo.Order; /** * Hibernate的抓取策略 * @author zhongzh * */ public class HibernateDemo2 { @Test /* *批量抓取 减少与数据库交互的次数 * 通过订单批量抓取客户: * 需要在客户一端<class>标签上配置batch-size * 批量抓取都是在一的一端配置的 */ public void demo13(){ 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()); } } @Test /* *批量抓取 减少与数据库交互的次数 * 在客户的一端配置 * <set>集合上配置batch-size="3" */ public void demo12(){ 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()); } } } @Test /* * 没有在<many-to-one>标签上配置: * * fetch="select" lazy="proxy" * * 发送多条SQL */ public void demo11(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); // 在这行发送多条SQL 查询关联对象. Order order = (Order) session.get(Order.class, 1); System.out.println(order.getCustomer().getCname()); tx.commit(); session.close(); } @Test /* * 没有在<many-to-one>标签上配置: * * fetch="select" lazy="false" * * 发送多条SQL */ public void demo10(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); // 在这行发送多条SQL 查询关联对象. Order order = (Order) session.get(Order.class, 1); System.out.println(order.getCustomer().getCname()); tx.commit(); session.close(); } @Test /* * 没有在<many-to-one>标签上配置: * * fetch="join" lazy="被忽略" * * 发送迫切左外连接 */ public void demo9(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); //发送一条迫切左外连接.查询关联对象. Order order = (Order) session.get(Order.class, 1); System.out.println(order.getCustomer().getCname()); tx.commit(); session.close(); } @Test /* * 没有在<many-to-one>标签上配置: * * 发送多条SQL进行查询. * */ public void demo8(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); //只会发送一条查询订单的SQL. Order order = (Order) session.get(Order.class, 1); //使用订单的客户对象的时候,又发送一条SQL查询订单关联的客户 System.out.println(order.getCustomer().getCname()); tx.commit(); session.close(); } @Test /* * 在<set>集合上配置 * * fetch="subselect" lazy="true" * * 使用subselect的时候 需要使用query接口进行测试. * * 如果查询一个客户 查询多个客户. * 如果有多个客户: * * select * from orders where cno in (1,2,3); * 如果只有一个客户: * * select * from orders where cno = 1; */ public void demo7(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); List<Customer> list = session.createQuery("from Customer").list(); for (Customer customer : list) { System.out.println(customer.getOrders().size()); } tx.commit(); session.close(); } @Test /* * 在<set>集合上配置 * * fetch="select" lazy="extra" * * lazy:extra:极其懒惰.要订单的数量 */ public void demo6(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); Customer customer = (Customer) session.get(Customer.class, 1); // select count(*) from orders where cno = ?; System.out.println(customer.getOrders().size()); //发送查询订单的SQL. for (Order order : customer.getOrders()) { System.out.println(order);//使用订单的是时候它才会发送查询订单的SQL. } tx.commit(); session.close(); } @Test /* * 在<set>集合上配置 * * fetch="select" lazy="false" * * lazy:false:关联对象的检索不使用延迟 */ public void demo5(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); // 发送多条SQL,查询关联对象. Customer customer = (Customer) session.get(Customer.class, 1); // 使用订单的时候又发送一条查询这个客户的订单的SQL System.out.println(customer.getOrders().size()); tx.commit(); session.close(); } @Test /* * 在<set>集合上配置 * * fetch="select" lazy="true" * * lazy:true-使用延迟检索 * * 发送多条SQL,查询关联对象 */ public void demo4(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); // 发送一条只查询客户的SQL Customer customer = (Customer) session.get(Customer.class, 1); // 使用订单的时候又发送一条查询这个客户的订单的SQL System.out.println(customer.getOrders().size()); tx.commit(); session.close(); } @Test /* * * <set>配置fetch="join" lazy就会被忽略!!!! * * 发送迫切左外连接查询两个表. */ public void demo3(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); //直接发送一条迫切左外连接。其实迫切左外连接和左外连接的SQL语句是一样的.只不过封装的对象不一样. //迫切左外连接封装到一个对象里.而普通左外连接封装到一个数组里. //只要一查客户订单就出来了. /* * Hibernate: select customer0_.cid as cid0_1_, customer0_.cname as cname0_1_, orders1_.cno as cno0_3_, orders1_.oid as oid3_, orders1_.oid as oid1_0_, orders1_.addr as addr1_0_, orders1_.cno as cno1_0_ from Customer customer0_ left outer join orders orders1_ on customer0_.cid=orders1_.cno where customer0_.cid=? */ Customer customer = (Customer) session.get(Customer.class, 1); System.out.println(customer.getOrders().size()); tx.commit(); session.close(); } @Test /* * * <set>没有配置fetch 和 lazy情况 * */ public void demo2(){ Session session = HibernateUtils.openSession(); Transaction tx = session.beginTransaction(); Customer customer = (Customer) session.get(Customer.class,1);// 发送查询客户的SQL. //System.out.println(customer.getCname()); System.out.println(customer.getOrders().size());// 使用了客户的订单的时候,才会发送查询订单的SQL. 又发送一条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);*/ //延迟检索: // 持久化类如果设置为final 延迟检索就失效了.因为不能生成代理对象 // 在Customer.hbm.xml中在<class>标签上配置lazy="false"不支持延迟检索,就会立即检索. Customer customer = (Customer) session.load(Customer.class, 1);//这是类级别的检索 //System.out.println(customer);//如果这一行注释的话根本就不会发送SQL语句,你执行完了它也不会发送,因为你根本没有 //用到它里面的属性。 //初始化代理对象 发送SQL语句 产生代理对象 那肯定就能拿出来了 //System.out.println(customer.getCname()); //还可以这样来初始化代理对象 Hibernate.initialize(customer);//当你初始化的时候它才会发送SQL语句 tx.commit(); session.close(); } }
<?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="cn.itcast.vo"><!-- 如果这里配置了包名下面可以不用写 --> <!-- <hibernate-mapping> --> <!-- <class name="cn.itcast.hibernate3.demo2.Customer" table="customer"> --> <!-- <class name="cn.itcast.vo.Customer" table="customer"> --> <class name="Customer" batch-size="2" table="customer"> <!-- 配置唯一标识 --> <id name="cid" column="cid"> <generator class="native"/> </id> <!-- 配置普通属性 --> <property name="cname" column="cname" length="30"/> <!-- 建立映射 --> <!-- 配置一个集合 <set>的name Customer对象中的关联对象的属性名称. --> <!-- 这里把级联去掉 要最简短的配置 <set name="orders" cascade="save-update" inverse="true"> --> <set name="orders" cascade="save-update" batch-size="2"> <!-- <key>标签中column:用来描述一对多多的一方的外键的名称. --> <key column="cno"></key> <!-- 配置一个<one-to-many>标签中class属性:订单的类的全路径 --> <!-- <one-to-many class="cn.itcast.hibernate3.demo2.Order"/> --> <one-to-many class="cn.itcast.vo.Order"/> </set> </class> <!-- 命名查询的方式 --> <query name="findAll"> from Customer </query> <!-- 这里要写sql语句 <sql-query> </sql-query> --> </hibernate-mapping>
<?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> <!-- <class name="cn.itcast.hibernate3.demo2.Order" table="orders"> --> <class name="cn.itcast.vo.Order" table="orders"> <!-- 配置唯一标识 --> <id name="oid" column="oid"> <generator class="native"/> </id> <!-- 配置普通属性 --> <property name="addr" column="addr" length="50"/> <!-- 配置映射 --> <!-- <many-to-one>标签 name :关联对象的属性的名称. column :表中的外键名称. class :关联对象类的全路径 --> <!-- <many-to-one name="customer" column="cno" class="cn.itcast.hibernate3.demo2.Customer"/> --> <many-to-one name="customer" column="cno" class="cn.itcast.vo.Customer"/> </class> </hibernate-mapping>
package cn.itcast.vo; import java.util.HashSet; import java.util.Set; /** * 客户的实体: * @author 姜涛 * */ public class Customer { private Integer cid; private String cname; public Customer() {//无参构造函数 super(); // TODO Auto-generated constructor stub } public Customer(String cname) {//有参构造 super(); this.cname = cname; } // 一个客户有多个订单. private Set<Order> orders = new HashSet<Order>(); public Integer getCid() { return cid; } public void setCid(Integer cid) { this.cid = cid; } public String getCname() { return cname; } public void setCname(String cname) { this.cname = cname; } public Set<Order> getOrders() { return orders; } public void setOrders(Set<Order> orders) { this.orders = orders; } //@Override /* public String toString() {//客户这里打印也打印出订单的集合。这是死循环了，所以这里应该去掉一方的打印。 return "Customer [cid=" + cid + ", cname=" + cname + ", orders=" + orders + "]"; return "Customer [cid=" + cid + ", cname=" + cname + "]";//客户这里去掉订单集合的打印 }*/ //测试迫切内连接的封装效果。重写toString()方法 @Override public String toString() { return "Customer [cid=" + cid + ", cname=" + cname + ", orders=" + orders + "]"; } }
package cn.itcast.vo; /** * 订单的实体: * @author 姜涛 * */ public class Order { private Integer oid; private String addr; // 订单属于某一个客户.放置一个客户的对象. private Customer customer; public Integer getOid() { return oid; } public void setOid(Integer oid) { this.oid = oid; } public String getAddr() { return addr; } public void setAddr(String addr) { this.addr = addr; } public Customer getCustomer() { return customer; } public void setCustomer(Customer customer) { this.customer = customer; } //@Override /* public String toString() {//订单这边又打印客户了。这是死循环了，所以这里应该去掉一方的打印。 return "Order [oid=" + oid + ", addr=" + addr + ", customer=" + customer + "]"; }*/ //测试迫切内连接的封装效果。重写toString()方法 @Override public String toString() {//两边不能同时打印,不然容易出问题 return "Order [oid=" + oid + ", addr=" + addr + "]"; } }
