它有两种配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具体参看SpringSide)，功能相同，只是一个在web.xml配置，另一个在application.xml配置而已。

    Open Session In View在request把session绑定到当前thread期间一直保持hibernate session在open状态，使session在request的整个期间都可以使用，如在View层里PO也可以lazy loading数据，如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。 

OpenSessionInViewInterceptor配置

<beans>
   <bean name="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
         <property name="sessionFactory">
         <ref bean="sessionFactory"/>
    </property>
   </bean>
   <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
       <property name="interceptors">
         <list>
            <ref bean="openSessionInViewInterceptor"/>
       </list>
     </property>
     <property name="mappings">
     ... 
    </property>
   </bean> ...
</beans> 

OpenSessionInViewFilter配置

<web-app>
 ... 
  <filter>
     <filter-name>hibernateFilter</filter-name>
     <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter </filter-class>
     <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
    <init-param>
       <param-name>singleSession</param-name>
       <param-value>true</param-value>
    </init-param>
  </filter>
 ... 
  <filter-mapping>
     <filter-name>hibernateFilter</filter-name>
     <url-pattern>*.do</url-pattern>
   </filter-mapping>
 ... 
</web-app> 

很多人在使用OpenSessionInView过程中提及一个错误：

org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into FlushMode.AUTO or remove 'readOnly' marker from transaction definition 

看看OpenSessionInViewFilter里的opensession方法

protected Session openSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException ...{
    Session session = SessionFactoryUtils.getSession(sessionFactory, true);
    session.setFlushMode(FlushMode.NEVER);
    return session;
}

    可以看到OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。然后把该sessionFactory绑定到TransactionSynchronizationManager，使request的整个过程都使用同一个session，在请求过后再接除该sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。

    也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有。

采用spring的事务声明,使方法受transaction控制

    <bean id="baseTransaction" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"       abstract="true">
         <property name="transactionManager" ref="transactionManager"/>
         <property name="proxyTargetClass" value="true"/>
         <property name="transactionAttributes">
             <props>
                 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
                 <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
                 <prop key="save*">PROPAGATION_REQUIRED</prop>
                 <prop key="add*">PROPAGATION_REQUIRED</prop>
                 <prop key="update*">PROPAGATION_REQUIRED</prop>
                 <prop key="remove*">PROPAGATION_REQUIRED</prop>
             </props>
         </property>
     </bean>

     <bean id="userService" parent="baseTransaction">
         <property name="target">
             <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>
         </property>
    </bean> 

对于上例，则以save,add,update,remove开头的方法拥有可写的事务，如果当前有某个方法，如命名为importExcel()，则因没有transaction而没有写权限，这时若方法内有insert,update,delete操作的话，则需要手动设置flush model为Flush.AUTO,如

session.setFlushMode(FlushMode.AUTO); 
session.save(user);  
session.flush(); 

     尽管Open Session In View看起来还不错，其实副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal方法代码，这个方法实际上是被父类的doFilter调用的，因此，我们可以大约了解的OpenSessionInViewFilter调用流程: request(请求)->open session并开始transaction->controller->View(Jsp)->结束transaction并close session.

     一切看起来很正确，尤其是在本地开发测试的时候没出现问题，但试想下如果流程中的某一步被阻塞的话，那在这期间connection就一直被占用而不释放。最有可能被阻塞的就是在写Jsp这步，一方面可能是页面内容大，response.write的时间长，另一方面可能是网速慢，服务器与用户间传输时间久。当大量这样的情况出现时，就有连接池连接不足，造成页面假死现象。

Open Session In View是个双刃剑，放在公网上内容多流量大的网站请慎用。

hibernate open session in view 抛出异常解决方法

 在使用open-session-in-view的时候，如果使用不当，有可能抛出两种异常
1，NonUniqueObjectException
2，在配合spring使用的时候会可能会抛出org.springframework.dao.InvalidDataAccessApiUsageException

先说1，这个异常的抛出原因和解决办法见这里：
javaeye上有了很好的事例:http://www.javaeye.com/topic/11581
解决办法可以用merge，也可以别的办法。
出现的原因，可以参考一下我前边的文章中将merge和update的区别的内容。
http://www.blogjava.net/dreamstone/archive/2007/07/29/133071.html

