J2EE中最大的一个观念就是分层.. 

session是持久层的东东.不可窜到别的层.. 

你的这个问题其实就是延迟加载的问题. 

从理论的角度讲,最好是用一个就关一个.防止资源消耗. 
但由于hibernate中的延迟加载,所以出现了你的关闭session的话,就无法读取到学生类里的classes值问题. 
这个问题可以用Hibernate.initialize()来解决.也可就使用opensessionview的方式.spring中提供了这样的filter 
不知道这在使用中有没有使用spring.用了就比较方便,也不会出现你所说的 

对于后两种情况，用标签遍历时不太方便，因为无法直接转换成实体类的对象。比较简单的解决方法是：

　　の：hql查询多表部分字段，select new 包名.表1实体类名(表1.属性1，表2.属性2……) from 表1实体类,表2实体类 where 表1.ID=表2.ID（即相关联的字段），同时在要返回的表1实体类中添加表2的属性和带参的构造方法，参数的个数和顺序与（表1.属性1，表2.属性 2……) 保持一致

例如要查询Problem 中的pid，score，title，totalAccept,totalSubmission,unSee

 



感谢glamey兄弟的文章，正好解决了当前遇到的问题。原文链接如下：http://glamey.iteye.com/blog/721019
        假设我们现在有一个DTO，其属性包括两张表的属性，我们现在需要将sql语句查询得到的内容转为一个DTO对象，其解决方法如下：  

public class UserBean implements java.io.Serializable {

 // Fields

 private String id1;
 private String name1;
 private java.util.Date createtime1;
 private String address;

 // Constructors

 /** default constructor */
 public UserBean() {
 }

 /** minimal constructor */
 public UserBean(String id1) {
  this.id1 = id1;
 }

 /** full constructor */
 public UserBean(String id1, String name1, java.util.Date createtime1, String address) {
  this.id1 = id1;
  this.name1 = name1;
  this.createtime1 = createtime1;
  this.address = address;
 }

 // Property accessors

 public String getId1() {
  return this.id1;
 }

 public void setId1(String id1) {
  this.id1 = id1;
 }

 public String getName1() {
  return this.name1;
 }

 public void setName1(String name1) {
  this.name1 = name1;
 }

 public java.util.Date getCreatetime1() {
  return this.createtime1;
 }

 public void setCreatetime1(java.util.Date createtime1) {
  this.createtime1 = createtime1;
 }

 public String getAddress() {
  return this.address;
 }

 public void setAddress(String address) {
  this.address = address;
 }

}



<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="com.lcdbtsf.air.po.UserBean" table="ABIN5" schema="ABIN" dynamic-update="true">
        <id name="id1" type="string">
            <column name="ID1" precision="0" />
            <generator class="assigned" />
        </id>
        <property name="name1" type="string">
            <column name="NAME1" default="defaultname1"/>
        </property>
        <property name="createtime1" type="java.util.Date">
            <column name="CREATETIME1" length="19" />
        </property>
        <property name="address" type="string" update="true"  access="field" insert="true">
            <column name="ADDRESS" default="defaultaddress" />
        </property>
    </class>
   
    <query name="getUserBeanByAddress">
     <![CDATA[select o from UserBean o where o.address=:address order by o.createtime1 desc]]>
    </query>
   
     <!-- 命名查询中使用sql，不推荐使用，影响跨数据库
    <sql-query name="getUserBeanByAddress">
     <![CDATA[select o from UserBean o where o.address=:address order by o.createtime1 desc]]>
    </sql-query>
    -->
   
</hibernate-mapping>

package com.abin.lee.hibernate;

import java.util.List;

import junit.framework.TestCase;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Order;

import com.lcdbtsf.air.po.UserBean;

public class UserDao extends TestCase {

