QBC——(Query By Criteria)

于 2021-06-07 20:56:58 发布
阅读量308 收藏 2
点赞数
文章标签： java mysql hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wylbdff/article/details/117663798
版权

Criteria基本查询

Criteria是一个通过组装不同查询条件来获取持久对象的条件类对象，代表特定持久类的一个查询。
Criteria对SQL进行封装，让开发人员可以用对象的方式来对数据库进行操作，
例如下面的查询User表格中的所有记录：
Criteria criteria = session.createCriteria(User.class);
List users = criteria.list();
for(int i=0;i<users.size();i++)
{
user =(User)users.get(i);
System.out.println(i+"–"+user.getUsername());
}

Criteria实际上只是个容器，如果想要设定查询条件，则要使用add()方法加入Restrictions的条件限制，
例如查询age大于30且小于40的资料：
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.gt(“age”, 30));
criteria.add(Restrictions.lt(“age”, 40));
List users = criteria.list();

查询名字开头为“大”的所有User
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.like(“username”,“大%”));
List users = criteria.list();
查询姓名在李白和李小白之间的User
String userscope[]={“李白”,“李小白”};
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.in(“username”, userscope));
List users = criteria.list();
Restrictions.allEq，参数为Map对象，使用key/value进行多个等于的比对，相当于多个Restrictions.eq的效果。
Criteria criteria = session.createCriteria(User.class);
Map cons = new HashMap();
cons.put(“name”,“李小白”) ;
cons.put(“password”,“123”);
criteria.add(Restrictions.allEq(cons));
List users = criteria.list();
也可以使用逻辑组合来进行查询
例如结合age等于（eq）20或（or）age为空（isNull）的条件：
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.or(
Restrictions.eq(“age”, 40), Restrictions.eq(“username“,”王二”)
));
List users = criteria.list();
可以使用sqlRestriction()方法来提供SQL语法作限定查询
例如查询username以”大”开头的资料：
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.sqlRestriction(“{alias}.username LIKE (?)”, “大%",Hibernate.STRING));
List users = criteria.list();
其中alias将被替换为与User类相关的名称，而?将被替换为大%，也就是第二个参数所提供的值

在SQL撰写时，不必再写WHERE
如果有多个查询条件，例如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();
Restrictions的几个常用限定查询方法如下表所示：
在这里插入图片描述

Criteria高级查询

您可以使用Criteria进行查询，并使用Order对结果进行排序
例如使用Order.asc()由小到大排序（反之则使用desc()）：
Criteria criteria = session.createCriteria(User.class);
criteria.addOrder(Order.asc(“age”));
List users = criteria.list();
setMaxResults()方法可以限定查询回来的记录数，setFirstResult()设定传回查询结果第一个记录的位置
这两个配合起来，就可以实现简单的分页。
例如返回第5条记录之后的10条记录（如果有的话）：
Criteria criteria = session.createCriteria(User.class);
criteria.setFirstResult(5);
criteria.setMaxResult(10);
List users = criteria.list();
Criteria接口的Projections类主要用于帮助Criteria接口完成数据的分组查询和统计功能 。
通过Criteria的setProjection()方法应用投影到一个查询。
您可以对查询结果进行统计动作，使用Projections的avg()、rowCount()、count()、max()、min()、countDistinct()等方法。
例如对查询结果的“age”作平均：
Criteria criteria = session.createCriteria(User.class);
criteria.setProjection(Projections.avg(“age”));
Number avgage = (Number)criteria.uniqueResult();
System.out.println(“平均年龄为:”+avgage);

还可以配合Projections的groupProperty()来对结果进行分组。
例如以“age”进行分组，也就是如果资料中“age”如果有20、20、25、30，则以下会显示20、25、30：
Criteria criteria = session.createCriteria(User.class);
criteria.setProjection(Projections.groupProperty(“age”));
List ages = criteria.list();
for(int i=0;i<ages.size();i++)
{
System.out.println("–"+ages.get(i));
}
如果想结合统计与分组功能，则可以使用ProjectionList
例如下面的程序会计算每个年龄各有多少个人：
Criteria criteria = session.createCriteria(User.class);
criteria.setProjection(
Projections.projectionList().
add(Projections.count(“age”)).
add(Projections.groupProperty(“age”)));
List ages = criteria.list();
for(int i=0;i<ages.size();i++)
{
Object obj[]=(Object [])ages.get(i);
System.out.println("–"+obj[1]+":"+obj[0]);
}
使用Example对象，可以将一个已知的对象作为查询的依据，看看是否有属性与之类似的对象，也叫QBE查询。
例如：
Criteria criteria = session.createCriteria(User.class);
User user = new User();
user.setName(“大”);
user.setAge(55);
Example exampleUser =Example.create(user);
//enableLike():标识对模板类中所有的String属性进行like模糊匹配
exampleUser.enableLike(MatchMode.ANYWHERE);
criteria.add(exampleUser);
List users = criteria.list();
for(int i=0;i<users.size();i++)
{ everyuser =(User)users.get(i); System.out.println("–"+everyuser.getName()+":"+everyuser.getAge());}

DetchedCriteria高级查询

Criteria与Session绑定，其生命周期跟随着Session结束而结束，使用Criteria时进行查询时，每次都要于执行时期动态建立对象，并加入各种查询条件，随着Session的回收，Criteria也跟着回收。
在Hibernate 3.0中新增了DetchedCriteria对象，可以先建立DetchedCriteria实例，并加入各种查询条件，并于需要查询时再与Session绑定，获得一个绑定Session的Criteria对象。
DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来执行它。可以实现查询和查询条件的构造的解耦。


DetachedCriteria detachedcriteria = DetachedCriteria.forClass(User.class);
   	String name="大";
detachedcriteria.add(Restrictions.like("name",name,MatchMode.ANYWHERE));
List users = findRecordByDetachedCriteria(detachedcriteria);
     for(int i=0;i<users.size();i++)
	 {everyuser =(User)users.get(i); 
     	System.out.println("--"+everyuser.getName()+":"+everyuser.getAge());}

 public List findRecordByDetachedCriteria(DetachedCriteria detchedCriteria){
		Session s = null;
		List list = null;
		try {        s = HibernateUtil.getSession();
			Criteria criteria = detchedCriteria.getExecutableCriteria(s);
			list = criteria.list();
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally{
			if(s!=null)  HibernateUtil.closeSession();
		}
		return list;
	}

高级查询的一些技巧

例如：
在实际中，经常会根据用户在客户界面的输入各种查询条件来返回结果
客户界面如下
在这里插入图片描述

HQL适合于静态查询（编程时已经确定查询字段）
QBC适合于动态查询（编程时无法确定要查询的字段，比如组合查询，往往需要查询的项很多，但不是每个项都必需）
1.查询全部属性

	//1、基本的criteria查询，查询所有属性
	public void testQueryUser(){
		Configuration cfg =null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null;
		try {
			sf=HibernateUtil.getSessionFactory();//SessionFactory单态模式
			session=sf.getCurrentSession();//保证每个读写线程有唯一的session实例
			ts=session.beginTransaction();
			CriteriaQuery cq=session.getCriteriaBuilder().createQuery(User.class);
			cq.from(User.class);
			List users=session.createQuery(cq).list();
			for(int i=0;i<users.size();i++)
			{
				Object u =users.get(i);
				System.out.println(u.toString());
			}
			ts.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if(ts !=null) {
				ts.rollback();
			}
		}finally {
		}
	}

在这里插入图片描述

2.根据某个属性查询
//2、基本的criteria查询，条件查询1
	public void testWhere1QueryUser(){
		Configuration cfg =null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null;
		try {
			sf=HibernateUtil.getSessionFactory();//SessionFactory单态模式
			session=sf.getCurrentSession();//保证每个读写线程有唯一的session实例
			ts=session.beginTransaction();
			CriteriaBuilder cb = session.getCriteriaBuilder();
			CriteriaQuery cq=cb.createQuery(User.class);
			Root<User> root=cq.from(User.class);
			//创建查询条件
			Predicate username = cb.equal(root.get("name"),"李白");
			//cq.from(User.class);
			cq.where(username);
			List users=session.createQuery(cq).list();
			for(int i=0;i<users.size();i++)
			{
				Object u =users.get(i);
				System.out.println(u.toString());
			}
			ts.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if(ts !=null) {
				ts.rollback();
			}
		}finally {
		}
	}

在这里插入图片描述
3.两个条件的查询

//3、基本的criteria查询，条件查询2
	public void testWhere2QueryUser(){
		Configuration cfg =null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null;
		try {
			sf=HibernateUtil.getSessionFactory();//SessionFactory单态模式
			session=sf.getCurrentSession();//保证每个读写线程有唯一的session实例
			ts=session.beginTransaction();
			CriteriaBuilder cb = session.getCriteriaBuilder();
			CriteriaQuery cq=cb.createQuery(User.class);
			Root<User> root=cq.from(User.class);
			//创建查询条件
			Predicate age1 = cb.ge(root.get("age"), 20);
			Predicate age2 = cb.le(root.get("age"), 40);
			//cq.from(User.class);
			cq.where(cb.and(age1,age2));
			List users=session.createQuery(cq).list();
			for(int i=0;i<users.size();i++)
			{
				Object u =users.get(i);
				System.out.println(u.toString());
			}
			ts.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if(ts !=null) {
				ts.rollback();
			}
		}finally {
		}
	}

在这里插入图片描述
4.模糊查询

//4、基本的criteria查询，条件查询3
		public void testWhere3QueryUser(){
			Configuration cfg =null;
			SessionFactory sf=null;
			Session session=null;
			Transaction ts=null;
			try {
				sf=HibernateUtil.getSessionFactory();//SessionFactory单态模式
				session=sf.getCurrentSession();//保证每个读写线程有唯一的session实例
				ts=session.beginTransaction();
				CriteriaBuilder cb = session.getCriteriaBuilder();
				CriteriaQuery cq=cb.createQuery(User.class);
				Root<User> root=cq.from(User.class);
				//创建查询条件
				Predicate username = cb.like(root.get("name"),"%李");
				//cq.from(User.class);
				cq.where(username);
				List users=session.createQuery(cq).list();
				for(int i=0;i<users.size();i++)
				{
					Object u =users.get(i);
					System.out.println(u.toString());
				}
				ts.commit();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				if(ts !=null) {
					ts.rollback();
				}
			}finally {
			}
		}

在这里插入图片描述
5.多个条件的查询

//5、基本的criteria查询，条件查询4
	public void testWhere4QueryUser(){
		Configuration cfg =null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null;
		try {
			sf=HibernateUtil.getSessionFactory();//SessionFactory单态模式
			session=sf.getCurrentSession();//保证每个读写线程有唯一的session实例
			ts=session.beginTransaction();
			CriteriaBuilder cb = session.getCriteriaBuilder();
			CriteriaQuery cq=cb.createQuery(User.class);
			Root<User> root=cq.from(User.class);
			//创建查询条件
			Predicate username = cb.like(root.get("name"),"%李%");
			Predicate gender = cb.equal(root.get("gender"),"男");
			Predicate age = cb.le(root.get("age"),50);
			//cq.from(User.class);
			cq.where(cb.and(username,cb.and(age,gender)));
			List users=session.createQuery(cq).list();
			for(int i=0;i<users.size();i++)
			{
				Object u =users.get(i);
				System.out.println(u.toString());
			}
			ts.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if(ts !=null) {
				ts.rollback();
			}
		}finally {
		}
	}

在这里插入图片描述
6.统计查询

//6、基本的criteria查询，条件查询5
	public void testWhere5QueryUser(){
		Configuration cfg =null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null;
		try {
			sf=HibernateUtil.getSessionFactory();//SessionFactory单态模式
			session=sf.getCurrentSession();//保证每个读写线程有唯一的session实例
			ts=session.beginTransaction();
			CriteriaBuilder cb = session.getCriteriaBuilder();
			CriteriaQuery<Object[]> cq=cb.createQuery(Object[].class);
			Root<User> root=cq.from(User.class);
			//创建查询条件
			cq.multiselect(root.get("gender"),cb.avg(root.get("age")));
			cq.groupBy(root.get("gender"));
			Query query = session.createQuery(cq);
			List users=session.createQuery(cq).getResultList();
			for(int i=0;i<users.size();i++)
			{
				Object[] objs =(Object[])users.get(i);
				System.out.println(objs[0]+" "+objs[1]);
			}
			ts.commit();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			if(ts !=null) {
				ts.rollback();
			}
		}finally {
		}
	}

在这里插入图片描述

wylbdff
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate的查询条件lt_Hibernate Criteria按条件查询(Query By Criteria, QBC)
weixin_33034651的博客
12-24 376
org.hibernate.Criteria接口表示特定持久类的一个查询。Criteria代表一次查询Criterion代表一个查询条件。Restrictions产生查询条件的工具类。Criterion是Criteria的查询条件。Criteria提供了add(Criterioncriterion)方法来1：添加查询条件。Session是Criteria实例的工厂。Criteriacr...
hibernate映射和查询
11-06
Hibernate 提供了多种查询方式，包括 HQL（Hibernate Query Language）、QBC（Query By Criteria）和 JPA（Java Persistence API）的 Criteria API。这些查询语言提供了面向对象的方式来检索数据，比传统的 SQL 更加...
第十一章 Hibernate的查询 Query by Criteria(QBC)
事事无所
06-13 124
QBC(QueryByCriteria)查询方式是Hibernate提供的“更加面向对象”的一种检索方式。QBC在条件查询上比HQL查询更为灵活，而且支持运行时动态生成查询语句。 1、在Hibernate应用中使用QBC查询通常经过3个步骤(1)使用Session实例的createCriteria()方法创建Criteria对象 (2)使用工具类Restrictions的相关方法为Cri...
Hibernate ，Query By Criteria
(Java)
09-11 1926
Hibernate QBC查询              QBC查询：              QBC查询就是通过使用Hibernate提供的Query By Criteria              API来查询对象，这种API封装了SQL语句的动态拼装，对查询提供了更加面向对象的功能接口。我们看下面的示例程序：              Criteria criteria=sess
Hibernate_查询_QueryByCriteria的方式
辐_射的博客
05-11 621
package cn.itcast.k_query_qbc; import java.util.Arrays; import java.util.List; import org.hibernate.Criteria; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.
Hibernate 入门----Query,Criteria,SQLQuery
fengltxx的博客
04-05 2148
Hibernate 入门—-Query,Criteria,SQLQuery ONE Goal , ONE Passion ! hibernate 的QueryHQL(Hibernate Query Language)是一种Hibernate专用的查询语句，基于面向对象的模式，将SQL语句转化成对象的操作格式. list() 查询多条 @Test public void
hibernate查询缓存1
最新发布
08-08
4. **Criteria查询**：Criteria API是一种完全面向对象的查询方式，也称为QBC（Query By Criteria）。它允许开发者动态构建查询，无需预先知道查询的具体形式。 5. **SQLQuery**：对于HQL无法满足的复杂SQL查询需求...
Hibernate开发资料
04-11
5. **CRUD操作**：详细说明如何使用Hibernate进行创建（Create）、读取（Read）、更新（Update）和删除（Delete）操作，包括Criteria、HQL（Hibernate Query Language）和QBC（Query By Criteria）等查询方式。...
hibernate.zip
05-09
9. **HQL和QBC**: Hibernate提供了自己的查询语言HQL（Hibernate Query Language）和Query By Criteria API，它们允许开发者以面向对象的方式编写查询，比直接写SQL更符合面向对象的思想。 10. **缓存机制**: ...
OR_Mapping_Simulation
09-02
5. **查询语言HQL和QBC**：解释Hibernate特有的查询语言HQL（Hibernate Query Language）和Criteria API（Query By Criteria），它们允许开发者用面向对象的方式来编写查询。 6. **事务管理**：探讨Hibernate如何...
QBC的使用全集大全
01-05
Hibernate criteria queris 条件查询(QBC)转 Hibernate QBC查询 QBC分页查询大全
QBC的各种查询
10-21
QBC的各种查询，采用mvc多hibernate的封装，是很好的资料
myFirstHibernate
02-07
Hibernate提供了丰富的查询方式，包括HQL（Hibernate Query Language）、Criteria API和QBC（Query By Example）。例如，使用HQL查询所有用户： ```java String hql = "from User"; List<User> users = session....
Hibernateghfd串讲.rar
11-25
QBC（Query By Example）是根据对象实例进行查询的方式，更符合面向对象的思想。两者都支持复杂的条件、分组、排序等操作。 七、 Criteria查询 Criteria API是另一种动态构建查询的方式，允许在运行时构建查询条件...
Hibernate开发指南.rar
03-09
此外，Query By Criteria（QBC）也是Hibernate提供的查询接口，与Criteria API类似，但更加面向对象。 七、缓存机制 为了提高性能，Hibernate引入了缓存机制。一级缓存是Session级别的，自动管理对象的持久状态；二...
hibernate查询(Query By Criteria(QBC))
Hero_孙的博客
11-27 272
hibernate 的查询方式 1 sql  2 hql  3 qbc 此处只介绍QBC QBC一般的步骤是: 使用Session实例的createCriteria()方法创建Criteria对象； 使用工具类Restrictions的方法为Criteria对象设置查询条件，Order工具类的方法设置排序方式，Projections工具类的方法进行统计和分组； 使用Criteria...
精通hibernate学习笔记（8）[检索方式]
09-03 1538
提供的检索方式：（1）导航对象图检索方式 （2）OID检索方式（3）HQL检索方式（4）QBC检索方式[query by Criteria(标准)]（5）本地SQL检索方式1、简介1.1 HQL检索方式HQL（Hibernate query Language）是面向对象的查询语言，在Hibernate提供的检索方式中，HQL是使用最广泛的检索方式。功能：a.在查询语句中设定各种查询条件b.
QBC（Qurey ByCriteria）检索方式
05-28 236
QBC（Qurey ByCriteria）检索方式        采用HQL检索方式时，在应用程序中需要定义基于字符串形式的HQL查询语句。QBC API提供了检索对象的另一种方式，它主要由Criteria接口、Criterion接口和Expression类组成，它支持在运行时动态生成查询语句。【例】雇员信息表测试类session=HibernateSessionFactory.getSessio...
Query By Criteria的运算符参考
liuyi1985_2008的专栏
04-20 622
QBC (Query By Criteria) 主要有Criteria,Criterion,Oder,Restrictions类组成   session = this.getSession();   Criteria cri = session.createCriteria(JdItemSerialnumber.class);   Criterion cron = Restrictions.lik
hibernateCriteria的使用.docx
09-13
HibernateCriteria的使用可以分为两种方式，一种是QBE（Query By Example），另一种是QBC（Query By Criteria）。 QBE是通过Example对象来创建查询条件，首先创建一个Criteria对象，然后调用add方法传入一个Example...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值