2的解决办法：在这里
springside的一篇文章做了详细说明
http://calvin.blog.javascud.org/post/46.htm

好了，现在问题解决了，但关于open-session-in-view的使用还有一些探讨，是否应该使用，使用的好处与坏处。
见这两篇jdon上的文章:
http://www.jdon.com/jivejdon/thread/22374.html
http://www.jdon.com/jivejdon/thread/28955.html

实体对象的延迟加载:
1.在hibernate配置文件中的class指定

集合类型的延迟加载：
在set中指定lazy=true
这样只有实际加载与对象相关联的集合对象的时候，再通过session从数据库中加载实际的数据集。
Hibernate.initialize方法可以强制Hibernate立即加载关联的对象集，例如：
Hibernate.initialize(user.getAddress());
集合类型的缓存：
如果为某个集合类设定了缓存，如
<set
     name="address"
     table="t_address"
     lazy="true"
     ......
>
     <cache usage="read-only"/>
     <key column="user_id" />
     <one-to-many class="cn.blogjava.TAddress" />
</set>
Hibernate对集合类型进行缓存的时候，分两部分保存。首先是这个集合中所有实体的id列表，其次才是各个实体对象。
这里制定了cache usage="read-only"只会使得Hibernate对数据索引进行缓存。也就是说只缓存了集合中的数据索引，并不包含集合中的各个实体元素。
如果指定cache usage="read-write"才会对集合中的实体进行缓存。

属性的延迟加载：
在property节点中声明lazy=true,而且还需要借助Hibernate类增强器对POJO类的二进制Class文件进行强化处理。

hibernate中的Collection
Hibernate对JDK Collention接口的独立实现：
由于传统的Java Set, Map, List实现不能满足要求，Hibernate根据这些接口提供了自己的实现。
Hibernate的实现：
无序集：Set, Bag, Map
有序集：List
Bag相当于一个允许重复元素存在的Set。
因为Hibernate是自己的Collection实现，所以如下语句会出错，
Set hset = (HashSet)user.getAddresses();
会在运行期报告一个java.lang.ClassCastException,因为实际上返回的是一个类型为org.hibernate.collention.Set的对象。
所有我们在写POJO时，必须用JDK Collection Interface(如Set, Map)，而非特定的JDK Collection实现类(如HashSet, HashMap)声明Collection型属性的原因。例如：
应该是private Set addresses;
而不是private HashSet addresses;

collection类型属性的保存过程。
例如
public class TUser implements Serializable {
private Set addresses = new HashSet();
         ......
}

然后创建一个TUser实例后，就可以为其添加关联的address对象：
TUser user = new TUser();
TAddress addr = new TAddress();
addr.setAddress("HongKong");
user.getAddress().add(addr);
session.save(user);
user对象在经过Hibernate处理后发生了变化，首先，由于insert操作，产生了id值，并填充到user对象的id属性，另一方面Hibernate使用了自己的collection实现对user中的HashSet型addresses属性进行了替换，并用数据对其进行了填充。

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">         
  <property name="dataSource">
   <ref bean="dataSource"/>
  </property>
  <property name="mappingResources">
   <list>
    <value>org/appfteaching/model/TArticleclass.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">${hibernate.dialect}</prop>
          <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
          <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
          <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
          <prop key="hibernate.cache.use_query_cache">true</prop>
          <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
   </props>   
  </property>  
 </bean> 

2.其次,在src目录下的ehcache.xml中配置如下信息(如果是默认ehcache.xml则会有<cache name="sampleCache1">和<cache name="sampleCache2>",去掉)

<cache name="org.hibernate.cache.StandardQueryCache"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="4200"
        overflowToDisk="true"
        />

    <!-- Sample cache named sampleCache2
        This cache contains 1000 elements. Elements will always be held in memory.
        They are not expired. -->

    <cache name="org.hibernate.cache.UpdateTimestampsCache"
        maxElementsInMemory="5000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        />

3.将你要缓存的model加进ehcache.xml里

<cache name="org.appfteaching.model.TArticleclass"
     maxElementsInMemory="1000"
        eternal="false"
        timeToIdleSeconds="100"
        timeToLiveSeconds="4200"
        overflowToDisk="true"
     />  

4.最后一步,在TArticleclass.hbm.xml里加上

<cache usage="read-write"/>

启动Tomcat,如发现如下错误