 public  List<UserBean> getAll(){
  Configuration cfg = new Configuration().configure(); // 获取hibernate的配置信息
  SessionFactory sf = cfg.buildSessionFactory(); // 根据config建立sessionFactory
  Session session = sf.openSession(); // factory用于建立session，开启Session，相当于开启JDBC的Connection
  Transaction ts = session.beginTransaction(); // 创建事务的对象ts
  List<UserBean> list=null;
  try {
   Criteria criteria=session.createCriteria(UserBean.class);
   criteria.addOrder(Order.desc("createtime1"));
   list=criteria.list();
   ts.commit();
  } catch (HibernateException he) {
   he.printStackTrace();
   ts.rollback();
  }
  return list;
 }
 
 public  List<UserBean> getAllByAddress(String address){
  Configuration cfg = new Configuration().configure(); // 获取hibernate的配置信息
  SessionFactory sf = cfg.buildSessionFactory(); // 根据config建立sessionFactory
  Session session = sf.openSession(); // factory用于建立session，开启Session，相当于开启JDBC的Connection
  Transaction ts = session.beginTransaction(); // 创建事务的对象ts
  List<UserBean> list=null;
  try {
   Query query=session.getNamedQuery("getUserBeanByAddress");
   query.setParameter("address", address);
   list=query.list();
   ts.commit();
  } catch (HibernateException he) {
   he.printStackTrace();
   ts.rollback();
  }
  return list;
 }

}

package com.abin.lee.hibernate;

import java.util.List;

import junit.framework.TestCase;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.lcdbtsf.air.po.UserBean;

public class UserDaoTest extends TestCase {

 public void test() {
   List<UserBean> list=new UserDao().getAllByAddress("shanghai");
  try {
   if(list.size()>0){
    UserBean user =list.get(0);
    System.out.println(list.get(0).getId1());
   }
  } catch (HibernateException he) {
   he.printStackTrace();  }
 }

}

hibernate 中 Criteria 的使用介绍

/**
 * Userbean entity. @author MyEclipse Persistence Tools
 */

public class UserBean implements java.io.Serializable {

 // Fields

 private String id;
 private String username;
 private String password;

 // Constructors

 /** default constructor */
 public UserBean() {
 }

 /** minimal constructor */
 public UserBean(String id) {
  this.id = id;
 }

 /** full constructor */
 public UserBean(String id, String username, String password) {
  this.id = id;
  this.username = username;
  this.password = password;
 }

 // Property accessors

 public String getId() {
  return this.id;
 }

 public void setId(String id) {
  this.id = id;
 }

 public String getUsername() {
  return this.username;
 }

 public void setUsername(String username) {
  this.username = username;
 }

 public String getPassword() {
  return this.password;
 }

 public void setPassword(String password) {
  this.password = password;
 }

}

package com.abin.lee.dao;

import java.sql.SQLException;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class UserDao {
 private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
 private static SessionFactory sessionFactory;
 static {
  sessionFactory=new Configuration().configure().buildSessionFactory();
 }
 public static Session GetSession(){
  Session session=(Session)threadLocal.get();
  if(null == session|| !session.isOpen()){
   if(null==sessionFactory){
    sessionFactory=new Configuration().configure().buildSessionFactory();
   }
   session=(sessionFactory!=null)?sessionFactory.openSession():null;
   threadLocal.set(session);
  }
  return session;
 }
 
 public static int insert(String id,String usr,String pwd) throws SQLException{
  UserDao UserDao=new UserDao();
  Session session=UserDao.GetSession();
  Transaction tx=session.beginTransaction();
  SQLQuery sqlQuery = session.createSQLQuery("{call insertObj(?,?,?)}");
  sqlQuery.setParameter(0, id);
  sqlQuery.setParameter(1, usr);
  sqlQuery.setParameter(2, pwd);
  int result=sqlQuery.executeUpdate();
  System.out.println("result="+result);
  return result;
 }
 
}

package com.abin.lee.test;

import java.sql.SQLException;

