Hibernate中Criteria的完整用法

1，Criteria 
Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口，下面提供了 Criteria和DetachedCriteria 。 

2，DetachedCriteria 
Spring 的框架提供了getHibernateTemplate().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结果。 

DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name) 进行DetachedCriteria 实例的创建。 

3，Criteria 和 DetachedCriteria 
Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，是由Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需Session。
Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设置FetchMode( 联合查询抓取的模式 ) ，设置排序方式。对于 Criteria 还可以设置 FlushModel 
（冲刷 Session 的方式）和 LockMode （数据库锁模式）。 
下面对 Criterion 和 Projection 进行详细说明。 

4，Criterion 和 Projection 
a,概念
Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来添加查询条件。 
Criterion 接口的主要实现包括： Example 、 Junction 和 SimpleExpression 。
Junction 的实际使用是它的两个子类 conjunction 和 disjunction ，分别是使用 AND 和 OR 操作符进行来联结查询条件集合。 
b,创建
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% 

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) 方法加入到查询条件中去。 

5，应用
使用 Criteria 进行查询，主要要清晰的是 Hibernate 提供了那些类和方法来满足开发中查 
询条件的创建和组装，下面介绍几种用法： 
1. 创建一个Criteria 实例 
org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。 
Criteria crit = sess.createCriteria(Cat.class); 
crit.setMaxResults(50); 
List cats = crit.list(); 

2. 限制结果集内容 
一个单独的查询条件是org.hibernate.criterion.Criterion 接口的一个实例。 

org.hibernate.criterion.Restrictions类 定义了获得某些内置Criterion类型的工厂方法。 
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(); 

Hibernate提供了相当多的内置criterion类型(Restrictions 子类), 但是尤其有用的是可以允许 

你直接使用SQL。 

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

{alias}占位符应当被替换为被查询实体的列别名。 
Property实例是获得一个条件的另外一种途径。你可以通过调用Property.forName() 创建一个Property。 

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(); 

3. 结果集排序 
你可以使用org.hibernate.criterion.Order来为查询结果排序。 

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(); 

4. 关联 
你可以使用createCriteria()非常容易的在互相关联的实体间建立 约束。 

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

注意第二个 createCriteria()返回一个新的 Criteria实例，该实例引用kittens 集合中的元素。 
接下来，替换形态在某些情况下也是很有用的。 

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

(createAlias()并不创建一个新的 Criteria实例。) 
Cat实例所保存的之前两次查询所返回的kittens集合是 没有被条件预过滤的。如果你希望只获得 

符合条件的kittens， 你必须使用returnMaps()。 

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"); 
} 

5. 动态关联抓取 
你可以使用setFetchMode()在运行时定义动态关联抓取的语义。 

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

这个查询可以通过外连接抓取mate和kittens。 

6. 查询示例 
org.hibernate.criterion.Example类允许你通过一个给定实例 构建一个条件查询。 

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


版本属性、标识符和关联被忽略。默认情况下值为null的属性将被排除。 
可以自行调整Example使之更实用。 

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(); 

甚至可以使用examples在关联对象上放置条件。 

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

7. 投影(Projections)、聚合（aggregation）和分组（grouping） 
org.hibernate.criterion.Projections是 Projection 的实例工厂。我们通过调用setProjection()应用投影到一个查询。 

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(); 

在一个条件查询中没有必要显式的使用 "group by" 。某些投影类型就是被定义为 分组投影，他们也出现在SQL的group by子句中。
可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的实现方式： 

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(); 

alias()和as()方法简便的将一个投影实例包装到另外一个 别名的Projection实例中。简而言之，当你添加一个投影到一个投影列表中时 你可以为它指定一个别名： 

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(); 

也可以使用Property.forName()来表示投影： 

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(); 

8. 离线(detached)查询和子查询 
DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session执行它。 

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

DetachedCriteria也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者 
Property获得。 

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.add(Expression.eq("status",new Integer(status))); 
criteria.add(Expression.in("status", optParm.getQueryStatus()));

实例解析：

当查询数据时，人们往往需要设置查询条件。在SQL或HQL语句中，查询条件常常放在where子句中。此外，Hibernate还支持Criteria查询（Criteria Query），这种查询方式把查询条件封装为一个Criteria对象。在实际应用中，使用Session的createCriteria()方法构建一个org.hibernate.Criteria实例，然后把具体的查询条件通过Criteria的add()方法加入到Criteria实例中。这样，程序员可以不使用SQL甚至HQL的情况下进行数据查询，如例程9-1所示。

例程9-1  Criteria应用实例  

Criteria cr = session.createCriteria(Student.class); //生成一个Criteria对象
cr.add(Restrictions.eq("name", "Bill"));//等价于where name=’Bill’
List list = cr.list();
Student stu = (Student)list.get(0);
System.out.println(stu.getName());