Could not find configuration [org.hibernate.cache.UpdateTimestampsCache]; using defaults.
Could not find configuration [org.hibernate.cache.StandardQueryCache]; using defaults.

则是第二步没有做,加上即可.配置完毕

org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。

Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.between("weight", minWeight, maxWeight) )
.list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.or(
Restrictions.eq( "age", new Integer(0) ),
Restrictions.isNull("age")
) )
.list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
.add( Restrictions.disjunction()
.add( Restrictions.isNull("age") )
.add( Restrictions.eq("age", new Integer(0) ) )
.add( Restrictions.eq("age", new Integer(1) ) )
.add( Restrictions.eq("age", new Integer(2) ) )
) )
.list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%", Hibernate.STRING) )
.list();

Property age = Property.forName("age");
List cats = sess.createCriteria(Cat.class)
.add( Restrictions.disjunction()
.add( age.isNull() )
.add( age.eq( new Integer(0) ) )
.add( age.eq( new Integer(1) ) )
.add( age.eq( new Integer(2) ) )
) )
.add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )
.list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.addOrder( Order.asc("name") )
.addOrder( Order.desc("age") )
.setMaxResults(50)
.list();

List cats = sess.createCriteria(Cat.class)
.add( Property.forName("name").like("F%") )
.addOrder( Property.forName("name").asc() )
.addOrder( Property.forName("age").desc() )
.setMaxResults(50)
.list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.createCriteria("kittens")
.add( Restrictions.like("name", "F%")
.list();

List cats = sess.createCriteria(Cat.class)
.createAlias("kittens", "kt")
.createAlias("mate", "mt")
.add( Restrictions.eqProperty("kt.name", "mt.name") )
.list();

List cats = sess.createCriteria(Cat.class)
.createCriteria("kittens", "kt")
.add( Restrictions.eq("name", "F%") )
.returnMaps()
.list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
Map map = (Map) iter.next();
Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
Cat kitten = (Cat) map.get("kt");
}

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.setFetchMode("kittens", FetchMode.EAGER)
.list();

Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();

Example example = Example.create(cat)
.excludeZeroes()           //exclude zero valued properties
.excludeProperty("color")  //exclude the property named "color"
.ignoreCase()              //perform case insensitive string comparisons
.enableLike();             //use like for string comparisons
List results = session.createCriteria(Cat.class)
.add(example)
.list();

List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.createCriteria("mate")
.add( Example.create( cat.getMate() ) )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.rowCount() )
.add( Restrictions.eq("color", Color.BLACK) )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount() )
.add( Projections.avg("weight") )
.add( Projections.max("weight") )
.add( Projections.groupProperty("color") )
)
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
.addOrder( Order.asc("colr") )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.groupProperty("color").as("colr") )
.addOrder( Order.asc("colr") )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount(), "catCountByColor" )
.add( Projections.avg("weight"), "avgWeight" )
.add( Projections.max("weight"), "maxWeight" )
.add( Projections.groupProperty("color"), "color" )
)
.addOrder( Order.desc("catCountByColor") )
.addOrder( Order.desc("avgWeight") )
.list();

List results = session.createCriteria(Domestic.class, "cat")
.createAlias("kittens", "kit")
.setProjection( Projections.projectionList()
.add( Projections.property("cat.name"), "catName" )
.add( Projections.property("kit.name"), "kitName" )
)
.addOrder( Order.asc("catName") )
.addOrder( Order.asc("kitName") )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Property.forName("name") )
.add( Property.forName("color").eq(Color.BLACK) )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount().as("catCountByColor") )
.add( Property.forName("weight").avg().as("avgWeight") )
.add( Property.forName("weight").max().as("maxWeight") )
.add( Property.forName("color").group().as("color" )
)
.addOrder( Order.desc("catCountByColor") )
.addOrder( Order.desc("avgWeight") )
.list();

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
.add( Property.forName("sex").eq('F') );
Session session = ....;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
.add( Property.forName("weight).gt(avgWeight) )
.list();

DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
.add( Subqueries.geAll("weight", weights) )
.list();

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
.setProjection( Property.forName("weight").avg() )
.add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
.add( Property.forName("weight).gt(avgWeightForSex) )
.list();

Criteria criteria = session.createCriteria(User.class);

1)criteria.add(Restrictions.gt("age", new Integer(20)));

2)criteria.add(Restrictions.lt("age", new Integer(40)));

3)criteria.add(Restrictions.or(Restrictions.eq("age", new Integer(20)), Restrictions.isNull("age")));

crit.add(Restrictions.ilike("name","1", MatchMode.END));

// // ilike的i即ignore之意,所以这里查询出englishName"Optima?XL?100K?Ultracentrifuge"（忽略大小写）的记录

4)criteria.add(Restrictions.sqlRestriction("{alias}.name LIKE (?)", "cater%", Hibernate.STRING));