import junit.framework.TestCase;

import com.abin.lee.dao.UserDao;

public class UserTest extends TestCase{
 public void test() throws SQLException{
  UserDao user=new UserDao();
  int success=user.insert("abin","abing","bing");
  System.out.println("success="+success);
 }
}

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

 <session-factory>
  <property name="dialect">
   org.hibernate.dialect.OracleDialect
  </property>
  <property name="connection.url">
   jdbc:oracle:thin:@localhost:1521:xe
  </property>
  <property name="connection.username">abing</property>
  <property name="connection.password">abing</property>
  <property name="connection.driver_class">
   oracle.jdbc.driver.OracleDriver
  </property>
  <property name="myeclipse.connection.profile">
   OracleConnection
  </property>
  <mapping resource="com/abin/lee/bean/UserBean.hbm.xml" />
   
    </session-factory>

</hibernate-configuration>

在spring下配置使用二级缓存：

<property name="hibernateProperties">
<props>
........
<prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
</props>
</property>

其中${hibernate.cache.provider_class}为net.sf.ehcache.hibernate.EhCacheProvider，${hibernate.cache.use_query_cache}属性值为true（对经常使用的List查询方式，只有在使用查询缓存时，才会从缓存中通过id去get缓存的值；查询缓存一般缓存查询语句和查询结果的id）

A的持久化映射文件中加上cache元素：usage属性的取值根据自己的情况自己指定相应的值

<cache usage="read-write"/>

配置spring的HibernateTemplate对查询语句和结果缓存（cacheQueries值为true)：

<bean id="hibernateTemplate"
        <property name="sessionFactory"><ref bean="sessionFactory"/></property>
    <property name="cacheQueries" value="${hibernate.cache.use_query_cache}"></property>
</bean>
开发的spring dao（集成HibernateDaoSupport）应该配置实用这个hibernateTemplate：

<bean id="myDao" of HibernateDaoSupport">
<property name="hibernateTemplate" ref="hibernateTemplate" />
<property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>

在src下新建ehcache.xml文件，文件内容如下：

<ehcache>
<diskStore path="java.io.tmpdir"/>

<!--
        eternal:元素是否永久的;
        MemoryStoreEvictionPolicy:default is LRU
    -->
<defaultCache         maxElementsInMemory="10000"
            eternal="false"            timeToIdleSeconds="120"            timeToLiveSeconds="120"
            overflowToDisk="true"            diskPersistent="false"           diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"/>

<cache name="cn.hnisi.persistence.mmedia.Dmtjbxx"
               maxElementsInMemory="500"               eternal="false"
               timeToIdleSeconds="2400"      timeToLiveSeconds="3600"
               overflowToDisk="false"/>

<cache name="org.hibernate.cache.StandardQueryCache"
        maxElementsInMemory="50" eternal="false" timeToIdleSeconds="600"
        timeToLiveSeconds="1200" overflowToDisk="false"/>

<cache name="org.hibernate.cache.UpdateTimestampsCache"
        maxElementsInMemory="500" eternal="true" overflowToDisk="false"/>

</ehcache>
然后你可以使用HQL查询对象了，比如"from A where name=？"；