1．常用的查询限制方法

在例程9-1中，Restrictions.eq()方法表示equal，即等于的情况。Restrictions类提供了查询限制机制。它提供了许多方法，以实现查询限制。这些方法及其他一些criteria常用查询限制方法列于表9-1中。

表9-1  Criteria Query常用的查询限制方法

方    法	说    明
Restrictions.eq()	equal，=
Restrictions.allEq()	参数为Map对象，使用key/value进行多个等于的对比，相当于多个Restrictions.eq()的效果
Restrictions.gt()	greater-than, >
Restrictions.lt()	less-than, <
Restrictions.le()	less-equal, <=
Restrictions.between()	对应SQL的between子句
Restrictions.like()	对应SQL的like子句
Restrictions.in()	对应SQL的in子句
Restrictions.and()	and关系
Restrictions.or()	or关系
Restrictions.isNull()	判断属性是否为空，为空返回true，否则返回false
Restrictions.isNotNull()	与Restrictions.isNull()相反
Order.asc()	根据传入的字段进行升序排序
Order.desc()	根据传入的字段进行降序排序
MatchMode.EXACT	字符串精确匹配，相当于“like 'value'”
MatchMode.ANYWHERE	字符串在中间位置，相当于“like '%value%'”
MatchMode.START	字符串在最前面的位置，相当于“like 'value%'”
MatchMode.END	字符串在最后面的位置，相当于“like '%value'”

例1：查询学生名字以t开头的所有Student对象。

 Criteria cr = session.createCriteria(Student.class);
cr.add(Restrictions.like(“name”, “t%”))
List list = cr.list();
Student stu = (Student)list.get(0);

或者使用另一种方式：

 Criteria cr = session.createCriteria(Student.class);
cr.add(Restrictions.like(“name”, “t”, MatchMode.START))
List list = cr.list();
Student stu = (Student)list.get(0);

例2：查询学生姓名在Bill, Jack和Tom之间的所有Student对象。

 String[] names = {“Bill”, “Jack”, “Tom”}
Criteria cr = session.createCriteria(Student.class);
cr.add(Restrictions.in(“name”, names))
List list = cr.list();
Student stu = (Student)list.get(0);

例3：查询学生的年龄age等于22或age为空（null）的所有Student对象。