5) Integer[] ages = {new Integer(20), new Integer(40)};

Type[] types = {Hibernate.INTEGER, Hibernate.INTEGER};

criteria.add(Restrictions.sqlRestriction("{alias}.age BETWEEN (?) AND (?)", ages, types));

6) criteria.setFirstResult(51);

criteria.setMaxResult(50);

  7) 统计表rowCount()、count()、max()、min()、countDistinct()

criteria.setProjection(Projections.avg("age"));

  8)分组20,20,25,30 à 20.25.30

       criteria.setProjection(Projections.groupProperty("age"));

 9)结合统计分组

   ProjectionList projectionList = Projections.projectionList();

projectionList.add(Projections.groupProperty("age"));

projectionList.add(Projections.rowCount());

Criteria criteria = session.createCriteria(User.class);

criteria.setProjection(projectionList);

10) Query Criteria Id: data type Long

projectionList.add(crit.add( Expression.idEq( 11111L) );

11) Query Criteria Id: Not Equal

 crit.add( Expression.ne( "name", "noName" ) );)

12)crit.setProjection(Projections.rowCount());

13）这是显示不重复记录

criteria.setResultTransformer(criteria.DISTINCT_ROOT_ENTITY);

List users = criteria.list();

Restrictions的幾個常用限定查詢方法如下表所示：

HQL（Hibernate Query Language）

 PS:

 1:HOL是不区分大小写的,但名称是区分大小写的.

     2:如果User類別提供有適當的建構方法，則可以在使用HQL時直接指定新建一個物件傳回

Query query = session.createQuery("select new User(user.name, user.age) from User as user");

    3. 如果試圖使用Session的saveOrupdate()方法，則會新增一筆資料而不是更新原有的資料。

    4. 還可以結合having子句，例如只將平均大於20的資料分組顯示出來：

Query query = session.createQuery("select user.sex, avg(user.age) from User user group by user.sex having avg(user.age) > 20");

   5. 更新与删除的时候

             Session session = sessionFactory.openSession();

Transaction tx= session.beginTransaction();

Query query = session.createQuery("update User set name='momor' where name='bbb'");

query.executeUpdate();

tx.commit();

session.close();

Hibernate:HQL/QBC查询语言比较的用法

Hib的检索方式
1'导航对象图检索方式。通过已经加载的对象，调用.iterator()方法可以得到order对象
如果是首次执行此方法，Hib会从数据库加载关联的order对象，否则就从缓存中得到。
2'OID检索方式。通过session的get，load方法知道了OID的情况下可以使用
3'HQL检索方式。使用面向对象的HQL查询语句session的find方法利用HQL来查询
4'QBC检索方式。利用QBCAPI来检索它是封装了基于字符串的查询语句
5'本地的SQL检索方式。使用本地数据库的SQL查询语句Hib会负责把检索到的JDBC结果集映射为持久化对象图。

五种检索方式的使用场合和特点：

HQL ： 是面向对象的查询语言，同SQL有些相似是Hib中最常用的方式。
       查询设定各种查询条件。
       支持投影查询，检索出对象的部分属性。
       支持分页查询，允许使用having和group by
       提供内制的聚集函数，sum()，min()，max()
       能调用用户的自定义SQL
       支持子查询，嵌入式查询
       支持动态绑定参数
建议使用Query接口替换session的find方法。
   Query Q = session.createQuery("from customer as c where c.name = :customerName" + "and c.age = :customerAge");
   query.setString ("customerName" , "tom");
   query.setInteger("customerAge" , "21");
   list result = query.list();