跟踪查询的sql日志就可以看出第一次是查询数据库，第二次是从缓存中get(见Hibernate ReadWriteCache类的get方法）

问题：什么样的数据适合存放到第二级缓存中？

1 很少被修改的数据
2 不是很重要的数据，允许出现偶尔并发的数据
3 不会被并发访问的数据
4 参考数据,指的是供应用参考的常量数据，它的实例数目有限，它的实例会被许多其他类的实例引用，实例极少或者从来不会被修改。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/selley/archive/2008/03/13/2177479.aspx

   缓存是介于应用程序和物理数据源之间，其作用是为了降低应用程序对物理数据源访问的频次，从而提高了应用的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。

　　缓存的介质一般是内存，所以读写速度很快。但如果缓存中存放的数据量非常大时，也会用硬盘作为缓存介质。缓存的实现不仅仅要考虑存储的介质，还要考虑到管理缓存的并发访问和缓存数据的生命周期。

　　Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。SessionFactory的内置缓存和Session的缓存在实现方式上比较相似，前者是SessionFactory对象的一些集合属性包含的数据，后者是指Session的一些集合属性包含的数据。SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，映射元数据是映射文件中数据的拷贝，而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来，SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的拷贝，外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。

　　Hibernate的这两级缓存都位于持久化层，存放的都是数据库数据的拷贝，那么它们之间的区别是什么呢？为了理解二者的区别，需要深入理解持久化层的缓存的两个特性：缓存的范围和缓存的并发访问策略。

　　持久化层的缓存的范围

　　缓存的范围决定了缓存的生命周期以及可以被谁访问。缓存的范围分为三类。

　　1 事务范围：缓存只能被当前事务访问。缓存的生命周期依赖于事务的生命周期，当事务结束时，缓存也就结束生命周期。在此范围下，缓存的介质是内存。事务可以是数据库事务或者应用事务，每个事务都有独自的缓存，缓存内的数据通常采用相互关联的的对象形式。

　　2 进程范围：缓存被进程内的所有事务共享。这些事务有可能是并发访问缓存，因此必须对缓存采取必要的事务隔离机制。缓存的生命周期依赖于进程的生命周期，进程结束时，缓存也就结束了生命周期。进程范围的缓存可能会存放大量的数据，所以存放的介质可以是内存或硬盘。缓存内的数据既可以是相互关联的对象形式也可以是对象的松散数据形式。松散的对象数据形式有点类似于对象的序列化数据，但是对象分解为松散的算法比对象序列化的算法要求更快。

　　3 集群范围：在集群环境中，缓存被一个机器或者多个机器的进程共享。缓存中的数据被复制到集群环境中的每个进程节点，进程间通过远程通信来保证缓存中的数据的一致性，缓存中的数据通常采用对象的松散数据形式。

　　对大多数应用来说，应该慎重地考虑是否需要使用集群范围的缓存，因为访问的速度不一定会比直接访问数据库数据的速度快多少。

　　持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应的数据，还可以到进程范围或集群范围的缓存内查询，如果还是没有查到，那么只有到数据库中查询。事务范围的缓存是持久化层的第一级缓存，通常它是必需的；进程范围或集群范围的缓存是持久化层的第二级缓存，通常是可选的。

　　持久化层的缓存的并发访问策略

　　当多个并发的事务同时访问持久化层的缓存的相同数据时，会引起并发问题，必须采用必要的事务隔离措施。

　　在进程范围或集群范围的缓存，即第二级缓存，会出现并发问题。因此可以设定以下四种类型的并发访问策略，每一种策略对应一种事务隔离级别。

　　事务型：仅仅在受管理环境中适用。它提供了Repeatable Read事务隔离级别。对于经常被读但很少修改的数据，可以采用这种隔离类型，因为它可以防止脏读和不可重复读这类的并发问题。

　　读写型：提供了Read Committed事务隔离级别。仅仅在非集群的环境中适用。对于经常被读但很少修改的数据，可以采用这种隔离类型，因为它可以防止脏读这类的并发问题。

　　非严格读写型：不保证缓存与数据库中数据的一致性。如果存在两个事务同时访问缓存中相同数据的可能，必须为该数据配置一个很短的数据过期时间，从而尽量避免脏读。对于极少被修改，并且允许偶尔脏读的数据，可以采用这种并发访问策略。 　　只读型：对于从来不会修改的数据，如参考数据，可以使用这种并发访问策略。

　　事务型并发访问策略是事务隔离级别最高，只读型的隔离级别最低。事务隔离级别越高，并发性能就越低。

　　什么样的数据适合存放到第二级缓存中？

　　1、很少被修改的数据

　　2、不是很重要的数据，允许出现偶尔并发的数据

　　3、不会被并发访问的数据

　　4、参考数据

　　不适合存放到第二级缓存的数据？

　　1、经常被修改的数据

　　2、财务数据，绝对不允许出现并发

　　3、与其他应用共享的数据。

　　Hibernate的二级缓存

　　如前所述，Hibernate提供了两级缓存，第一级是Session的缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。第一级缓存是必需的，不允许而且事实上也无法比卸除。在第一级缓存中，持久化类的每个实例都具有唯一的OID。

　　第二级缓存是一个可插拔的的缓存插件，它是由SessionFactory负责管理。由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此第二级缓存是进程范围或者集群范围的缓存。这个缓存中存放的对象的松散数据。第二级对象有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。缓存适配器用于把具体的缓存实现软件与Hibernate集成。第二级缓存是可选的，可以在每个类或每个集合的粒度上配置第二级缓存。

　　Hibernate的二级缓存策略的一般过程如下：

　　1) 条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。

