精华内容
下载资源
问答
  • DetachedCriteria

    2009-11-03 17:41:00
    org.hibernate.criterion.DetachedCriteria的用法 一 Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口,下面提供了 Criteria和DetachedCriteria 。  1 Criteria 和 DetachedCriteria 的主要区别...

    org.hibernate.criterion.DetachedCriteria的用法

    一 Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口,下面提供了 Criteria和DetachedCriteria 。
       1 Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样, Criteria 是在线的,所
    以它是由 Hibernate Session 进行创建的;而 DetachedCriteria 是离线的,创建时无需Session,DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name)
    进行DetachedCriteria 实例的创建。 Spring 的框架提供了getHibernateTemplate().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结果。
       2 Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设
    置 FetchMode( 联合查询抓取的模式 ) ,设置排序方式。对于 Criteria 还可以设置 FlushModel
    (冲刷 Session 的方式)和 LockMode (数据库锁模式)。
    二 下面对 Criterion 和 Projection 进行详细说明:
       1 Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来
    添加查询条件。
       2 Criterion 接口的主要实现包括: Example 、 Junction 和 SimpleExpression 。而
    Junction 的实际使用是它的两个子类 conjunction 和 disjunction ,分别是使用 AND 和 OR 操
    作符进行来联结查询条件集合。
       3 Criterion 的实例可以通过 Restrictions 工具类来创建,Restrictions 提供了大量的静态
    方法,如 eq (等于)、 ge (大于等于)、 between 等来方法的创建 Criterion 查询条件
    (SimpleExpression 实例)。除此之外, Restrictions 还提供了方法来创建 conjunction 和
    disjunction 实例,通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合。
       4 至于 Example 的创建有所不同, Example 本身提供了一个静态方法 create(Object entity),
    即根据一个对象(实际使用中一般是映射到数据库的对象)来创建。然后可以设置一些过滤条件:
    Example exampleUser =Example.create(u).ignoreCase() // 忽略大小写
                                          .enableLike(MatchMode.ANYWHERE);
               // 对 String 类型的属性,无论在那里值在那里都匹配。相当于 %value%
       5 Project 主要是让 Criteria 能够进行报表查询,并可以实现分组。 Project 主要有
    SimpleProjection 、 ProjectionList 和 Property 三个实现。其中 SimpleProjection 和
    ProjectionList 的实例化是由内建的 Projections 来完成,如提供的 avg 、 count 、 max 、
    min 、 sum 可以让开发者很容易对某个字段进行统计查询。
       6 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()应用投影到一个查询。

     

    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)查询和子查询

       在web层,程序员使用DetachedCriteria来构造查询条件,然后将这个DetachedCriteria作为方法调用参数传递给业务层对象。而业务层对象获得DetachedCriteria之后,可以在session范围内直接构造Criteria,进行查询。就此,查询语句的构造完全被搬离到web层实现,而业务层则只负责完成持久化和查询的封装即可,与查询条件构造完全解耦,非常完美!这恐怕也是以前很多企图在web层代码中构造HQL语句的人想实现的梦想吧!

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


    例子
    public List findAllByCriter(final DetachedCriteria detachedCriteria){
     return (List)getHibernateTemplate().execute(new HibernateCallback(){
      public Object doInHibernate(Session session)
       throws HibernateException{
       Criteria criteria=detachedCriteria.getExecutableCriteria(session);
       return criteria.list();
      }
     });
    }

     

    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/kjfcpua/archive/2009/06/21/4287248.aspx
    -----------------------------------------------------------------------------------------
    Hibernate一直都认为比较简单 就那么影射一下:)但最近项目当中遇见很多问题,今天看见别人在项目当中使用了 Hibernate3的DetachedCriteria,感觉真的是太好了,于是就花了点时间研究了一下,希望和大家分享一下吧
      针对这种需求,对于分层应用程序来说,Web层需要传递一个查询的条件列表给业务层对象,业务层对象获得这个条件列表之后,然后依次取出条件,构造查询语句。这里的一个难点是条件列表用什么来构造?传统上使用Map,但是这种方式缺陷很大,Map可以传递的信息非常有限,只能传递name和 value,无法传递究竟要做怎样的条件运算,究竟是大于,小于,like,还是其它的什么,业务层对象必须确切掌握每条entry的隐含条件。因此一旦隐含条件改变,业务层对象的查询构造算法必须相应修改,但是这种查询条件的改变是隐式约定的,而不是程序代码约束的,因此非常容易出错。

      DetachedCriteria可以解决这个问题,即在web层,程序员使用DetachedCriteria来构造查询条件,然后将这个 DetachedCriteria作为方法调用参数传递给业务层对象。而业务层对象获得DetachedCriteria之后,可以在session范围内直接构造Criteria,进行查询。就此,查询语句的构造完全被搬离到web层实现,而业务层则只负责完成持久化和查询的封装即可,与查询条件构造完全解耦,非常完美!这恐怕也是以前很多企图在web层代码中构造HQL语句的人想实现的梦想吧!

      示例代码片段如下:

      web层程序构造查询条件:

      Java代码:
    DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
    detachedCriteria.add(Restrictions.eq("name", "department")).createAlias("employees", "e").add(Restrictions.gt(("e.age"), new Integer(20)));

      Department和Employee是一对多关联,查询条件为:

      名称是“department”开发部门;
      部门里面的雇员年龄大于20岁;

      业务层对象使用该条件执行查询:

      java代码: detachedCriteria.getExecutableCriteria(session).list();
      最大的意义在于,业务层代码是固定不变的,所有查询条件的构造都在web层完成,业务层只负责在session内执行之。这样代码就可放之四海而皆准,都无须修改了。

      然而Spring和Hibernate3的DetachedCriteria有不兼容的问题,因此在Spring环境下面使用Hibernate3需要注意:

      Spring的HibernateTemplate提供了Hibernate的完美封装,即通过匿名类实现回调,来保证Session的自动资源管理和事务的管理。其中核心方法是:

      java代码:
    HibernateTemplate.execute(new HibernateCallback() {
     public Object doInHibernate(Session session) throws HibernateException {
      ....
     }
    }
      回调方法提供了session作为参数,有了session,就可以自由的使用Hibernate API编程了。使用了spring的之后,代码修改如下:

      web层代码:

      java代码:
    DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
    detachedCriteria.createAlias("employees", "e").add(Restrictions.eq("name", "department")).add(Restrictions.gt(("e.age"), new Integer(20)));
    departmentManager.findByCriteria(detachedCriteria);
      构造detachedCriteria,作为参数传递给departmentManager

      业务层代码使用spring,DepartmentManager的findByCriteria如下:

      java代码:

    public List findByCriteria(final DetachedCriteria detachedCriteria) {
     return (List) getHibernateTemplate().execute(new HibernateCallback() {
      public Object doInHibernate(Session session) throws HibernateException {
       Criteria criteria = detachedCriteria.getExecutableCriteria(session);
       return criteria.list();
      }
     });
    }
      实际上也就是:

      java代码:
    Criteria criteria = detachedCriteria.getExecutableCriteria(session);
    return criteria.list();
      而已

      但是该程序代码执行,会抛出强制类型转换异常!

      我跟踪了一下spring和Hibernate源代码,原因如下:

      spring的HibernateTemplate的execute方法提供的回调接口具有Session作为参数,但是实际上,默认情况下, HibernateTemplate传递给回调接口的session并不是org.hibernate.impl.SessionImpl类,而是 SessionImpl类的一个Proxy类。之所以替换成为一个Proxy类,HibernateTemplate的注释说明,Proxy提供了一些额外的功能,包括自动设置Cachable,Transaction的超时时间,Session资源的更积极的关闭等等。

      java代码:
    private boolean exposeNativeSession = false;
    ...
      execute方法内部:
    Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session));

      但是遗憾的是,Hibernate的DetachedCriteria的setExecutableCriteria方法却要求将session参数强制转为SessionImpl,但是spring传过来的却是一个Proxy类,因此就报错了。

      java代码:
    public Criteria getExecutableCriteria(Session session) {
     impl.setSession( (SessionImpl) session ); // 要求SessionImpl,Spring传递的是Proxy
     return impl;
    }

      解决方法,禁止Spring的HibernateTemplate传递Proxy类,强制要求它传递真实的SessionImpl类,即给exexute方法增加一个参数,提供参数为true,如下:

      java代码:
    public List findByCriteria(final DetachedCriteria detachedCriteria) {
     return (List) getHibernateTemplate().execute(new HibernateCallback() {
      public Object doInHibernate(Session session) throws HibernateException {
       Criteria criteria = detachedCriteria.getExecutableCriteria(session);
       return criteria.list();
      }
     }, true);
    }

    展开全文
  • DetachedCriteria笔记

    2017-08-02 23:08:02
    DetachedCriteria
  • DetachedCriteria查询

    2011-07-13 18:53:02
    DetachedCriteria的查询方式汇总
  • DetachedCriteria使用介绍

    2013-06-27 09:24:40
    DetachedCriteria使用介绍
  • DetachedCriteria用法

    2017-04-05 21:51:15
    一、基本使用 1. 说明 Restrictions 是产生查询条件的工具类。 2. 定义 可以直接用class 创建 ...DetachedCriteria.forClass(QymlPerson.class); 也可以用hibernate 的session 创建 session.createCriter
    一、基本使用
    1. 说明
    Restrictions 是产生查询条件的工具类。
    2. 定义
    可以直接用class 创建
    DetachedCriteria searDc =
    DetachedCriteria.forClass(QymlPerson.class);
    也可以用hibernate 的session 创建
    session.createCriteria(Student.class)
    3. 条件查询
    3.1 多条件的and 规则
    通过searDc.add(Restrictions.eq("unid", userid))实现条件查询。
    多次添加的条件,默认的规则是and.
    3.2 多条件的or 规则
    如果实现or 的查询,需要按照如下方式进行
    searDc.add(Restrictions.or(Restrictions.eq("deptunid", "aa"),
    Restrictions.isNull("deptunid")));
    其中isnull 表示一个常规字段是否为空,isEmpty 用来表示一个集合字段是否为空。
    4. 查询排序
    通过searDc.addOrder(Order.asc(propertyName1))可以添加排序,如果有多个排
    序字段,可以添加多次;最终的结果将按照添加的次序进行排序处理。
    二、子查询
    //主查询:人员查询
    DetachedCriteria searDc =
    DetachedCriteria.forClass(QymlPerson.class);
    //子查询:职务人员关系表
    DetachedCriteria sub =
    DetachedCriteria.forClass(QymlPositionUserLink.class);
    sub.add(Restrictions.eq("positionunid", positionunid));
    //子查询:指定查询的列(也就是select usernuid from ....)
    sub.setProjection(Property.forName("userunid"));
    //主查询和子查询关联(也就是where unid in (select userunid from...) )
    searDc.add(Property.forName("unid").in(sub));
    在上面的例子中,用个一个类似于下面SQL 的子查询
    Select * from Person a where a.unid in (select userunid from PositionUserLink b where
    b.positionunid = ..)
    Property 还有其他的条件判断,参考api
    http://docs.jboss.org/hibernate/core/3.3/api/org/hibernate/criter
    ion/Property.html。
    三、Restrictions表达式
    HQL运算符 QBC运算符 含义
    = Restrictions.eq() 等于equal
    <> Restrictions.ne() 不等于 not equal
    > Restrictions.gt() 大于greater than
    >= Restrictions.ge() 大于等于 greater than or
    equal
    < Restrictions.lt() 小于less than
    <= Restrictions.le() 小 于 等 于 less than or
    equal
    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() 等于列表中的某一个值
    not in(列表) Restrictions.not(Restrictions.in()) 不等于列表中任意一个值
    between x and y Restrictions.between() 闭区间 xy中的任意值
    not between x and y
    Restrictions.not(Restrictions..between()) 小于值X 或者大于值y


    三、Restrictions关联查询
    如果每个美女都有自己的客户资源(不要想歪了!),那么需要查询拥有客户Gates的美女怎么办?
    使用Criteria可以有两种方法:
    1:
    DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class).createCriteria("customers");
    beautyCriteria.add(Restrictions.eq("name", "Gates")):
    2:
    DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class).createAlias("customers", "c");
    beautyCriteria.add(Restrictions.eq("c.name", "Gates")):
    接着有了新的要求,年纪太大的美女不要,还是查找拥有客户Gates的,条件如下:
    DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class, "b").;
    DetachedCriteria customerCriteria = beautyCriteria.createAlias("customers", c");
    beautyCriteria.add(Restrictions.le("b.age", new Long(20))):
    customerCriteria.add(Restrictions.eq("c.name", "Gates")):
    展开全文
  • DetachedCriteria Criteria 使用方法 非常详细外加练习
  • 父接口CriteriaSpecification,其下有子接口Criteria和实现类DetachedCriteria,Criteria和DetachedCriteria均可使用Criterion和Projection设置查询条件。可以设置FetchMode( 联合查询抓取的模式 ) ,设置排序方式。...

    参考

    spring hibernate DetachedCriteria

    概述

    父接口CriteriaSpecification,其下有子接口Criteria和实现类DetachedCriteria,Criteria和DetachedCriteria均可使用Criterion和Projection设置查询条件。可以设置FetchMode( 联合查询抓取的模式 ) ,设置排序方式。对于Criteria还可以设置FlushModel(冲刷 Session 的方式)和LockMode(数据库锁模式)。

    Criteria和DetachedCriteria的主要区别在于创建的形式不一样,Criteria是在线的,所以它是由Hibernate Session进行创建的;而DetachedCriteria是离线的,创建时无需Session,它通过2个静态方法forClass(Class) 或 forEntityName(Name) 进行DetachedCriteria 的实例创建。

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

    所以它也称为离线条件查询,即建立一个DetachedCriteria对象,将查询的条件等指定好,然后在session.beginTransaction()后将这个对象传入。通常这个对象可以在表示层建立,然后传入业务层进行查询。

    使用

    过滤域,只查询需要的属性

     // 过滤域,只查询需要的属性
        public BaseDao<T> filterField(String[] params) {
            String tableName = getTableName();//表名
            this.dc = DetachedCriteria.forClass(getTable(), tableName);//第一个参数实体类,第二个参数表名
            ProjectionList pList = Projections.projectionList();
            for (String param : params) {
                pList.add(Projections.property(tableName + "." + param).as(param)); // 设置需要查询的域
            }
            dc.setProjection(pList);
            return this;
        }
    
    
        // 设置查询where语句
        public BaseDao<T> where(String arg1, Object... params) {
            if (arg1 == null || params == null || params.length == 0) {
                return null;
            }
            if (params.length == 1) {
                dc.add(Restrictions.eq(arg1, params[0]));
            } else if (params.length == 2) {
                switch (params[1].toString()) {
                    case "=": {
                        dc.add(Restrictions.eq(arg1, params[0]));
                    }
                    ;
                    break;
                    case ">": {
                        dc.add(Restrictions.gt(arg1, params[0]));
                    }
                    break;
                    case ">=": {
                        dc.add(Restrictions.ge(arg1, params[0]));
                    }
                    break;
                    case "<": {
                        dc.add(Restrictions.le(arg1, params[0]));
                    }
                    break;
                    case "<=": {
                        dc.add(Restrictions.le(arg1, params[0]));
                    }
                    ;
                    break;
                    case "!=": {
                        dc.add(Restrictions.ne(arg1, params[0]));
                    }
                    break;
                }
            }
            return this;
        }
    
    展开全文
  • DetachedCriteria中使用或(or)和与(and) DetachedCriteria criteria = new DetachedCriteria(SysUser) criteria.or { criteria.gt('createDate',searchDate) criteria.gt('modifyDate',searchDate) } 上面的...
    1. DetachedCriteria中使用或(or)和与(and)
    DetachedCriteria criteria = new DetachedCriteria(SysUser)
    criteria.or {
    	criteria.gt('createDate',searchDate)
    	criteria.gt('modifyDate',searchDate)
    }
    

    上面的意思就是查询createDate大于searchDate或者modifyDate大于searchDate的数据,与的话就把or换成and。
    2. sort排序

    criteria.sort('createDate','asc')//多个字段排序我还不清楚,后续补上
    
    1. offset,max翻页,限制查询总量
    criteria.offset(0).max(100).list()
    

    注意:因为offset和max方法每次都返回新的DetachedCriteria,所以要采用链式调用的方式查询才会生效。

    展开全文
  • hibernate detachedcriteria

    2014-12-15 17:34:46
    Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样, Criteria 是在线的,所 以它是由 Hibernate Session 进行创建的;而 DetachedCriteria 是离线的,创建时无需 Session,DetachedCriteria 提供了 2...
  • DetachedCriteria详细使用

    2020-04-07 13:09:26
    一、基本使用 1. 说明 Restrictions 是产生查询条件的工具类。...DetachedCriteria.forClass(QymlPerson.class); 也可以用hibernate的session创建 session.createCriteria(Student.class) 3. ...
  • DetachedCriteria的使用

    2017-04-10 17:16:52
    DetachedCriteria detachedCriteria = DetachedCriteria.forClass(WtPepBillpay.class); detachedCriteria.createAlias("id", "id"); detachedCriteria.add(Restrictions.eq(WtPepBillpay.BILLMERCODE, organization
  • DetachedCriteria一例子

    2018-05-07 14:58:39
    DetachedCriteria query = DetachedCriteria.forClass(SysNotice.class,"sysNotice1"); /*定义子查询对象并命名别名*/ DetachedCriteria querySon = DetachedCriteria.forClass(SysNoticeVisit.class,&...
  • DetachedCriteria查询实例

    2017-04-10 18:02:51
    项目中用到了DetachedCriteria,顺便记下来 DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Holiday.class); detachedCriteria.add(Restrictions.eq("department", department)); //下面这句比较...
  • DetachedCriteria 使用记录
  • detachedCriteria.setResultTransformer(DetachedCriteria.ROOT_ENTITY);的作用 是用来指定hibernate框架封装对象的方法 例如有两个对象region和subarea,然后在subarea里面有region 此时用detachedCriteria根据条件...
  • DetachedCriteria 查询

    2014-05-04 11:47:59
    1、简介2、一对多查询的过滤3、or 查询4、对象属性的属性查询DetachedCriteria r1 = DetachedCriteria.forClass(ResourceDownLog.class) .setProjection(Property.forName("id")) .add(Restriction
  • Criteria与DetachedCriteria

    2017-07-31 10:45:16
    Criteria和DetachedCriteria是hibernate的两个查询方法(方便查询条件的组装)。 hibernate设计了CriteriaSpecification作为Criteria的父接口,提供Criteria和DetachedCriteria。 Criteria和DetachedCriteria主要...
  • DetachedCriteria 用法

    2012-10-10 13:42:37
    2、DetachedCriteria中的add方法将条件封装起来,hibernate拼写sql语句 3、用getHibernateTemplate().findByCriteria();方法执行DetachedCriteria @SuppressWarnings("unchecked")  public Set prodphoto
  • DetachedCriteria使用记录

    2015-06-15 08:53:06
    DetachedCriteria使用记录
  • Hibernate DetachedCriteria

    2012-11-08 08:49:00
    hibernate DetachedCriteria(hibernate 分离/离线查询)   使用DetachedCriteria类可以在session之外构造一个查询条件,而不受session的约束。同时也很好的实现了   分层。并且对于动态查询也有不错的作用。 ...
  • Criteria和DetachedCriteria

    2019-02-27 14:02:00
    首先,Criteria和DetachedCriteria不存在父子关系。但是,它们有一个共同的父接口CriteriaSpecification。 Criteria jdk的帮助文档中是这样介绍Criteria的: Criteriais a simplified API for retrieving ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,194
精华内容 477
关键字:

detachedcriteria