QBC :  QBCAPI提供了另一种方式，主要是Criteria接口、Criterion接口和Expression类
   Criteria criteria = session.createCriteria(customer.class);
   Criterion criterion1 = Expression.like("name","t%");
   Criterion criterion2 = Expression.eq("age",new Integer(21));
   Critera = criteria.add(criterion1) ;
   Critera = criteria.add(criterion2) ;
   list result = criteria.list(); 
   或是： list result = session.createCriteria(Customer.class).add(Expression.eq("this.name","tom")).list(); 
SQL :  采用HQL和QBC检索时，Hib生成SQL语句适用所有数据库。
   Query query  = session.createSQLQuery("select {c.*} from customers c where c.name like : customername " + "and c.age = :customerage","c",customer.calss);
   query.setString("customername","tom");
   query.setInteger("customerage","21");
   list result = query.list();
/////////////多态查询
   HQL ：session.createQuery("from employee");
   QBC ：session.createCriteria(employee.class);
   HQL : session.createQuery("from hourlyEmployee");
   QBC : session.createCriteria(hourlyEmployee.class);
   下面的HQL查询语句将检索出所有的持久化对象：
   from java.lang.Object ;
   from java.io.serializable ;
////////////查询的排序
   1'查询结果按照客户姓名升序排列：
   HQL ：
        Query query = session.createQuery ("from customer c order by c.name");
   QBC ：
        Criteria criteria = session.createCriteria(customer.class);
        criteria.addOrder(order.asc("name"));
   HQL :
        Query query = session.createQuery ("from customer c order by c.name asc , c.age desc");
   QBC :
        Criteria criteria = session.createCriteria(customer.class);
        criteria.addOrder(order.asc ("name"));
        criteria.addOrder(order.desc("age")); 

        import net.sf.hibernate.pression.Order
        import mypack.Order
        ...........
        Criteria criteria = session.createCritria (mypack.Order.class);
        criteria.addOrder(net.sf.hibernate.Order.asc("name"));
///////////HQL语句的参数绑定Query接口提供了绑定各种Hib映射类型的方法。
        setBinary()
        setString()
        setBoolean()
        setByte()
        setCalendar()
        setCharacter()
        setDate()
        setDouble()
        setText()
        setTime()
        setTimestamp()
        setEntity()//把参数与一个持久化类的事例绑定lsit result = session.createQuery("from order o where o.customer =            :customer").setEntity("customer" , customer).list ;
        setParameter()//绑定任意类型的参数
        setProperties()//把命名参数与一个对象的属性值绑定 Query query = session.createQuery("from customer c where c.name =:     name " + "and c.age =:age" );
        Query.setProperties(customer); 

多对一情况  
DetachedCriteria  zlbdc=DetachedCriteria.forClass(ZlZlxm.class, "zlb");
                     //  .createAlias("zlb.zl", "t")
                        // .setProjection(Property.forName("t.id").count())
                       //.add(Property.forName("t.id").eq(new  Long(1)))
                       org.hibernate.criterion.Projection projection=org.hibernate.criterion.Projections.projectionList()
                                   .add(org.hibernate.criterion.Property.forName("zlb.fdxx"),"id");
                       zlbdc.setProjection(projection);
                                     //zlbdc.createCriteria("zl");//加上这句是内联接(inner join)zl为集合
投影查询，得到一是object[]

  DetachedCriteria  zlbdc=DetachedCriteria.forClass(ZlZlxm.class, "zlb")
  //zlbdc.createCriteria("zl"); //此处为对象
                       .createAlias("zlb.zl", "t") //别名
                       .setProjection(Property.forName("t.id").count())
                       .add(Property.forName("t.id").eq(new  Long(1))); //这里统计的是个数内联接(inner join)
         //zladc.setFetchMode("zla.zlZlxm", org.hibernate.FetchMode.JOIN);//无作用(集合lazy)？？？，如果not lazy将会是全部查出

Criteria Query通过面向对象化的设计，将数据查询条件封装为一个对象。简单来

讲，Criteria Query可以看作是传统SQL的对象化表示，如：

Criteria criteria = session.createCriteria(User.class);

criteria.add(Expression.eq("name","Erica"));

criteria.add(Expression.eq("sex",new Integer(1)));

这里的criteria 实例实际上是SQL “Select * from t_user where

name=’Erica’ and sex=1”的封装（我们可以打开Hibernate 的show_sql 选项，

以观察Hibernate在运行期生成的SQL语句）。