　　2) 把获得的所有数据对象根据ID放入到第二级缓存中。

　　3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。

　　4) 删除、更新、增加数据的时候，同时更新缓存。

　　Hibernate的二级缓存策略，是针对于ID查询的缓存策略，对于条件查询则毫无作用。为此，Hibernate提供了针对条件查询的Query缓存。

　　Hibernate的Query缓存策略的过程如下：

　　1) Hibernate首先根据这些信息组成一个Query Key，Query Key包括条件查询的请求一般信息：SQL, SQL需要的参数，记录范围（起始位置rowStart，最大记录个数maxRows)，等。

　　2) Hibernate根据这个Query Key到Query缓存中查找对应的结果列表。如果存在，那么返回这个结果列表；如果不存在，查询数据库，获取结果列表，把整个结果列表根据Query Key放入到Query缓存中。

　　3) Query Key中的SQL涉及到一些表名，如果这些表的任何数据发生修改、删除、增加等操作，这些相关的Query Key都要从缓存中清空。

级联保存和更新
当Hibernate持久化一个临时对象时，在默认情下，他不会自动持久化所关联的其他临时对象，如果希望当持久化对象时把他所关联的所有临时对象进行持久化的话：可以把 的cascade属性设置为"save-update" ,cascade的默认属性值为none。
cascade:设置操作对象时的级联操作，即层级之间的连锁操作
值 save-update ：表示当保存和更新当前对象(即insert和update语句时)，会级联保存和更新与他关联的对象
值 all ：表示任何情况下都会进行级联操作，即对一个对象进行操作，也会对和他关联的其他对象进行同样的操作
值 delete ：表示在执行delete时，进行级联操作，删除和他关联的对象
值 none ：表示任何情况下，都不会进行级联操作
<set>元素的inverse属性

在运行上面的程序时，如果hibernate的"show-sql"设置为true时，就会看到Hibernate会生成很多sql语句，其实很多sql语句都是重复的
eg： 
insert into  test.order(o_name,c_id)values(?,?)
insert into  test.order(o_name,c_id)values(?,?)
insert into  test order   set c_id=? where id=?
insert into  test order   set c_id=? where id=?

为了解决这个问题，我们可以利用在<set>标签中加上inverse属性。术语：inverse是指反转的意思，在 Hibernate中，表示关联关系中的方向关联关系中，inverse="false"的主控方，由主动方负责维护对象关系我们 在customer对象的对象配置文件中加上

<set name="orders"  cascade="save-update" inverse="true">
<key  column="c_id" > </key>
<one-to-many class="net.mbs.mypack.Order " />
</set>