Criteria cr = session.createCriteria(Student.class);
cr.add(Restrictions.eq(“age”, new Integer(22));
cr.add(Restrictions.isNull(“age”));
List list = cr.list();
Student stu = (Student)list.get(0);

例4：查询学生姓名以字母F开头的所有Student对象，并按姓名升序排序。

Criteria cr = session.createCriteria(Student.class);
cr.add(Restrictions.like(“name”, “F%”);
cr.addOrder(Order.asc(“name”));
List list = cr.list();
Student stu = (Student)list.get(0);

调用Order.asc的方法应是Criteria的addOrder()方法。

使用add()方法加入条件时，预设是使用and来组合条件，如果要用or的方式来组合条件，则可以使用Restrictions.or()方法，例如结合age等于（eq）20或（or）age为空（isNull）的条件：

Criteria criteria = session.createCriteria(User.class);  
criteria.add(Restrictions.or(  
                   Restrictions.eq("age", new Integer(20)),  
                   Restrictions.isNull("age")  
               ));  
List users = criteria.list();  

观察所产生的SQL语句，将使用where与or子句完成SQL的条件查询：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where (this_.age=? or this_.age is null)

使用Criteria进行查询时，不仅仅能组合出SQL中where子句的功能，还可以组合出如排序、统计、分组等的查询功能。这就是Criteria进阶查询。

排序 
您可以使用Criteria进行查询，并使用org.hibernate.criterion.Order对结果进行排序，例如使用Oder.asc()，指定根据”age”由小到大排序（反之则使用desc()）：

Criteria criteria = session.createCriteria(User.class);  
criteria.addOrder(Order.asc("age"));  
List users = criteria.list(); 

 

注意在加入Order条件时，使用的是addOrder()方法，而不是add()方法，在产生SQL语句时，会使用order by与asc（desc）来进行排序指定：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ order by this_.age asc

限定查询笔数 
Criteria的setMaxResults()方法可以限定查询回来的笔数，如果配合setFirstResult()设定传回查询结果第一笔资料的位置，就可以实现简单的分页，例如传回第51笔之后的50笔资料（如果有的话）：

Criteria criteria = session.createCriteria(User.class);  
criteria.setFirstResult(51);  
criteria.setMaxResults(50);  
List users = criteria.list(); 

根据您所指定得资料库，Hibernate将自动产生与资料库相依的限定笔数查询子句，例如在MySQL中，将使用limit产生以下的SQL语句：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ limit ?, ?

统计动作 
您可以对查询结果进行统计动作，使用 org.hibernate.criterion.Projections的avg()、rowCount()、count()、max()、min ()、 countDistinct()等方法，再搭配Criteria的setProjection()方法加入条件设定，例如对查询结果的"age"作平均：

Criteria criteria = session.createCriteria(User.class);  
criteria.setProjection(Projections.avg("age"));  
List users = criteria.list(); 

 

上面的程式将由Hibernate自动产生SQL的avg函数进行平均计算：

Hibernate: select avg(this_.age) as y0_ from T_USER this_

分组 
还可以配合Projections的groupProperty()来对结果进行分组，例如以"age"进行分组，也就是如果资料中"age"如果有 20、20、25、30，则以下会显示20、25、30：

Criteria criteria = session.createCriteria(User.class);  
criteria.setProjection(Projections.groupProperty("age"));  
List users = criteria.list();

上面的程式将由Hibernate自动产生SQL的group by子句进行分组计算：

Hibernate: select this_.age as y0_ from T_USER this_ group by this_.age

如果想同时结合统计与分组功能，则可以使用org.hibernate.criterion.ProjectionList，例如下面的程式会计算每个年龄各有多少个人：

ProjectionList projectionList = Projections.projectionList();  
projectionList.add(Projections.groupProperty("age"));  
projectionList.add(Projections.rowCount());  

Criteria criteria = session.createCriteria(User.class);  
criteria.setProjection(projectionList);  
List users = criteria.list();  

观察所产生的SQL语句，将使用group by先进行分组，再针对每个分组进行count函数的计数，

Hibernate: select this_.age as y0_, count(*) as y1_ from T_USER this_ group by this_.age

根据已知物件进行查询 
设定查询条件并非一定要使用Restrictions，如果属性条件很多，使用Restrictions也不方便，如果有一个已知的物件，则可以根据这个物件作为查询的依据，看看是否有属性与之类似的物件，例如：

User user = new User();  
user.setAge(new Integer(30));  
Criteria criteria = session.createCriteria(User.class);  
criteria.add(Example.create(user));   
List users = criteria.list();  

 

Criteria进阶查询中，您可以透过 org.hibernate.criterion.Example的create()方法来建立Example实例，Example实作了 Criteria介面，因此可以使用add()方法加入至Criteria条件设定之中，Hibernate将自动过滤掉空属性，根据已知物件上已设定的属性，判定是否产生于where子句之中：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where (this_.age=?)

设定SQL范本 
如果您了解如何撰写SQL语句，想要设定一些Hibernate产生SQL时的范本，您也可以使用Restrictions的sqlRestriction()方法，提供SQL语法范本作限定查询，例如查询name以cater开头的资料：

Criteria criteria = session.createCriteria(User.class);  
criteria.add(Restrictions.sqlRestriction(  
"{alias}.name LIKE (?)", "cater%", Hibernate.STRING));  
List users = criteria.list(); 

其中alias将被替换为与User类别相关的名称，而? 将被替换为cater%，也就是第二个参数所提供的值，sqlRestriction()方法第一个参数所设定的是where子句的部份，所以在SQL撰写时，不必再写where，观察所产生的SQL语句，将使用您所设定的SQL范本作为基础，来完成SQL的条件查询：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.name LIKE (?)

如果有多个查询条件，例如between子句的查询，则可以如下：

Criteria criteria = session.createCriteria(User.class);  
Integer[] ages = {new Integer(20), new Integer(40)};  
Type[] types = {Hibernate.INTEGER, Hibernate.INTEGER};  
criteria.add(Restrictions.sqlRestriction(  
"{alias}.age BETWEEN (?) AND (?)", ages, types));  
List users = criteria.list(); 

观察所产生的SQL语句如下：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.age BETWEEN (?) AND (? 

2．连接限制

在Criteria 查询中使用FetchMode来实现连接限制。在HQL语句中，可以通过fetch关键字来表示预先抓取（Eager fetching），如下所示：

 from Group g
left join fetch g.students s
where g.name like '%2005'

可以使用Criteria的API完成同样的功能，如下所示：

Criteria cr = session.createCriteria(Group.class);
cr.setFetchMode(“students”, FetchMode.EAGER);
cr.add(Restrictions.like(“name”, “2005”, MatchMode.END))
List list = cr.list();

以上两种方式编写的代码，都使用相同的SQL语句完成它们的功能，如下所示：

select g.*, s.* from Group g
left outer join Student s
on g.id = s.group_id
where g.name like '%2005'