Hibernate 在运行期会根据Criteria 中指定的查询条件（也就是上面代码中通过

criteria.add方法添加的查询表达式）生成相应的SQL语句。

这种方式的特点是比较符合Java 程序员的编码习惯，并且具备清晰的可读性。正因

为此，不少ORM实现中都提供了类似的实现机制（如Apache OJB）。

对于Hibernate的初学者，特别是对SQL了解有限的程序员而言，Criteria Query

无疑是上手的极佳途径，相对HQL，Criteria Query提供了更易于理解的查询手段，借

助IDE的Coding Assist机制，Criteria的使用几乎不用太多的学习。

Criteria 查询表达式

Criteria 本身只是一个查询容器，具体的查询条件需要通过Criteria.add

方法添加到Criteria实例中。

如前例所示，Expression 对象具体描述了查询条件。针对SQL 语法，

Expression提供了对应的查询限定机制，包括：

方法 描述

Expression.eq 对应SQL“field = value”表达式。

如Expression.eq("name","Erica")

Expression.allEq 参数为一个Map对象，其中包含了多个属性－值对

应关系。相当于多个Expression.eq关系的叠加。

Expression.gt 对应SQL中的 “field > value ” 表达式

Hibernate Developer’s Guide Version 1.0

September 2, 2004 So many open source projects. Why not Open your Documents?

Expression.ge 对应SQL中的 “field >= value” 表达式

Expression.lt 对应SQL中的 “field < value” 表达式

Expression.le 对应SQL中的 “field <= value” 表达式

Expression.between 对应SQL中的 “between” 表达式

如下面的表达式表示年龄（age）位于13到50区

间内。

Expression.between("age",new

Integer(13),new Integer(50));

表达式

Expression.in 对应SQL中的 ”field in …” 表达式

Expression.eqProperty 用于比较两个属性之间的值，对应SQL中的“field

= field”。

如：

Expression.eqProperty(

"TUser.groupID",

"TGroup.id"

);

Expression.gtProperty 用于比较两个属性之间的值，对应SQL中的“field

> field”。

Expression.geProperty 用于比较两个属性之间的值，对应SQL中的“field

>= field”。

Expression.ltProperty 用于比较两个属性之间的值，对应SQL中的“field

< field”。

Expression.leProperty 用于比较两个属性之间的值，对应SQL中的“field

<= field”。

Expression.and and关系组合。

如：

Expression.and(

Expression.eq("name","Erica"),

Expression.eq(

"sex",

new Integer(1)

)

);

Expression.or or关系组合。

如：

Hibernate Developer’s Guide Version 1.0

September 2, 2004 So many open source projects. Why not Open your Documents?

Expression.or(

Expression.eq("name","Erica"),

Expression.eq("name","Emma")

);

Expression.sql 作为补充，本方法提供了原生SQL语法的支持。我

们可以通过这个方法直接通过SQL语句限定查询

条件。

下面的代码返回所有名称以“Erica”起始的记录：

Expression.sql(

“lower({alias}.name) like lower(?)”,

"Erica%",

Hibernate.STRING

);

其中的“{alias}”将由Hibernate在运行期使

用当前关联的POJO别名替换。

注意Expression 各方法中的属性名参数（如Express.eq中的第一个参数），这里

所谓属性名是POJO中对应实际库表字段的属性名（大小写敏感），而非库表中的实

际字段名称。

Criteria 高级特性

限定返回的记录范围

通过criteria. setFirstResult/setMaxResults 方法可以限制一次查询返回

的记录范围:

Criteria criteria = session.createCriteria(TUser.class);

//限定查询返回检索结果中，从第一百条结果开始的20条记录

criteria.setFirstResult(100);

criteria.setMaxResults(20);

对查询结果进行排序

//查询所有groupId=2的记录

//并分别按照姓名(顺序)和groupId（逆序）排序

Criteria criteria = session.createCriteria(TUser.class);

criteria.add(Expression.eq("groupId",new Integer(2)));

criteria.addOrder(Order.asc("name"));

Hibernate Developer’s Guide Version 1.0

September 2, 2004 So many open source projects. Why not Open your Documents?

criteria.addOrder(Order.desc("groupId"));

Criteria作为一种对象化的查询封装模式，不过由于Hibernate在实现过程中将精力