声明在Customer和Order的双向关联关系中，Customer端的关联只是Order端关联的镜象（即Order端是主空端，负责维护 Customer和order对象之间的关联关系），当hibernate探测到持久化对象Customer或Order的状态发生变化时(主要是关联关系的改变),仅按照Order对象的状态的变化来同步更新数据库。
按次配置，如果在程序中，我们仅仅使用Customer.getOrder().add(order)（涉及了和Order的关联关系的改变），是不能让数据库跟对象的变化来进行数据库同步更新的，只有利用Order对象的方法改变的Order对象状态 (eg：order.setCustomer(customer)----涉及到了和Customer的关联关系的改变)时，数据库才会根据变化来同步更新数据库，即只有主控方的状态（涉及到了和另一方面的关联关系的改变）发生了变化后，才会触发对象和数据库的同步更新。

映射一对多双向关联关系
当类与类之间建立了关联，就可以方便的从一个对象导航到另一个对象或一组与他关联的对象当中，根据上面的程序，对于一个给定的Order对象，如果想获取与他关联的Customer对象，我们只需要调用入下方法：
Customer c=order.geCustomer(); 那么当我们得到一个Customer对象后，想查出和这个Customer对象关联的所有Order对象时，应该怎么办呢？由于在Customer中没有建立对Order对象的关联，所以，不能通过加载Customer对象来自动加载和他关联的所有Order对象，唯一的方法只能通过JDBC或SQL语言人工写出代码来查询数据库Order表来返回所需要的信息
上面的问题虽然解决，但不能算是最好，因为这样性能会有所下降，对象位于内存中，在内存中从一个对象导航到另一个对象显然比到数据库中查询数据要快得多

具体实现<br>
1：由于Customer和Order是一对多，即一个Customer要对应多个Order，所以在Customer中应该建立一个Set对象，用于存放和本Customer对象关联的所有Order对象。
2：在customer.hbm.xml通过<one-to-many>建立对Order表的关联关系
注意：<one-to-many>应该放置在<set>标签中 
我们先来看看Customer类的设计和customer.hbm.xml文件的内容
<br><br><br>------------------------------------------------------
Customer Order 双向一对多
1：Customer类中建立一个容器对象，包含关联的所有Order对象
2：Order类中建立一个Customer对象，关联Customer
inverse="true"表示将维护关联的权利交给引起Hibernate语句的生成

customer.getOrders().add(order);
customer.setName("dddddd");

inverse="true"（设置此属性的一方----是被控方）
当主控方修改对象之间的关联关系时，让Hibernate生成sql语句

延迟加载：

   延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载，另外在Hibernate3中还提供了对属性的延迟加载。下面我们就分别介绍这些种类的延迟加载的细节。

A、实体对象的延迟加载：

如果想对实体对象使用延迟加载，必须要在实体的映射配置文件中进行相应的配置，如下所示：

<hibernate-mapping>

<class name=”com.neusoft.entity.User” table=”user” lazy=”true”>

    ……

</class>

</hibernate-mapping>

通过将class的lazy属性设置为true，来开启实体的延迟加载特性。如果我们运行下面的代码：

User user=(User)session.load(User.class,”1”);（1）

System.out.println(user.getName());（2）

当运行到(1)处时，Hibernate并没有发起对数据的查询，如果我们此时通过一些调试工具(比如JBuilder2005的Debug工具)，观察此时user对象的内存快照，我们会惊奇的发现，此时返回的可能是User$EnhancerByCGLIB$$bede8986类型的对象，而且其属性为 null,这是怎么回事？还记得前面我曾讲过session.load()方法，会返回实体对象的代理类对象，这里所返回的对象类型就是User对象的代理类对象。在Hibernate中通过使用CGLIB,来实现动态构造一个目标对象的代理类对象，并且在代理类对象中包含目标对象的所有属性和方法，而且所有属性均被赋值为null。通过调试器显示的内存快照，我们可以看出此时真正的User对象，是包含在代理对象的 CGLIB$CALBACK_0.target属性中，当代码运行到（2）处时，此时调用user.getName()方法，这时通过CGLIB赋予的回调机制，实际上调用CGLIB$CALBACK_0.getName()方法，当调用该方法时，Hibernate会首先检查 CGLIB$CALBACK_0.target属性是否为null，如果不为空，则调用目标对象的getName方法，如果为空，则会发起数据库查询，生成类似这样的SQL语句：select * from user where id=’1’;来查询数据，并构造目标对象，并且将它赋值到CGLIB$CALBACK_0.target属性中。

    这样，通过一个中间代理对象，Hibernate实现了实体的延迟加载，只有当用户真正发起获得实体对象属性的动作时，才真正会发起数据库查询操作。所以实体的延迟加载是用通过中间代理类完成的，所以只有session.load()方法才会利用实体延迟加载，因为只有session.load()方法才会返回实体类的代理类对象。

