Hibernate Criteria用法大全

1.标准查询简介

2.比较运算符

3.分页使用标准

4.排序结果

5.预测与聚合

6.关联

7. 动态关联抓取

8.查询示例

9.投影(Projections)、聚合（aggregation）和分组（grouping）

10. 离线(detached)查询和子查询

 

1.标准查询简介（QBC：Query By Criteria）

Hibernate 提供了操纵对象和相应的 RDBMS 表中可用的数据的替代方法。一种方法是标准的 API，它允许你建立一个标准的可编程查询对象来应用过滤规则和逻辑条件。

Hibernate Session 接口提供了 createCriteria() 方法，可用于创建一个 Criteria 对象，使当您的应用程序执行一个标准查询时返回一个持久化对象的类的实例。

以下是一个最简单的标准查询的例子

Criteria cr = session.createCriteria(Employee.class);  
List results = cr.list();  

QBC (Query By Criteria) 主要有Criteria,Criterion,Oder,Restrictions类组成

@Override
    public List<Role> getAllRoles() {
        // TODO Auto-generated method stub
        
        List<Role> roles = null;        
        Session session =sessionFactory.getCurrentSession();
        
        Criteria criteria = session.createCriteria(Role.class);        
        Criterion criterion = Restrictions.eq("roleServer", "一梦十年");
        criteria.add(criterion);        
        roles = criteria.list();    
        
        return roles;
    }

2.比较运算符

= 　　Restrictions.eq() 等于
<> 　 Restrictions.not(Exprission.eq()) 不等于
> 　　Restrictions.gt() 大于
>= 　 Restrictions.ge() 大于等于
< 　　Restrictions.lt() 小于
<= 　　Restrictions.le() 小于等于
is null 　　Restrictions.isnull() 等于空值
is not null 　　Restrictions.isNotNull() 非空值
like 　　Restrictions.like() 字符串模式匹配
and 　　Restrictions.and() 逻辑与
and 　　Restrictions.conjunction() 逻辑与 
or 　　Restrictions.or() 逻辑或
or 　　Restrictions.disjunction() 逻辑或
not 　　Restrictions.not() 逻辑非
in(列表) 　　Restrictions.in() 等于列表中的某一个值
ont in(列表) 　　Restrictions.not(Restrictions.in())不等于列表中任意一个值
between x and y 　　Restrictions.between() 闭区间xy中的任意值
not between x and y 　　Restrictions.not(Restrictions..between()) 小于值X或者大于值y

 使用逻辑表达式创建 in 的条件组合

  cri.add(Restrictions.in("chcStatus", new Object[]{"2","3","4"})); 

使用逻辑表达式创建 AND 或 OR 的条件组合

　　@Override
    public List<Role> getAllRoles() {
        // TODO Auto-generated method stub
        
        List<Role> roles = null;        
        Session session =sessionFactory.getCurrentSession();
        
        Criteria criteria = session.createCriteria(Role.class);        
        Criterion serverName = Restrictions.eq("roleServer", "一梦十年");
        Criterion userOrder = Restrictions.eq("roleOrder", 1);
        LogicalExpression andExp = Restrictions.and(serverName, userOrder);
        criteria.add(andExp);
        return roles;
    }

你可以直接使用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.分页使用标准

这里有两种分页标准接口方法：

序号	方法描述
1	public Criteria setFirstResult(int firstResult)，这种方法需要一个代表你的结果集的第一行的整数，以第 0 行为开始。
2	public Criteria setMaxResults(int maxResults)，这个方法设置了 Hibernate 检索对象的 maxResults。

利用上述两种方法结合在一起，我们可以在我们的 Web 或 Swing 应用程序构建一个分页组件。以下是一个例子，利用它你可以一次取出 10 行：

Criteria cr = session.createCriteria(Employee.class);
cr.setFirstResult(1);
cr.setMaxResults(10);
List results = cr.list();

4.排序结果

标准 API 提供了 org.hibernate.criterion.order 类可以去根据你的一个对象的属性把你的排序结果集按升序或降序排列。这个例子演示了如何使用 Order 类对结果集进行排序：

Criteria cr = session.createCriteria(Employee.class);
// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));

// To sort records in descening order
crit.addOrder(Order.desc("salary"));

// To sort records in ascending order
crit.addOrder(Order.asc("salary"));

List results = cr.list();  

5.预测与聚合

标准 API 提供了 org.hibernate.criterion.projections 类可得到各属性值的平均值，最大值或最小值。Projections 类与 Restrictions 类相似，均提供了几个获取预测实例的静态工厂方法。

以下是几个例子，涵盖了不同的情况，可按要求进行使用：

Criteria cr = session.createCriteria(Employee.class);

// To get total row count.
cr.setProjection(Projections.rowCount());

// To get average of a property.
cr.setProjection(Projections.avg("salary"));

// To get distinct count of a property.
cr.setProjection(Projections.countDistinct("firstName"));

// To get maximum of a property.
cr.setProjection(Projections.max("salary"));

// To get minimum of a property.
cr.setProjection(Projections.min("salary"));

// To get sum of a property.
cr.setProjection(Projections.sum("salary"));

 6.关联

你可以使用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");
}

16.5. 动态关联抓取

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

 

List cats = sess.createCriteria(Cat.class)

 

.add( Restrictions.like("name", "Fritz%") )

 

.setFetchMode("mate", FetchMode.EAGER)

 

.setFetchMode("kittens", FetchMode.EAGER)

 

.list();

 

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

8.查询示例

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

　　　　 Role role = null;
        Session session = sessionFactory.getCurrentSession();
        
        Role demoRole = new Role();
        demoRole.setRoleSect("星宿");
        
        Example example = Example.create(demoRole).excludeZeroes() ;
        Criteria criteria = session.createCriteria(Role.class);
        
        List<Role> roles =criteria.add(example).list();

注意：如何实体类中如果有int 或者doubole 类型的值而没有设置值，一定要加 excludeZeroes() 条件

 

版本属性、标识符和关联被忽略。默认情况下值为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();

 

 9.投影(Projections)、聚合（aggregation）和分组（grouping）

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

10. 离线(detached)查询和子查询

DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来执行它。

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也可以用以表示子查询。条件实例包含子查询可以通过 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();

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

Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，

创建时无需 Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name) 

进行DetachedCriteria 实例的创建。 Spring 的框架提供了getHibernateTemplate ().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结果。 

Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设 

置 FetchMode( 联合查询抓取的模式 ) ，设置排序方式。对于 Criteria 还可以设置 FlushModel 

（冲刷 Session 的方式）和 LockMode （数据库锁模式）。