更加集中在HQL查询语言上，因此Criteria的功能实现还没做到尽善尽美（这点上，OJB

的Criteria 实现倒是值得借鉴），因此，在实际开发中，建议还是采用Hibernate 官

方推荐的查询封装模式：HQL。

       如图 1 。 hibernate 设计了 criteriaspecification 作为 criteria 的顶级接口，其下面提供了 criteria 和 detachedcriteria 。

criteria 和 detachedcriteria 的主要区别在于创建的形式不一样， criteria 是在线的，所以它是由 hibernate session 进行创建的；而 detachedcriteria 是离线的，创建时无需 session ， detachedcriteria 提供了 4 个静态方法 forclass(class) 或 forentityname(name) 进行 detachedcriteria 实例的创建。 spring 的框架提供了

gethibernatetemplate().findbycriteria(detachedcriteria) 方法可以很方便地根据

detachedcriteria 来返回查询结果。

如图 1 ， criteria 和 detachedcriteria 均可使用 criterion 和 projection 设置查询条件。可以设置 fetchmode( 联合查询抓取的模式 ) ，设置排序方式。对于 criteria 还可以设置 flushmodel （冲刷 session 的方式）和 lockmode （数据库锁模式）。

下面就对 criterion 和 projection 进行详细说明。

图 1

       criterion 是 criteria 的查询条件。

criteria 提供了 add(criterion criterion) 方法来添加查询条件。图 2 是 criterion 的结构图。 criterion 接口的主要实现包括： example 、 junction 和 simpleexpression 。而 junction 的实际使用是它的两个子类 conjunction 和 disjunction ，分别是使用 and 和 or 操作符进行来联结查询条件集合。

criterion 的实例可以通过 restrictions 工具类来创建， restrictions 提供了大量的静态方法，如 eq （等于）、 ge （大于等于）、 between 等来方法的创建 criterion 查询条件

（ simpleexpression 实例）。除此之外， restrictions 还提供了方法来创建 conjunction 和 disjunction 实例，通过往该实例的 add(criteria) 方法来增加查询条件形成一个查询条件集合。

至于 example 的创建有所不同， example 本身提供了一个静态方法 create(object entity) ，即根据一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设置一些过滤条件：

example exampleuser =example.create(u)

.ignorecase() // 忽略大小写

.enablelike(matchmode.anywhere);

// 对 string 类型的属性，无论在那里值在那里都匹配。相当于 %value%

图 2

project 主要是让 criteria 能够进行报表查询，并可以实现分组。 project 主要有 simpleprojection 、 projectionlist 和 property 三个实现。其中 simpleprojection 和 projectionlist 的实例化是由内建的 projections 来完成，如提供的 avg 、 count 、 max 、 min 、 sum 可以让开发者很容易对某个字段进行统计查询。

       property 是对某个字段进行查询条件的设置，如通过

      porperty.forname(“color”).in(new string[]{“black”,”red”,”write”}); 则可以创建一个 project 实例。通过 criteria 的 add(project) 方法加入到查询条件中去。

图 3

       使用 criteria 进行查询，主要要清晰的是 hibernate 提供了那些类和方法来满足开发中查询条件的创建和组装，其结构层次如何。这样使用起来便可得心应手。

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

/**
 * Configures and provides access to Hibernate sessions, tied to the
 * current thread of execution.  Follows the Thread Local Session
 * pattern, see {@linkhttp://hibernate.org/42.html}.
 */
public class HibernateSessionFactory{

    /**
     * Location of hibernate.cfg.xml file.
     * NOTICE: Location should be on the classpath as Hibernate uses
     * #resourceAsStream style lookup for its configuration file. That
     * is place the config file in a Java package - the default location
     * is the default Java package.<br><br>
     * Examples: <br>
     * <code>CONFIG_FILE_LOCATION = "/hibernate.conf.xml".
     * CONFIG_FILE_LOCATION = "/com/foo/bar/myhiberstuff.conf.xml".</code>
     */
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";

    /** Holds a single instance of Session */
 private static final ThreadLocal threadLocal = new ThreadLocal();

    /** The single instance of hibernate configuration */
    private static final Configuration cfg = new Configuration();

    /** The single instance of hibernate SessionFactory */
    private static org.hibernate.SessionFactory sessionFactory;