B、        集合类型的延迟加载：

在Hibernate的延迟加载机制中，针对集合类型的应用，意义是最为重大的，因为这有可能使性能得到大幅度的提高，为此Hibernate进行了大量的努力，其中包括对JDK Collection的独立实现，我们在一对多关联中，定义的用来容纳关联对象的Set集合，并不是java.util.Set类型或其子类型，而是 net.sf.hibernate.collection.Set类型，通过使用自定义集合类的实现，Hibernate实现了集合类型的延迟加载。为了对集合类型使用延迟加载，我们必须如下配置我们的实体类的关于关联的部分：

<hibernate-mapping>

    <class name=”com.neusoft.entity.User” table=”user”>

…..

<set name=”addresses” table=”address” lazy=”true” inverse=”true”>

<key column=”user_id”/>

<one-to-many class=”com.neusoft.entity.Arrderss”/>

</set>

    </class>

</hibernate-mapping>

通过将<set>元素的lazy属性设置为true来开启集合类型的延迟加载特性。我们看下面的代码：

User user=(User)session.load(User.class,”1”);

Collection addset=user.getAddresses();       (1)

Iterator it=addset.iterator();                (2)

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

当程序执行到(1)处时，这时并不会发起对关联数据的查询来加载关联数据，只有运行到(2)处时，真正的数据读取操作才会开始，这时Hibernate会根据缓存中符合条件的数据索引，来查找符合条件的实体对象。

这里我们引入了一个全新的概念——数据索引，下面我们首先将接一下什么是数据索引。在Hibernate中对集合类型进行缓存时，是分两部分进行缓存的，首先缓存集合中所有实体的id列表，然后缓存实体对象，这些实体对象的id列表，就是所谓的数据索引。当查找数据索引时，如果没有找到对应的数据索引，这时就会一条select SQL的执行，获得符合条件的数据，并构造实体对象集合和数据索引，然后返回实体对象的集合，并且将实体对象和数据索引纳入Hibernate的缓存之中。另一方面，如果找到对应的数据索引，则从数据索引中取出id列表，然后根据id在缓存中查找对应的实体，如果找到就从缓存中返回，如果没有找到，在发起select SQL查询。在这里我们看出了另外一个问题，这个问题可能会对性能产生影响，这就是集合类型的缓存策略。如果我们如下配置集合类型：

<hibernate-mapping>

    <class name=”com.neusoft.entity.User” table=”user”>

…..

<set name=”addresses” table=”address” lazy=”true” inverse=”true”>

<cache usage=”read-only”/>

<key column=”user_id”/>

<one-to-many class=”com.neusoft.entity.Arrderss”/>

</set>

    </class>

</hibernate-mapping>

这里我们应用了<cache usage=”read-only”/>配置，如果采用这种策略来配置集合类型，Hibernate将只会对数据索引进行缓存，而不会对集合中的实体对象进行缓存。如上配置我们运行下面的代码：

User user=(User)session.load(User.class,”1”);

Collection addset=user.getAddresses();      

Iterator it=addset.iterator();               

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

System.out.println(“Second query……”);

