离线查询DetachedCriteria详解

在查询方法设计上可以灵活的根据Criteria的特点来方便地进行查询条件的组装.Hibernate设计了CriteriaSpecification作为Criteria的父接口,下面提供了Criteria和DetachedCriteria.

Criteria和DetachedCriteria的主要区别在于创建的形式不一样,Criteria是在线的,所以它是由HibernateSession进行创建的;而DetachedCriteria是离线的,创建时无需Session,DetachedCriteria提供了2个静态方法forClass(Class)或forEntityName(Name)进行DetachedCriteria实例的创建.Spring的框架提供了getHibernateTemplate().findByCriteria(detachedCriteria)方法,可以很方便地根据DetachedCriteria来返回查询结果.Criteria和DetachedCriteria均可使用Criterion和Projection设置查询条件.可以设置FetchMode(联合查询抓取的模式),设置排序方式.对于Criteria还可以设置FlushModel(冲刷Session的方式)和LockMode(数据库锁模式).

下面对Criterion和Projection进行详细说明.

Criterion是Criteria的查询条件.Criteria提供了add(Criterion 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% 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)方法加入到查询条件中去.使用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()应用投影到一个查询.

hibernate投影、聚合和分组实例。投影运算实际上就是一个基于列的运算，通常用于投影到指定列（也就是过滤其他列，类似select子句的作用），还可以完成SQL语句中常用的分组、组筛选等功能。

Hibernate的条件过滤中使用Projection代表投影运算，Projection是一个接口，而Projections作为Projection的工厂，负责生成Projection对象。

一旦产生了Projection对象之后，就可通过Criteria提供的setProjection(Projection projection)方法来进行投影运算。从该方法上看，每个Criteria只能接受一个投影运算，似乎无法进行多个投影运算，但实际上Hibernate又提供了一个ProjectionList类，该类是Projection的子类，并可以包含多个投影运算，通过这种方式即完成多个投影运算。

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

注意：使用条件查询的投影运算时，不能使用显示的分组子句，但某些投影类型的实质就是分组投影，这些投影元素将出现在SQL的group by子句中——如上的groupProperty(“color”)投影。

在一个条件查询中没有必要显式的使用"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();

投影运算的实质和group by子句、聚集函数的功能大致一致。

除此之外，如果我们希望对分组（投影）后属性进行排序，那就需要为投影运算指定一个别名。为投影运算指定别名有3种方法：

（1）使用Projections的alias()方法为指定投影指定别名。一旦为projection指定了别名，则程序就可以根据该Projection别名来进行其他额外操作了，比如排序。条件查询片段如下：

List l = session.createCriteria(Enrolment.class)

.setProjection(Projections.projectionList()

//按course进行分组

.add(Projections.groupProperty(“course”))

//统计记录条数，并为统计结果指定别名c

.add(Projections.alias(Projections.rowCount(),” c”))

).addOrder(Order, asc(“c”))

.list();

（2）使用SimpleProjection的as()方法为自身指定别名。

List l = session.createCriteria(Enrolment.class)

.setProjection(Projections.projectionList()

//按course进行分组

.add(Projections.groupProperty(“course”).as(“c”))

//统计记录条数，并为统计结果指定别名c

.add(Projections.rowCount())

).addOrder(Order, asc(“c”))

.list();

（3）使用ProjectionList的add()方法添加投影时指定别名。

ProjectionList的add()方法有两个重载形式，一个是直接添加投影，另一个是在添加投影时指定别名。条件查询片段如下：

List l = session.createCriteria(Enrolment.class)

.setProjection(Projections.projectionList()

//按course进行分组，指定别名为c

.add(Projections.groupProperty(“course”),(“c”))

//统计记录条数，并为统计结果指定别名rc

.add(Projections.rowCount(),”rc”)

).addOrder(Order, asc(“c”))

.list();

除此之外，Hibernate还提供了Property执行投影运算，Property投影的作用类似于SQL语句中的select，条件查询的结果只有被Property投影的列才会被选出，条件查询片段如下：

List l = session.createCriteria(Student.class)

.setProjection(Property.forName(“name”))

.list();

上面条件查询执行的结果不再是Student对象集合，而是name属性所组成的集合。

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