    /**
     * Returns the ThreadLocal Session instance.  Lazy initialize
     * the <code>SessionFactory</code> if needed.
     *
     *  @return Session
     *  @throws HibernateException
     */
    public static Session currentSession() throws HibernateException {
        Session session = (Session) threadLocal.get();

  if (session == null || !session.isOpen()) {
   if (sessionFactory == null) {
    try {
     cfg.configure(CONFIG_FILE_LOCATION);
     sessionFactory = cfg.buildSessionFactory();
    } catch (Exception e) {
     System.err
       .println("%%%% Error Creating SessionFactory %%%%");
     e.printStackTrace();
    }
   }
   session = (sessionFactory != null) ? sessionFactory.openSession()
     : null;
   threadLocal.set(session);
  }

        return session;
    }

    /**
     *  Close the single hibernate session instance.
     *
     *  @throws HibernateException
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);

        if (session != null) {
            session.close();
        }
    }

    /**
     * Default constructor.
     */
    private HibernateSession() {
    }

}
(3).自动在classes下产生hibernate.cfg.xml配置文件
<?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="connection.username">root</property>
  <property name="connection.url">jdbc:mysql://localhost:3306/test?useUnicode=true;characterEncoding=gbk</property>
  <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
  <property name="myeclipse.connection.profile">MySqlDB</property>
  <property name="connection.password">1234</property>
  <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
  <mapping resource="com/semovy/business/pojo/Employee.hbm.xml" /><!--对应对象映射文件资源-->.

 </session-factory>

</hibernate-configuration>
三、打开MyEclipse的DB Browser选择Employee右击creating hibernate mapping,设置持久类路径好之后。
便自动产生Employee持久类，与同一目录下的Employee.hbm.xml两个文件

1).
package com.semovy.business.pojo;

/**
 * Employee generated by MyEclipse - Hibernate Tools
 */

public class Employee  implements java.io.Serializable {

    // Fields   

     /**
  *
  */
 private static final long serialVersionUID = 1L;
 private Integer id;
     private String name;

    // Constructors

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

 /** minimal constructor */
    public Employee(Integer id) {
        this.id = id;
    }
   
    /** full constructor */
    public Employee(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    // Property accessors

    public Integer getId() {
        return this.id;
    }
   
    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }
   
    public void setName(String name) {
        this.name = name;
    }
}

2).Employee.hbm.xml文件

<?xml version="1.0"?>
<!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 - Hibernate Tools
-->
<hibernate-mapping>
    <class name="com.semovy.business.pojo.Employee" table="employee" ><!---一定弃掉catalog属性，我是卡在这里好久，运行有异常-->
        <id name="id" type="integer">
            <column name="id" />
            <generator class="identity" />
        </id>
        <property name="name" type="string">
            <column name="name" length="50" />
        </property>
    </class>
</hibernate-mapping>

四，建立Employee持久化类的业务逻辑：
package com.semovy.business.service;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.semovy.framework.base.HibernateSession;
/**
 * this class supply all type of busniss service method for Employees
 * @author Semovy
 * @since 2006-11-08
 * @version 1.0
 */
public class EmployeeService {
 Session session = null;
 public EmployeeService(){}
 public List findAllEmployees()
 {
  List employees = new ArrayList();
  try
  {
   session = HibernateSession.currentSession();
   Transaction tx = session.beginTransaction();
   employees = session.createQuery("from Employee").list();
   tx.commit();
   return employees;
  }
  catch(Exception ex)
  {
   ex.printStackTrace();
   return null;
  }
  finally
  {
   HibernateSession.closeSession();
  }
 }
}
五，建立jsp页面listEmployees.jsp来调用测试hibernate.

<%@ page language="java" import="java.util.*,
com.semovy.business.pojo.Employee,com.semovy.business.service.EmployeeService"
pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
   
    <title>My JSP 'listEmployees.jsp' starting page</title>
   
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
   
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>
 
  <body>
    This is my JSP page.<br>
    <%
 
    EmployeeService es = new EmployeeService();
    List l = es.findAllEmployees();
    if(l != null)
    {
     Iterator it = l.iterator();
     while(it.hasNext())
     {
      Employee em = (Employee)it.next();
      out.print("ID: " + em.getId() + "Name: " + em.getName()+"<br>");
      
     } 
    }
    %>
  </body>
</html>
六、发布应用