User user2=(User)session.load(User.class,”1”);

Collection it2=user2.getAddresses();

while(it2.hasNext()){

Address address2=(Address)it2.next();

System.out.println(address2.getAddress());

}

运行这段代码，会得到类似下面的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

Dalian

Second query……

Select * from address where id=’1’;

Select * from address where id=’2’;

Tianjin

Dalian

我们看到，当第二次执行查询时，执行了两条对address表的查询操作，为什么会这样？这是因为当第一次加载实体后，根据集合类型缓存策略的配置，只对集合数据索引进行了缓存，而并没有对集合中的实体对象进行缓存，所以在第二次再次加载实体时，Hibernate找到了对应实体的数据索引，但是根据数据索引，却无法在缓存中找到对应的实体，所以Hibernate根据找到的数据索引发起了两条select SQL的查询操作，这里造成了对性能的浪费，怎样才能避免这种情况呢？我们必须对集合类型中的实体也指定缓存策略，所以我们要如下对集合类型进行配置：

<hibernate-mapping>

    <class name=”com.neusoft.entity.User” table=”user”>

…..

<set name=”addresses” table=”address” lazy=”true” inverse=”true”>

<cache usage=”read-write”/>

<key column=”user_id”/>

<one-to-many class=”com.neusoft.entity.Arrderss”/>

</set>

    </class>

</hibernate-mapping>

此时Hibernate会对集合类型中的实体也进行缓存，如果根据这个配置再次运行上面的代码，将会得到类似如下的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

Dalian

Second query……

Tianjin

Dalian

这时将不会再有根据数据索引进行查询的SQL语句，因为此时可以直接从缓存中获得集合类型中存放的实体对象。

C、       属性延迟加载：

   在Hibernate3中，引入了一种新的特性——属性的延迟加载，这个机制又为获取高性能查询提供了有力的工具。在前面我们讲大数据对象读取时，在 User对象中有一个resume字段，该字段是一个java.sql.Clob类型，包含了用户的简历信息，当我们加载该对象时，我们不得不每一次都要加载这个字段，而不论我们是否真的需要它，而且这种大数据对象的读取本身会带来很大的性能开销。在Hibernate2中，我们只有通过我们前面讲过的面性能的粒度细分，来分解User类，来解决这个问题（请参照那一节的论述），但是在Hibernate3中，我们可以通过属性延迟加载机制，来使我们获得只有当我们真正需要操作这个字段时，才去读取这个字段数据的能力，为此我们必须如下配置我们的实体类：

<hibernate-mapping>

<class name=”com.neusoft.entity.User” table=”user”>

……

<property name=”resume” type=”java.sql.Clob” column=”resume” lazy=”true”/>

    </class>

</hibernate-mapping>

通过对<property>元素的lazy属性设置true来开启属性的延迟加载，在Hibernate3中为了实现属性的延迟加载，使用了类增强器来对实体类的Class文件进行强化处理，通过增强器的增强，将CGLIB的回调机制逻辑，加入实体类，这里我们可以看出属性的延迟加载，还是通过 CGLIB来实现的。CGLIB是Apache的一个开源工程，这个类库可以操纵java类的字节码，根据字节码来动态构造符合要求的类对象。根据上面的配置我们运行下面的代码：

String sql=”from User user where user.name=’zx’ ”;

Query query=session.createQuery(sql);    (1)

List list=query.list();

for(int i=0;i<list.size();i++){

User user=(User)list.get(i);

System.out.println(user.getName());

System.out.println(user.getResume());    (2)

}

当执行到(1)处时，会生成类似如下的SQL语句：

Select id,age,name from user where name=’zx’;

这时Hibernate会检索User实体中所有非延迟加载属性对应的字段数据，当执行到(2)处时，会生成类似如下的SQL语句：

Select resume from user where id=’1’;

这时会发起对resume字段数据真正的读取操作。