Hibernate中Criteria的完整用法
criteriaquery 检索nested类型 -回复
criteriaquery 检索nested类型-回复CriteriaQuery是Hibernate框架中的一种查询方法，用于进行复杂的查询操作。
在本文中，我们将重点介绍如何使用CriteriaQuery来检索nested类型的数据。
第一步：了解nested类型Nested类型是一种特殊的数据类型，它允许将一个文档嵌套在另一个文档中。
在关系型数据库中，我们通常使用外键来建立文档之间的关系，而在NoSQL数据库中，使用nested类型可以更方便地表示文档之间的嵌套关系。
第二步：创建实体类和映射文件在使用CriteriaQuery检索nested类型之前，我们首先需要创建相应的实体类和映射文件。
假设我们有两个实体类：Order和Product，其中Order中包含一个名为products的nested类型的属性。
我们可以使用注解或XML文件来定义实体类和映射关系。
第三步：创建CriteriaBuilder和CriteriaQuery对象在使用CriteriaQuery之前，我们需要创建CriteriaBuilder和CriteriaQuery对象。
CriteriaBuilder是用于构建查询条件的类，而CriteriaQuery是用于构建查询语句本身的类。
javaCriteriaBuilder cb = session.getCriteriaBuilder();CriteriaQuery<Order> cq = cb.createQuery(Order.class);Root<Order> root = cq.from(Order.class);第四步：创建Join对象由于我们要检索nested类型的数据，因此需要使用Join操作来处理嵌套在Order中的products属性。
我们可以使用CriteriaQuery的join方法来创建Join对象。
javaJoin<Order, Product> productJoin = root.join("products");第五步：设置查询条件在使用CriteriaQuery进行查询之前，我们还可以设置各种查询条件。
Criteria查询
Criteria查询实现分页 2-1
Criteria 的setMaxResults()方法可以限定查询 返回数据的行数 Criteria 的setFirstResult()设定查询返回结果 的第一行数据的位置 结合以上Criteria的两个方法即可实现简单分页
Criteria查询实现分页 2-2
Criteria查询排序 2-1
Criteria 查询不仅能组合出SQL中where子句的 功能，还可以组合出排序查询功能 使用org.hibernate.criterion.Order对结果进行 排序 排序的方法为：
asc() desc()
Criteria查询排序 2-2
SessionFactory sessionFactory = new Configuration().configure() 创建Criteria对象 .buildSessionFactory(); Session session = sessionFactory.openSession(); Criteria criteria = session.createCriteria(House.class); criteria.addOrder(Order.desc("price")); List result = criteria.list(); 以价格降序的方式排列 Iterator it = result.iterator(); while (it.hasNext()) { 加入Order 条件 House house = (House) it.next(); System.out.println("标题：" + house.getTitle() + " 价格" + house.getPrice()); } session.close(); sessionFactory.close(); 演示示例：Criteria排序
Criteria
order
ID varchar2(14)
order_number number(10)
customer_ID varchar2(14)
现在有两条HQL查询语句，分别如下：
from Customer c inner join c.orders o group by c.age;(1)
select c.ID,,c.age,o.ID,o.order_number,o.customer_ID
for(int i=0;i
System.out.println(list.get(i));
}
我们只检索了User实体的name属性对应的数据，此时返回的包含结果集的list中每个条目都是String类型的name属性对应的数据。我们也可以一次检索多个属性，如下面程序：
List list=session.createQuery(“select ,user.age from User user ”).list();
Criteria查询对查询条件进行了面向对象封装，符合编程人员的思维方式，不过HQL(Hibernate Query Lanaguage)查询提供了更加丰富的和灵活的查询特性，因此Hibernate将HQL查询方式立为官方推荐的标准查询方式，HQL查询在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装。完整的HQL语句形势如下：
from User user where user.age=20 and like ‘%zx%’;
2、 实体的更新和删除：
在继续讲解HQL其他更为强大的查询功能前，我们先来讲解以下利用HQL进行实体更新和删除的技术。这项技术功能是Hibernate3的新加入的功能，在Hibernate2中是不具备的。比如在Hibernate2中，如果我们想将数据库中所有18岁的用户的年龄全部改为20岁，那么我们要首先将年龄在18岁的用户检索出来，然后将他们的年龄修改为20岁，最后调用Session.update()语句进行更新。在Hibernate3中对这个问题提供了更加灵活和更具效率的解决办法，如下面的代码：
条件类Criteria的用法
复合查询主要是处理，具有关联关系的两个实体怎样进行关联查询，比如User 实体对象与Addres实体对象具有一对多的关联关系，我们可以如下构造符合查询：Criteria criteria=session.createCriteria(User.class);Criteria addcriteria=criteria.createCriteria(“addresses”);(1)addcriteria.add(Express.like(“address”,”%tianjin%”));List list=criteria.list();for(int i=0;iUser user=(User)list.get(i);System.out.println(user.getName()+”\n”);Set addresses=user.getAddresses();Iterator it=addresses.iterator();while(it.hasNext(){Address address=(Address)it.next();Syste m.out.println(address.getAddress()+”\n”);}}当执行到了（1）处时，表明要针对User对象的addresses属性添加新的查询条件，因此当执行criteria.list()时，Hibernate会生成类似如下的SQL语句：Select * from user inner join address on user.id=address.id where address.address like …%shanghai%‟;正如我们所见，我们可以通过向Criteria中添加保存关联对象的集合属性（addresses属性保存与User对象相关联的Address对象），来构造复合查询，在数据库一端是通过内连接查询来实现。
Hibernate QBC查询QBC查询：QBC查询就是通过使用Hibernate提供的Query By Criteria API来查询对象，这种API封装了SQL语句的动态拼装，对查询提供了更加面向对象的功能接口。
criteria使用总结(目前只会单表)
Criteria的使用总结1、目前只遇到用于单表查询（多表查询期待中。
）public Integer getqueryTamArchivesCount(String content, String fileNumber, String fileType, Date beginDate,Date endDate){DetachedCriteria criteria = DetachedCriteria.forClass(TamArch.class);if (content != null && content.trim().length() > 0) {//模糊匹配criteria.add(Restrictions.like("subject", "%" + content + "%"));}if (fileNumber != null && fileNumber.trim().length() > 0) { //相等criteria.add(Restrictions.eq("archivesNo", fileNumber));}if ("1".equals(fileType)) {//或者criteria.add(Restrictions.or(Restrictions.eq("archivesStatus", "1"), Restrictions.eq("archivesStatus", "2")));}else if("2".equals(fileType)){criteria.add(Restrictions.eq("archivesStatus", "99"));}if(beginDate!=null&&endDate!=null){//两者之间criteria.add(Restrictions.between("issueDate",beginDate,endDate));}//按日期降序排列criteria.addOrder(Order.desc("inputDate"));return archDao.getRowCount(criteria) ;}注意：①对于日期有点bug，如果查询的日期为空，则查询不到数据。
Hibernate查询sql结果行数、查询列表的几种方法
Hibernate查询sql结果⾏数、查询列表的⼏种⽅法⼀、前⾔这个东西，难度⼏乎没有，就是繁琐。
⼀条简单的select count（*） from table_name都能有多种书写⽅式。
总是忘，这⾥记录下。
⼀、通过Criteria 查询查询⾏数：Criteria criteriaCount = getCriteria();criteriaCount = criteriaCount.add(Restrictions.eq("dispatchTaskId", dispatchTaskId));criteriaCount.setProjection(Projections.rowCount());Integer totalCount = ((Long) criteriaCount.uniqueResult()).intValue();查询列表：Criteria criteria = getCriteria();criteria.add(Restrictions.eq("eventId", eventInformationId));List<EventTaskAssignment> list = criteria.list();⼆、通过原⽣sql查询查询⾏数：SQLQuery queryCount = getSession().createSQLQuery("SELECT COUNT(*) FROM incidentInformation WHERE ii.incidentInformationId = :incidentInformationId AND dti.taskstate = :taskstate");queryCount.setParameter("incidentInformationId", incidentInformationId);queryCount.setParameter("taskstate", ETaskStatus.STATUS_INIT.getStatusValue());int count = ((BigDecimal) queryCount.uniqueResult()).intValue();return count;查询列表：1、返回的item为数据库表对应poSQLQuery query = getSession().createSQLQuery(sqlQuery);query.setParameter("userId", userId);query.addEntity(EventTaskAssignment.class);List<EventTaskAssignment> items = query.list();2、返回的item为voSQLQuery query = getSession().createSQLQuery(sqlBuffer.toString());query.setParameter("eventInformationId", eventInformationId);query.addScalar("userId", StandardBasicTypes.STRING);query.addScalar("userName", StandardBasicTypes.STRING);query.setResultTransformer(Transformers.aliasToBean(UserRoles.class));List<UserRoles> list = query.list();三、通过hibernate的查询语⾔查询String countHql = "select count(*) from a where and a.approveResult = :approveResult and a.approverId = :approverId";Query countQuery = getSession().createQuery(countHql);countQuery.setParameter("approverId", approverId);int count = ((Long) countQuery.uniqueResult()).intValue();。
Criteria
hibernate 中Criteria 的使用介绍要对资料库管理系统进行操作，最基本的就是使用SQL（Standard Query Language）语句，大部份的资料库都支援标准的SQL语句，然而也有一些特定于资料库的SQL语句，应用程式配合SQL 语句进行资料库查询时，若使用到特定于资料库的SQL语句，程式本身会有相依于特定资料库的问题。
使用Hibernate时，即使您不了解SQL的使用与撰写，也可以使用它所提供的API来进行SQL语句查询，org.hibernate.Criteria对SQL进行封装，您可以从Java物件的观点来组合各种查询条件，由Hibernate自动为您产生SQL语句，而不用特别管理SQL与资料库相依的问题。
以最基本的查询来说，如果您想要查询某个物件所对应的资料表中所有的内容，您可以如下进行查询：Criteria criteria = session.createCriteria(User.class);List users = criteria.list();for(Iterator it = users.iterator(); it.hasNext(); ) {User user = (User) it.next();System.out.println(user.getId() +" "t " + user.getName() +"/" + user.getAge());}Criteria建立后，若不给予任何的条件，预设是查询物件所对应表格之所有资料，如果您执行以上的程式片段，并于设定档中设定了了Hibernate的”show_sql”属性，则可以在主控下看到以下的SQL 语句之产生：Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_Criteria基本查询条件设定org.hibernate.Criteria实际上是个条件附加的容器，如果想要设定查询条件，则要使用org.hibernate.criterion.Restrictions的各种静态方法传回org.hibernate.criterion.Criteria实例，传回的每个org.hibernate.criterion.Criteria实例代表着一个条件，您要使用org.hibernate.Criteria的add()方法加入这些条件实例，例如查询”age”大于20且小于40的资料：Criteria criteria = session.createCriteria(User.class);criteria.add(Restrictions.gt("age", new Integer(20)));criteria.add(Restrictions.lt("age", new Integer(40)));List users = criteria.list();for(Iterator it = users.iterator(); it.hasNext(); ) {User user = (User) it.next();System.out.println(user.getId() +" "t " + user.getName() +"/" + user.getAge());}Restrictions的gt()方法表示大于（great than）的条件，而lt表示小于（less than）的条件，执行以上程式片段，观察所产生的SQL语句，将使用where与and子句产来完成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>? and this_.age使用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)您也可以使用Restrictions.like()方法来进行SQL中like子句的功能，例如查询”name”中名称为”just”开头的资料：Criteria criteria = session.createCriteria(User.class);criteria.add(Restrictions.like("name", "just%"));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_.name like ?Restrictions的几个常用限定查询方法如下表所示：方法说明Restrictions.eq 等于Restrictions.allEq 使用Map，使用key/value进行多个等于的比对Restrictions.gt 大于>Restrictions.ge 大于等于>=Restrictions.lt 小于<Restrictions.le 小于等于<=Restrictions.between 对应SQL的BETWEEN子句Restrictions.like 对应SQL的LIKE子句Restrictions.in 对应SQL的in子句Restrictions.and and关係Restrictions.or or关係Criteria进阶查询条件设定使用Criteria进行查询时，不仅仅能组合出SQL中where子句的功能，还可以组合出如排序、统计、分组等的查询功能。
criteria对象 逻辑运算查询
criteria对象逻辑运算查询一、引言在许多数据库应用中，我们经常需要使用查询语句来检索符合特定条件的数据。
Criteria对象是Hibernate等ORM框架提供的一种用于构建复杂查询的方法，它允许我们在实体类或映射文件中创建复杂的查询条件。
在本篇文章中，我们将介绍Criteria对象中逻辑运算查询的基本概念和用法。
二、基本逻辑运算符在Criteria对象中，我们通常使用AND、OR和NOT等逻辑运算符来组合查询条件。
这些运算符可以根据需要组合多个属性比较、集合比较、函数查询等操作符，从而构建复杂的查询语句。
以下是一些常用的逻辑运算符：* AND：表示两个条件都必须满足。
* OR：表示两个条件中至少有一个满足。
* NOT：表示否定一个条件。
三、示例查询以下是一个使用Criteria对象进行逻辑运算查询的示例：假设我们有一个User实体类，其中包含id、name和age三个属性。
我们想要查询年龄大于等于18岁且姓名包含“张”的所有用户。
```java// 创建Criteria对象Criteria criteria = session.createCriteria(User.class);// 添加条件：年龄大于等于18岁criteria.add(Property.ge("age", 18));// 添加条件：姓名包含“张”criteria.add(Property.like("name", "张%"));// 执行查询List<User> users = criteria.list();```在上述示例中，我们首先创建了一个Criteria对象，并使用add 方法添加了两个条件：年龄大于等于18岁和姓名包含“张”。
最后，我们使用list方法执行查询，并获取符合条件的User对象的列表。
四、多重条件查询在某些情况下，我们可能需要同时满足多个条件。
java类中criteria.addlike 的各种方法
在Java类中，`criteria.addLike()`方法通常用于构建SQL查询语句中的模糊匹配条件。
它用于在查询中添加一个包含通配符`%`的模糊匹配条件。
`criteria.addLike()`方法的使用取决于你使用的ORM框架，因为不同的ORM框架可能有不同的API和语法。
以下是几个常见的ORM 框架中使用`criteria.addLike()`方法的示例：1. Hibernate Criteria API：```javaCriteria criteria = session.createCriteria(Employee.class);criteria.addLike(Restrictions.sqlRestriction("name like %?{%}", name, MatchMode.ANYWHERE));List<Employee> employees = criteria.list();```2. JPA Criteria API：```javaCriteriaBuilder builder = entityManager.getCriteriaBuilder();CriteriaQuery<Employee> query = builder.createQuery(Employee.class);Root<Employee> root = query.from(Employee.class);query.where(builder.like(root.get("name"), builder.concat("%", name, "%")));List<Employee> employees = entityManager.createQuery(query).getResultList();```3. MyBatis：```xml<select id="findEmployeesByName" resultType="Employee">SELECT * FROM employee WHERE name LIKE CONCAT('%', #{name}, '%')</select>```在上述示例中，`criteria.addLike()`方法用于将给定的名称（`name`）添加到查询条件中，并在名称中添加通配符`%`，以便进行模糊匹配。
hibernate 重写 criteria的order排序方式
hibernate 重写criteria的order排序方式在Hibernate中，要重写Criteria的排序方式，你可以使用`org.hibernate.criterion.Order`类，该类允许你指定排序的属性和排序方式。
下面是一个示例，展示如何使用Criteria进行排序：```javaimport org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Criteria;import org.hibernate.criterion.Order;import org.hibernate.criterion.Restrictions;import java.util.List;public class YourClass {public List<YourEntity> getDataWithCustomOrder(SessionFactory sessionFactory) { Session session = sessionFactory.openSession();Criteria criteria = session.createCriteria(YourEntity.class);// 添加一些条件，如果需要的话criteria.add(Restrictions.eq("someProperty", someValue));// 添加自定义排序criteria.addOrder(Order.asc("propertyName")); // 按升序排序// 或者criteria.addOrder(Order.desc("propertyName")); // 按降序排序List<YourEntity> result = criteria.list();session.close();return result;}}```在上述示例中，`YourEntity`是你要查询的实体类，`someProperty`是你添加的其他条件，`propertyName`是你要排序的属性名称。
Criteria用法详解
hibernate:Hibernate中Criteria的完整使用方法疯狂代码 / ĵ:http://Java/Article58225.html 最近在项目中使用 Spring 和 Hibernate 进行开发有感于 Criteria 比较好用在查询思路方法设计上可以灵活根据 Criteria 特点来方便地进行查询条件组装现在对 HibernateCriteria 使用方法进行整理总结: Hibernate 设计了 CriteriaSpecication 作为 Criteria 父接口下面提供了 Criteria和DetachedCriteria Criteria 和 DetachedCriteria 主要区别在于创建形式不样 Criteria 是在线所以它是由 Hibernate Session 进行创建；而 DetachedCriteria 是离线创建时无需SessionDetachedCriteria 提供了 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 3个实现其中SimpleProjection 和 ProjectionList 例子化是由内建 Projections 来完成如提供 avg 、 count 、 max 、 min 、 sum 可以让开发者很容易对某个字段进行统计查询 Property 是对某个字段进行查询条件设置如通过Porperty.forName(“color”).in(String{“black”,”red”,”write”}); 则可以创建个 Project 例子通过 criteria add(Project) 思路方法加入到查询条件中去 使用 Criteria 进行查询主要要清晰是 Hibernate 提供了那些类和思路方法来满足开发中查询条件创建和组装下面介绍几种使用方法: 1. 创建个Criteria 例子 org.hibernate.Criteria接口表示特定持久类个查询Session是 Criteria例子工厂Criteria crit = sess.createCriteria(Cat.);crit.MaxResults(50);List cats = crit.list; 2. 限制结果集内容 个单独查询条件是org.hibernate.criterion.Criterion 接口个例子 org.hibernate.criterion.Restrictions类 定义了获得某些内置Criterion类型工厂思路方法List cats = sess.createCriteria(Cat.) .add( Restrictions.like("name", "Fritz%") ) .add( Restrictions.between("weight", minWeight, maxWeight) ) .list; 约束可以按逻辑分组List cats = sess.createCriteria(Cat.) .add( Restrictions.like("name", "Fritz%") ) .add( Restrictions.or( Restrictions.eq( "age", Integer(0) ), Restrictions.isNull("age") ) ) .list;List cats = sess.createCriteria(Cat.) .add( Restrictions.in( "name", String { "Fritz", "Izi", "Pk" } ) ) .add( Restrictions.disjunction .add( Restrictions.isNull("age") ) .add( Restrictions.eq("age", Integer(0) ) ) .add( Restrictions.eq("age", Integer(1) ) ) .add( Restrictions.eq("age", Integer(2) ) ) ) ) .list; Hibernate提供了相当多内置criterion类型(Restrictions 子类), 但是尤其有用是可以允许你直接使用SQLList cats = sess.createCriteria(Cat.) .add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",Hibernate.STRING) ) .list; {alias}占位符应当被替换为被查询实体列别名 Property例子是获得个条件另外种途径你可以通过Property.forName 创建个PropertyProperty age = Property.forName("age");List cats = sess.createCriteria(Cat.) .add( Restrictions.disjunction .add( age.isNull ) .add( age.eq( Integer(0) ) ) .add( age.eq( Integer(1) ) ) .add( age.eq( Integer(2) ) ) ) ) .add( Property.forName("name").in( String { "Fritz", "Izi", "Pk" } ) ) .list; 3. 结果集排序 你可以使用org.hibernate.criterion.Order来为查询结果排序List cats = sess.createCriteria(Cat.) .add( Restrictions.like("name", "F%") .addOrder( Order.asc("name") ) .addOrder( Order.desc("age") ) .MaxResults(50) .list;List cats = sess.createCriteria(Cat.) .add( Property.forName("name").like("F%") ) .addOrder( Property.forName("name").asc ) .addOrder( Property.forName("age").desc ) .MaxResults(50) .list; 4. 关联 你可以使用createCriteria非常容易在互相关联实体间建立 约束List cats = sess.createCriteria(Cat.) .add( Restrictions.like("name", "F%") .createCriteria("kittens") .add( Restrictions.like("name", "F%") .list; 注意第 2个 createCriteria返回个新 Criteria例子该例子引用kittens 集合中元素 接下来替换形态在某些情况下也是很有用List cats = sess.createCriteria(Cat.) .createAlias("kittens", "kt") .createAlias("mate", "mt") .add( Restrictions.eqProperty("", "") ) .list; (createAlias并不创建个新 Criteria例子) Cat例子所保存的前两次查询所返回kittens集合是 没有被条件预过滤如果你希望只获得符合条件kittens 你必须使用MapsList cats = sess.createCriteria(Cat.) .createCriteria("kittens", "kt") .add( Restrictions.eq("name", "F%") ) .Maps .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. 动态关联抓取 你可以使用FetchMode在运行时定义动态关联抓取语义List cats = sess.createCriteria(Cat.) .add( Restrictions.like("name", "Fritz%") ) .FetchMode("mate", FetchMode.EAGER) .FetchMode("kittens", FetchMode.EAGER) .list; 这个查询可以通过外连接抓取mate和kittens 6. 查询举例 org.hibernate.criterion.Example类允许你通过个给定例子 构建个条件查询Cat cat = Cat;cat.Sex('F');cat.Color(Color.BLACK);List results = session.createCriteria(Cat.) .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 insensitive comparisons .enableLike; //use like for comparisonsList results = session.createCriteria(Cat.) .add(example) .list; 甚至可以使用examples在关联对象上放置条件List results = session.createCriteria(Cat.) .add( Example.create(cat) ) .createCriteria("mate") .add( Example.create( cat.getMate ) ) .list; 7. 投影(Projections)、聚合(aggregation)和分组(grouping) org.hibernate.criterion.Projections是 Projection 例子工厂我们通过 Projection应用投影到个查询List results = session.createCriteria(Cat.) .Projection( Projections.rowCount ) .add( Restrictions.eq("color", Color.BLACK) ) .list;List results = session.createCriteria(Cat.) .Projection( Projections.projectionList .add( Projections.rowCount ) .add( Projections.avg("weight") ) .add( Projections.max("weight") ) .add( Projections.groupProperty("color") ) ) .list; 在个条件查询中没有必要显式使用 "group by" 某些投影类型就是被定义为 分组投影他们也出现在SQLgroup by子句中 可以选择把个别名指派给个投影这样可以使投影值被约束或排序所引用下面是两种区别实现方式:List results = session.createCriteria(Cat.) .Projection( Projections.alias( Projections.groupProperty("color"), "colr" ) ) .addOrder( Order.asc("colr") ) .list;List results = session.createCriteria(Cat.) .Projection( Projections.groupProperty("color").as("colr") ) .addOrder( Order.asc("colr") ) .list; alias和as思路方法简便将个投影例子包装到另外个 别名Projection例子中简而言的当你添加个投影到个投影列表中时 你可以为它指定个别名:List results = session.createCriteria(Cat.) .Projection( 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., "cat") .createAlias("kittens", "kit") .Projection( Projections.projectionList .add( Projections.property(""), "catName" ) .add( Projections.property(""), "kitName" ) ) .addOrder( Order.asc("catName") ) .addOrder( Order.asc("kitName") ) .list; 也可以使用Property.forName来表示投影:List results = session.createCriteria(Cat.) .Projection( Property.forName("name") ) .add( Property.forName("color").eq(Color.BLACK) ) .list;List results = session.createCriteria(Cat.) .Projection( 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.) .add( Property.forName("sex").eq('F') );//创建个SessionSession session = .;Transaction txn = session.beginTransaction;List results = query.getExecutableCriteria(session).MaxResults(100).list;mit;session.close; DetachedCriteria也可以用以表示子查询条件例子包含子查询可以通过 Subqueries或者Property获得DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.) .Projection( Property.forName("weight").avg );session.createCriteria(Cat.) .add( Property.forName("weight).gt(avgWeight) ) .list;DetachedCriteria weights = DetachedCriteria.forClass(Cat.) .Projection( Property.forName("weight") );session.createCriteria(Cat.) .add( Subqueries.geAll("weight", weights) ) .list; 相互关联子查询也是有可能:DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat., "cat2") .Projection( Property.forName("weight").avg ) .add( Property.forName("cat2.sex").eqProperty("cat.sex") );session.createCriteria(Cat., "cat") .add( Property.forName("weight).gt(avgWeightForSex) ) .list;2009-1-23 1:04:58疯狂代码 /。
criteria的一些示例语句或方法
Criteria的一些语句范例（方法）一、Criteria的一些基本查询Criteria有一个方法add(“限定条件”)，这个方法可以添加限定条件，好得到自己应该要的查询结果；例如：有两个实体类，student和teacher已经有一个Criteria的关于Student 类的实例Criteria crit = session.createCriteria(Student.class)；1）在一个班级中要查询姓“王”的学生都有谁，就可以这样:List list = crit.add(Restrictions.like(“name”,”王%”)).list();2）查询年龄在17-20之间的学生：List list = crit.add(Restrictions.between(“age”,new Integer(17),new Integer(20))).list();3）查询没有手机号码的学生：List list = crit.add(Restrictions.isNull(tel)).list();4）查询90后的学生：List list = crit.add(Restrictions.ge(new Date(1990-01-01)).list();5）查询考试分数在前十名的学生（可用于分页查询）：List list = crit.addOrder(Order.desc(“grades”)).setFirstResult(0).setMaxResult(10).list();6）查询学生小明的个人信息：crit.add(Restriction.eq(“name”,”小明”)).list().iterator().next();7）查询小明的化学教师的信息：crit.add(Restricrions.eq(“name”,”小明”)).createCriteria(“teacher_id”).add(Restrictions.equ(“subject”,”化学”)).list().iterator().next();8）以上都是先创建session根据session得到Criteria的实体对象（即在线查询），下面来看看离线查询，离线查询用的是DetachedCriteria类，DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的Session来执行它。
criteria用法java
criteria用法java在Java中，"criteria"可以有不同的用法，具体取决于上下文和所使用的库或框架。
一般来说，"criteria"是指用于定义查询条件的对象或接口。
一种常见的使用情况是在Java持久层框架（如Hibernate）中使用"criteria"来创建查询。
在这种情况下，"criteria"可以作为一个类似于查询构造器的对象，用于动态地构建查询条件，以便从数据库中检索特定的数据。
这些查询条件可以包括等于、不等于、大于、小于等关系运算符，以及与、或等逻辑运算符。
通过使用"criteria"，可以以一种灵活的方式生成查询，并且不需要直接编写SQL语句。
以下是一个简单的示例，展示了如何在Hibernate中使用"criteria"来创建查询条件：```//创建一个Criteria对象Criteria criteria =session.createCriteria(YourEntity.class);//添加查询条件criteria.add(Restrictions.eq("fieldName", value));//执行查询List results = criteria.list();```上述示例中，我们首先通过`session.createCriteria()`方法创建一个Criteria对象，然后使用`criteria.add()`方法添加一个查询条件，该条件是指字段`fieldName`等于特定值`value`。
最后，我们通过`criteria.list()`方法执行查询，并将结果以列表的形式返回。
除了上述示例中演示的用法，不同的持久层框架和库可能还提供其他用于"criteria"的方法和功能，以满足不同的查询需求。
hibernate查询数据库返回一条数据的方法
hibernate查询数据库返回一条数据的方法Hibernate 是一个强大的对象关系映射（ORM）框架，它简化了Java 程序与数据库之间的交互。
在本文中，我们将探讨使用Hibernate 查询数据库并返回一条数据的方法。
### Hibernate 查询数据库返回一条数据的方法在Hibernate 中，查询数据库并返回一条数据通常有多种方式。
下面列举了几种常用的方法：#### 1.使用HQL（Hibernate Query Language）```java// 获取Hibernate 会话Session session = sessionFactory.openSession();Transaction transaction = session.beginTransaction();// 使用HQL 查询String hql = "FROM YourEntityName where someColumn = :value";Query query = session.createQuery(hql);query.setParameter("value", someValue);// 获取唯一结果Object result = query.uniqueResult();mit();session.close();// 输出结果if (result != null) {YourEntity entity = (YourEntity) result;// Do something with the entity}```注意：这里的`YourEntityName` 替换为你的实体类名，`someColumn` 和`someValue` 替换为你需要查询的列名和值。
#### 2.使用Criteria API```javaSession session = sessionFactory.openSession();Transaction transaction = session.beginTransaction();// 创建Criteria 对象Criteria criteria = session.createCriteria(YourEntityName.class);criteria.add(Restrictions.eq("someColumn", someValue));// 获取唯一结果Object result = criteria.uniqueResult();mit();session.close();// 输出结果if (result != null) {YourEntity entity = (YourEntity) result;// Do something with the entity```#### 3.使用Native SQL```javaSession session = sessionFactory.openSession();Transaction transaction = session.beginTransaction();// 使用原生SQL 查询String sql = "SELECT * FROM your_table WHERE some_column = :value";SQLQuery query = session.createSQLQuery(sql);query.setParameter("value", someValue);// 指定返回的实体类query.addEntity(YourEntityName.class);// 获取唯一结果Object result = query.uniqueResult();mit();session.close();// 输出结果if (result != null) {YourEntity entity = (YourEntity) result;// Do something with the entity}注意：在使用Native SQL 时，确保你了解原生SQL 语句的数据库依赖性。
[业务]条件类Criteria的用法
![[业务]条件类Criteria的用法](https://img.taocdn.com/s3/m/64793020f011f18583d049649b6648d7c1c70886.png)
复合查询主要是处理，具有关联关系的两个实体怎样进行关联查询，比如User 实体对象与Addres实体对象具有一对多的关联关系，我们可以如下构造符合查询：Criteria criteria=session.createCriteria(User.class);Criteria addcriteria=criteria.createCriteria(“addresses”);(1)addcriteria.add(Express.like(“address”,”%tianjin%”));List list=criteria.list();for(int i=0;iUser user=(User)list.get(i);System.out.print ln(user.getName()+”\n”);Set addresses=user.getAddresses();Iterator it=addresses.iterator();while(it.hasNext(){Address address=(Address)it.next();System.out.println(address.getAddress()+”\n”);}}当执行到了（1）处时，表明要针对User对象的addresses属性添加新的查询条件，因此当执行criteria.list()时，Hibernate会生成类似如下的SQL语句：Select * from user inner join address on user.id=address.id where address.address like …%shanghai%‟;正如我们所见，我们可以通过向Criteria中添加保存关联对象的集合属性（addresses属性保存与User对象相关联的Address对象），来构造复合查询，在数据库一端是通过内连接查询来实现。
Hibernate QBC查询QBC查询：QBC查询就是通过使用Hibernate提供的Query By Criteria API来查询对象，这种API封装了SQL语句的动态拼装，对查询提供了更加面向对象的功能接口。
criteria语法
criteria语法
Criteria语法是一种用于数据库查询的语句结构，它可以让我们轻松地查询数据库中存储的信息。
通过使用Criteria语法，我们可以在不写任何SQL语句的情况下轻松地查询数据库中的信息。
Criteria语法的基本结构包含三个部分：选择（Select）、条件（Where）和排序（Order By）。
在选择部分，我们可以列出需要查询的列名；在条件部分，我们可以指定一些限定条件，以过滤出满足条件的记录；在排序部分，我们可以按照指定的列名将结果按照升序或者降序排列。
在Criteria语法中，我们还可以使用一些常见的运算符，例如等于（=）、大于（>）、小于（<）、不等于（!=）等，以更精细地指定查询条件。
另外，我们还可以使用通配符（%）来进行模糊匹配，以便查询所有符合条件的记录。
除此之外，Criteria语法还支持多表查询，即同时查询多张相关联的数据库表。
通过使用关键字JOIN和ON，我们可以将不同的表连接起来，以获取更加详尽的信息。
总之，Criteria语法是一个非常实用的工具，可以让我们在数据库查询中更加高效和方便。
通过掌握Criteria语法的基本结构和常用运算符，我们可以轻松地对数据库中的信息进行查询、筛选和排序，从而更好地管理和利用数据库中的数据资源。
criteria用法java
criteria用法java摘要：1.概述2.Java 中的criteria 用法2.1 创建Criteria 对象2.2 设置查询条件2.3 执行查询2.4 获取查询结果3.示例4.总结正文：1.概述在Java 中，criteria 是一种用于查询数据库的方法，它可以帮助我们更方便地编写SQL 查询语句。
通过使用criteria，我们可以在代码中定义查询条件，而不需要直接编写SQL 语句。
这样可以提高代码的可读性和可维护性。
本文将介绍Java 中criteria 的用法。
2.Java 中的criteria 用法2.1 创建Criteria 对象要使用criteria，首先需要创建一个Criteria 对象。
这可以通过以下方法实现：```javaCriteria criteria = session.createCriteria(entityClass);```其中，session 是数据库会话，entityClass 是要查询的实体类。
2.2 设置查询条件创建Criteria 对象后，可以通过以下方法设置查询条件：- add(String property, Condition condition)：添加一个查询条件，其中property 是要查询的属性名，condition 是查询条件。
- add(String property, ng.String condition)：添加一个查询条件，其中property 是要查询的属性名，condition 是查询条件字符串。
- add(String property, Condition[] conditions)：添加一个查询条件数组，其中property 是要查询的属性名，conditions 是查询条件数组。
例如：```java// 添加一个查询条件：name = "John"criteria.add("name", Condition.eq("John"));// 添加一个查询条件：age > 20criteria.add("age", Condition.gt(20));// 添加一个查询条件：age < 30criteria.add("age", Condition.lt(30));```2.3 执行查询设置完查询条件后，可以通过以下方法执行查询：```javaList<T> list = criteria.list();```其中，T 是要查询的实体类。
Criteria用法
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 查询表达式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 ”表达式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",newInteger(13),new Integer(50));表达式Expression.in 对应SQL中的”field in …”表达式Expression.eqProperty 用于比较两个属性之间的值，对应SQL中的“field = field”。
hiberate criteriaquery排序
hiberate criteriaquery排序主题：Hibernate CriteriaQuery 排序介绍：Hibernate是Java中最受欢迎的对象关系映射（ORM）框架之一。
通过Hibernate，开发人员可以将Java对象映射到关系数据库中的表。
在使用Hibernate进行数据库操作时，我们可以使用CriteriaQuery来构建查询语句，包括排序功能。
本文将逐步解释如何使用Hibernate CriteriaQuery 进行排序。
第一部分：什么是Hibernate CriteriaQuery？Hibernate CriteriaQuery是Hibernate提供的一种API，允许开发人员以编程方式创建复杂的查询语句。
使用CriteriaQuery，开发人员可以避免直接编写SQL语句，从而提高开发效率和代码的可维护性。
第二部分：如何创建CriteriaQuery对象？要使用Hibernate CriteriaQuery进行排序，首先需要创建CriteriaQuery 对象。
可以使用Hibernate Session对象的createCriteriaQuery()方法来创建CriteriaQuery对象。
例如：Session session = sessionFactory.openSession();CriteriaBuilder builder = session.getCriteriaBuilder(); CriteriaQuery<Entity> criteriaQuery =builder.createQuery(Entity.class);在这个例子中，我们使用SessionFactory打开一个会话，然后获取一个CriteriaBuilder对象，最后使用builder的createQuery()方法创建一个CriteriaQuery对象。
第三部分：如何添加排序条件？一旦有了CriteriaQuery对象，就可以添加排序条件。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
QBE (Query By Example)Criteria cri = session.createCriteria(Student.class);cri.add(Example.create(s)); //s是一个Student对象list cri.list();实质：创建一个模版，比如我有一个表serial有一个giftortoy字段，我设置serial.setgifttoy("2"), 则这个表中的所有的giftortoy为2的数据都会出来2: QBC (Query By Criteria) 主要有Criteria,Criterion,Oder,Restrictions类组成session = this.getSession();Criteria cri = session.createCriteria(JdItemSerialnumber.class);Criterion cron = Restrictions.like("customer",name);cri.add(cron);list = cri.list();==============================比较运算符HQL运算符QBC运算符含义= 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或者大于值y3: HQLString hql = "select ,avg(s.age) from Student s group by ";Query query = session.createQuery(hql);list = query.list();....4: 本地SQL查询session = sessionFactory.openSession();tran = session.beginTransaction();SQLQuery sq = session.createSQLQuery(sql);sq.addEntity(Student.class);list = sq.list();mit();16.1. 创建一个Criteria实例org.hibernate.Criteria接口表示特定持久类的一个查询。
Session是Criteria实例的工厂。
Criteria crit = sess.createCriteria(Cat.class);crit.setMaxResults(50);List cats = crit.list();16.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();16.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();16.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("", "") ).list();(createAlias()并不创建一个新的Criteria实例。
)Cat实例所保存的之前两次查询所返回的kittens集合是没有被条件预过滤的。