hibernate Criteria查询学习笔记
Hibernate 中的HQL查询的总结(夏杰)
Hibernate 中的HQL查询的总结一．Spring+Hibernate 中1.保存一个实体getHibernateTemplate().save(user);2.根据id号从数据库中查询到一个实体Useruser=(User)getHibernateTemplate().load(User.class,fromUse rId));3.删除一个实体方法一：直接删除getHibernateTemplate().delete((Message)；方法二：嵌套一个根据id号查询到一个实体，再删除getHibernateTemplate().delete((Message)getHibernateTempla te().load(Message.class, msgId));4.查询符合添加的记录的个数，函数count(*)Object obj = getSession().createQuery("select count(*)from Message where recepUser.id="+recepUserId+" and msgType=1").uniqueResult();//表示只返回一个结果5.修改一个实体getHibernateTemplate().update(message);6.设定查询记录的起始位置和得到的记录数List<Message> list = getSession().createQuery("from Message where (fromUser.id="+userId+" or recepUser.id="+userId+") and msgType=2 order by id desc").setMaxResults(想要得到的记录数).setFirstResult(取得记录的起点).list();7. intValue()返回的结果是整数int msgCount=((Long)getSession().createQuery("select count(*) from Message where from User.id="+userId+" or recepUser.id="+userId).uniqueResult()).intValue();二．只有Hibernate 中1.保存数据/*** 保存数据** @param t传入的泛型* @return*/public boolean save(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.save(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}2.删除数据/*** 删除数据** @param t传入的泛型* @return*/public boolean delete(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.delete(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}3.修改数据/*** 修改数据** @param t传入的泛型* @return*/public boolean update(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.update(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}4.查询单条数据，返回查询得到的唯一的结果实体对象/*** 查询单条数据** @param hql* @return返回查询得到的唯一的结果实体对象*/public T queryFrom(String hql) {// T表示泛型对象,T泛型定义T t = null;// 引用实体对象session = HibernateUtil.getSession();try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询語句t = (T) query.uniqueResult();// 将查询结果转换为实体对象session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return t;// 返回查询得到的实体对象}5.通过泛型定义的查询多条语句方法/*** 通过泛型定义的查询多条语句方法** @param hql** @return 查询得到的结果集List*/public List<T> queryList(String hql) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合对象}6. 返回指定条数的查询结果的方法/*** 返回指定条数的查询结果的方法** @param hql* @param showNumber所要查询的数据的结果的条数* @return返回查询得到的集合对象*/public List<T> queryTypeListNumber(String hql, int showNumber,Type type) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句// for(int i=0;i<params.length;i++){//把传递过来的参数数组遍历出来，遍历赋值给hql语句中的未知待定数据// query=query.setParameter(i, params[i]);// }query=query.setParameter(0, type);query.setMaxResults(showNumber);// 设这所要查询的数据的结果的条数list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合集合对象}7.查询所有用户信息String hql = "from User";list = session.createQuery(hql) //创建Query对象 .list();8.保存用户session.save(user);9.通过用户名和密码查询用户（参数不一定，用动态赋值）//HQL查询语句String hql = "from User u where ername=? and u.password=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username)//动态赋值.setParameter(1, password);//动态赋值10.判断指定用户名的用户是否存在//HQL查询语句String hql = "from User u where ername=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username);//动态赋值Object user = query.uniqueResult();//返回User对象//如果用户存在exist为trueif(user != null){exist = true;}11.根据id删除一条留言信息//加载指定id的留言信息Message message = (Message)session.get(Message.class, id);session.delete(message); //删除留言12.查询所有文章中都有哪些作者（Group By）hql = "select author from ArticleInfo group by author";//查询文章详细信息的hql语句List authorList = objectDao.queryListObject(hql);//执行查询request.setAttribute("authorList", authorList);13.分组查询，各部门名称和各部门的人数（Group By）hql="select u.dept,count(*) from User u group by u.dept";Query query=session.creatQuery(hql);List<Object[]> list=query.list();//object[]是数组，可以同时多个属性查询obj[o],obj[1],obj[2],,,,//for循环输出信息For(object[] obj;list){Sysout.("部门"+obj[0]);Sysout.("人数"+obj[1])}14.查询文章的回复// 文章回复内容的详细查询hql = "from ReArticleInfo where re_id=" + id + " order by id desc";//查询文章详细内容的hql语句ObjectDao<ReArticleInfo> re_objectDao = new ObjectDao<ReArticleInfo>();//实例化持久化类List<ReArticleInfo> list = null;//定义List集合15.In的条件嵌套查询（双重条件，条件在其他表中）跨表hql_article_commend = "from ArticleInfo where commend='是' and author in (select account from UserInfo where freeze='解冻')";hql_article_vistor = "from ArticleInfo where author in (select account from UserInfo where freeze='解冻') order by visit desc";16.多对一映射在user表中，通过Author对象查询userString hql="from Category c wherec.typeName='"+category.getTypeName()+"'andc.author='"+category.getAuthor().getId()+"'";。
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进行查询之前，我们还可以设置各种查询条件。
Hibernate查询详解
Hibernate查询首先介绍get()和load()方法的区别:get()方法和load()方法的区别主要在于对二级缓存的使用上。
load()方法会使用二级缓存，而get()方法在一级缓存没有找到会直接查询数据库，不会去二级缓存中查找。
get():如果在数据库中没有记录会返回空，get()无论如何都会返回数据.load():如果数据库中没有记录会抛出异常，如果有数据返回的是一个代理对象。
list和iterator()方法之间的区别：(N+1?)list()方法在执行时，直接运行查询结果所需要的查询语句。
iterator()方法则是先执行得到对象ID的查询，然后在根据每个ID值去取得所要查询的对象。
因此：对于list()方式的查询通常只会执行一个SQL语句，而对于iterator()方法的查询则可能需要执行N+1条SQL语句(N为结果集中的记录数).结果集的处理方法不同:list()方法会一次活的所有的结果集对象，而且他会依据查询的结果初始化所有的结果集对象。
如果在结果集非常庞大的时候会占据非常多的内存，甚至会造成内存溢出的情况发生。
iterator()方法在执行时不会一次初始化所有的对象，而是根据对结果集的访问情况来初始化对象。
一次在访问中可以控制缓存中对象的数量，以避免占用过多的缓存，导致内存溢出情况的发生。
HQL:HQL是一种面向对象的查询语言，HQL的操作对象是类、实例和属性等。
SQL:sql的操作对象是数据表和列等数据对象。
Hql是完全面向对象的查询语言，因此可以支持继承和多条等特征。
HQL查询依赖于Query类，每个Query实例对应一个查询对象。
定参数的功能，Query 接口才是真正的HQL查询接口。
//创建一个Query 对象Java代码1Query query = session.createQuery ("from Customer as c where=:customerName and c.age=:customerAge");//动态绑定参数Java代码2query.setString("customerName","Tom");3query.setInteger("customerAge",21);//执行查询语句，返回结果Java代码4List result = query.list();HQL查询步骤:1:获取Hibernate Session对象。
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中对这个问题提供了更加灵活和更具效率的解决办法，如下面的代码：
hibernate4学习笔记
hibernate4学习笔记Hibernate4学习笔记本⼈全部以⾃学为主，在⽹上收集各种学习资料，总结归纳学习经验，现将学习路径给予⼤家分享。
此次学习的hibernate的版本是：hibernate-release-4.2.4.Final（截⽌2015年7⽉31⽇最新版），JAVA的版本是：java8.0，使⽤的开发⼯具是：Eclipse Mars Release (4.5.0)。
第⼀天：Hibernate4基础知识和HelloWorld简单编程Hibernate是⼀种半成品ORM框架，对数据库持久化操作，程序员对数据库的操作转换成对对象的操作。
ORM 采⽤元数据来描述对象-关系映射细节, 元数据通常采⽤XML 格式, 并且存放在专门的对象-关系映射⽂件中。
HelloWorld简单编程1、准备Hibernate环境（1）导⼊Hibernate的Jar包，如下：（2）导⼊Mysql驱动包，我⽤的数据库是：Mysql 5.0，数据库驱动包如下：以上所有Jar加完毕之后，需要加⼊到Eclipse⾃⾝系统⾥⾯，具体如下：以上操作完毕之后，Hibernate的环境就算搭建完毕，下⾯就可以进⼀步操作。
2、配置hibernate.cfg.xml⽂件，主要是对数据库的连接，具体如下："-//Hibernate/Hibernate Configuration DTD 3.0//EN""/doc/63fa364d5022aaea998f0fde.html /hibernate-configuration-3.0.dtd ">rootmysqlname="connection.driver_class">com.mysql.jdbc.Driver jdbc:mysql:///Test(或者：jdbc:mysql://localhost:3306/Test)name="dialect">org.hibernate.dialect.MySQLInnoDBDialecttruetrueupdate3、编写⼀个实例类News.java，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private Date date;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) { super();this.title = title;this.author = author;this.date = date;}public News(){}@Overridereturn"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射⽂件，具体代码如下："/doc/63fa364d5022aaea998f0fde.html /hibernate-mapping-3.0.dtd">5、将映射⽂件News.hbm.xml指定到hibernate.cfg.xml配置⽂件⾥⾯，即在hibernate.cfg.xml⽂件⾥加⼊⼀⾏映射代码，具体如下：6、创建hibernate API操作测试类（Juit测试），验证hibernate的优势效果，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.Test;public class HibernateTest {@Testpublic void test() {//1. 创建⼀个 SessionFactory 对象SessionFactory sessionFactory=null;//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和对象关系映射信息Configuration configuration=new Configuration().configure();//4.0 之前这样创建//sessionFactory=configuration.buildSessionFactory();//2). 4.0以后创建⼀个 ServiceRegistry 对象: hibernate 4.x 新添加的对象//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.ServiceRegistry serviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties() ).buildServiceRegistry();sessionFactory=configuration.buildSessionFactory(serviceRegistry) ;//2. 创建⼀个 Session 对象Session session=sessionFactory.openSession();//3. 开启事务Transaction transaction=session.beginTransaction();//4. 执⾏保存操作News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));session.save(news);//5. 提交事务/doc/63fa364d5022aaea998f0fde.html mit();//6. 关闭 Sessionsession.close();//7. 关闭 SessionFactory 对象sessionFactory.close();}}7、测试结果如下：（1）数据库⾥⾯的结果如下：（2）Eclipse下的语句⽣成如下：以上就是简单Hibernate的测试，总结：1、不需要在数据库⾥⾯创建任何数据，由hibernate ⾃动⽣成；2、代码简单易理解，不复杂，测试数据只需要先创建以下⼏个步骤：SessionFactory-→Session-→Transaction-→session操作数据库-→提交-→关闭；3、不需要写SQL 语句，从头到尾没有写⼀条SQL语句，反⽽Hibernate帮我们⽣成SQL语句。
hibernateCriteria关联查询
hibernateCriteria关联查询hibernate Criteria 关联查询0、配置文件增加property-ref1、测试通过Criteria查询关联表；2、查询策略外连接；3、通过外键关联查询；4、配置文件增加inverse＝true// Criteria查询语句的补充// 一、复合查询// 在这个一对多的例子中。
我们使用复合查询，查询所有用户及其地址。
// Criteria criteria = session.createCriteria(User.class);// List list = criteria.list();//// for (int i = 0; i < list.size(); i++) {// User user = (User) list.get(i);// System.out.println("\t user:"+i+" name is:" + user.getNam e());//// Set addrSet = user.getAddresses();// Iterator it = addrSet.iterator();// while(it.hasNext()){// Address addr = (Address)it.next();// System.out.println("\t\t user:"+i+" address is:"+addr.getA ddress());// }// }// 通过Criteria查询条件，我们可以查询位于上海的用户// Criteria criteria = session.createCriteria(User.class);//// Criteria addCriteria =// criteria.createCriteria("addresses");//这里addresses和User 类对应// addCriteria.add(Expression.like("address",// "%shanghai%"));//这里构造新的Criteria查询过滤条件// List list = criteria.list();//// for (int i = 0; i < list.size(); i++) {// User user = (User) list.get(i);// System.out.println("\t user:" + i + " name is:" + user.getN ame());//// Set addrSet = user.getAddresses();// Iterator it = addrSet.iterator();// while (it.hasNext()) {// Address addr = (Address) it.next();// System.out.println("\t\t user:" + i + " address is:"// + addr.getAddress());// }// }/zj%5Fchen/blog/item/35631384eb2f74 3267096e96.html4. 关联你可以使用createCriteria()非常容易的在互相关联的实体间建立约束。
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();。
封装JPA（Hibernate）动态查询（CriteriaQuery）
封装JPA（Hibernate）动态查询（CriteriaQuery）在JPA 2.0 中我们可以使用entityManager.createNativeQuery()来执行原生的SQL语句。
但当我们查询结果没有对应实体类时，query.getResultList()返回的是一个List<Object[]>。
也就是说每行的数据被作为一个对象数组返回。
常见的用法是这样的：[java] view plaincopy1.public void testNativeQuery(){2.Query query = entityManager.createNativeQuery("select i d, name, age from t_user");3.List rows = query.getResultList();4.for (Object row : rows) {5.Object[] cells = (Object[]) row;6.System.out.println("id = " + cells[0]);7.System.out.println("name = " + cells[1]);8.System.out.println("age = " + cells[2]);9.}10.}这样用会使代码非常不容易让人理解，究竟下标为0的元素到底是什么，不去数查询语句是不知道的，而且一旦查询语句被调整，Java代码也要一起调整。
这时候我们想如果返回的是Map的话，用起来会清晰的多。
可惜的是JPA的API中并没有提供这样的设置。
其实很多JPA的底层实现都是支持返回Map对象的。
例如：EclipseLink的query.setHint(QueryHints.RESULT_TYPE,ResultType.Map);Hibernate的.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);所以，如果我们想要返回Map并且确定底层用的是某一种JPA的实现时我们可以退而求其次，牺牲跨实现的特性来满足我们的需求：[java] view plaincopy1.public void testNativeQuery(){2.Query query = entityManager.createNativeQuery("select i d, name, age from t_user");3.query.unwrap(SQLQuery.class).setResultTransformer(Tran sformers.ALIAS_TO_ENTITY_MAP);4.List rows = query.getResultList();5.for (Object obj : rows) {6.Map row = (Map) obj;7.System.out.println("id = " + row.get("ID"));8.System.out.println("name = " + row.get("NAME"));9.System.out.println("age = " + row.get("AGE"));10.}11.}这里需要注意的是，用Map肯定要比用Object数组来的效率低。
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子句的功能，还可以组合出如排序、统计、分组等的查询功能。
Hibernate高效查询，只查询部分指定字段
Hibernate⾼效查询，只查询部分指定字段公司使⽤[java]1. DetachedCriteria detachedCriteria = DetachedCriteria.forClass(PeBulletin.class);2. detachedCriteria.createAlias("enumConstByFlagIsvalid", "enumConstByFlagIsvalid");3. detachedCriteria.createCriteria("peSite", "peSite");4. detachedCriteria.createCriteria("peManager", "peManager");5. detachedCriteria.add(Restrictions.eq("enumConstByFlagIsvalid.code", "1"));6. detachedCriteria.createAlias("enumConstByFlagIstop", "enumConstByFlagIstop");7. detachedCriteria.addOrder(Order.desc("enumConstByFlagIstop.code")).addOrder(Order.desc("publishDate"));的QBC⽅式查询数据。
这种⽅式的最⼤好处是⼏乎完全⾯向对象，是⼀种在HQL更上层的对象封装了，⼏乎让你忘记SQL是什么玩意了。
但是他有⼀个最⼤的弊端就是效率问题。
默认他会查询这个对象的所有字段【包括它的关联对象】。
像我上⾯这个查询最后查出来的字段起码有100多个字段了。
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对象的列表。
四、多重条件查询在某些情况下，我们可能需要同时满足多个条件。
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的大神，为什么用Hibernate自带查询进行关联查询，关联表数据查不到？这个问题是很多Hibernate开发者经常遇到的问题。
我们将深入探讨这个问题的根本原因，以及如何避免这个问题。
让我们来了解一下Hibernate的自带查询。
Hibernate提供了多种查询方式，其中一种就是自带查询。
自带查询是指Hibernate提供的一系列查询方法，这些方法可以通过Hibernate的Session对象进行调用。
使用自带查询的好处是可以减少代码量，提高开发效率。
使用Hibernate自带查询进行关联查询时，可能会出现关联表数据查不到的情况。
这是因为Hibernate自带查询默认使用的是左外连接（left outer join）的方式进行关联查询。
左外连接是指返回左表中所有记录和右表中匹配的记录。
如果右表中没有匹配的记录，那么就会返回一个NULL值。
当使用Hibernate自带查询进行关联查询时，如果关联表中没有匹配的记录，那么就会返回一个NULL值。
这就是为什么我们无法查到关联表数据的原因。
那么，如何避免这个问题呢？一种解决方法是使用Hibernate的Criteria查询。
Criteria 查询是一种类型安全的查询方式，可以通过编程方式构建查询条件，同时也可以进行关联查询。
在进行关联查询时，Criteria查询使用的是内连接（inner join）的方式，这样就可以避免关联表数据查不到的问题。
还可以使用Hibernate的HQL查询。
HQL查询是一种基于面向对象的查询方式，可以使用实体类的属性名进行查询。
在进行关联查询时，HQL查询使用的也是内连接的方式，因此也可以避免关联表数据查不到的问题。
使用Hibernate自带查询进行关联查询时，可能会出现关联表数据查不到的问题。
为了避免这个问题，我们可以使用Hibernate的Criteria查询或HQL查询。
这些查询方式都使用内连接的方式进行关联查询，可以保证查询结果的准确性。
Hibernate查询方法
Hibernate查询方法1: 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 的数据都会出来QBC查询方式QBC(Query By Criteria)查询方式是 Hibernate 提供的“ 更加面向对象” 的一种检索方式。
QBC 在条件查询上比 HQL 查询更为灵活，而且支持运行时动态生成查询语句。
在Hibernate 应用中使用 QBC 查询通常经过 3 个步骤(1)使用 Session 实例的 createCriteria() 方法创建 Criteria 对象(2)使用工具类 Restrictions 的相关方法为 Criteria 对象设置查询对象(3)使用 Criteria 对象的 list() 方法执行查询，返回查询结果Restrictions类的常用方法Restrictions.eq(String propertyName,Object value)等于Restrictions.allEq(Map propertyNameValues)使用Map key/value 进行多个等于的比对Restrictions.gt(String propertyName, Object value)大于 > (gt----->greater than)Restrictions.ge(String propertyName, Object value)大于等于 >= (ge----->greater equal)Restrictions.It(String propertyName, Object value)小于< (It---->less than)Restrictions.Le(String propertyName, Object value)小于等于<= (le---->less equal)Restrictions.between(String propertyName, Object lo, Object hi)对应SQL 语句的 Between 子句Restrictions.like(String propertyName, Object value)对应SQL 语句的 LIKE 子句Restrictions.in(String propertyName, Collection value)对应SQL 语句的 in 子句Restrictions.and(Criterion lhs, Criterion rhs)And关系Restrictions.or(Criterion lhs, Criterion rhs)Or关系Restrictions.sqlRestriction(String sql,Object[] values,Type[] types) SQL限定查询工具类Order 提供设置排序方式Order.asc(String propertyName)升序排序Order.desc(String propertyName)降序排序工具类Projections 提供对查询结果进行统计与分组操作Porjections.avg(String propertyName)求某属性的平均值Projections.count(String propertyName)统计某属性的数量Projections.countDistinct(String propertyName)统计某属性的不同值的数量Projections.groupProperty(String propertyName)指定一组属性值Projections.max(String propertyName)某属性的最大值Projections.min(String propertyName)某属性的最小值Projections.projectionList()创建一个新的projectionList 对象Projections.rowCount()查询结果集中记录的条数Projections.sum(String propertyName)返回某属性值的合计QBE查询QBE查询就是检索与指定样本对象具有相同属性值的对象。
Criteria查询
4.proList.add(Projections.max("price"));
5.proList.add(Projections.min("price"));
6.proList.add(Projections.avg("price"));
11.criteria.setProjection(proList);
12.Object values[]=(Object[])criteria.uniqueResult();
mit();
分组查询
Java代码
1.Transaction tx = session.beginTransaction();
8.List<Double> list=criteria.list();
mit();
投影查询
在一个表中有很多个字段，投影查询只是查询某一个或多个字段，也称局部查询
Java代码
1.Transaction tx = session.beginTransaction();
2.Criteria criteria=session.createCriteria(Testbook.class);
3.criteria.setProjection(Property.forName("price"));
4.criteria.add(Restrictions.gt("price",newDouble(40.0)))
5.List<Double> list=criteria.list();
hibernate学习笔记
Hibernate 学习笔记2010年7月9日星期五1目录1.学习纲要2.学习目的3.达标标准4.名词解释5.学习时间：两天又3小时(16~19pm)2具体内容2.1学习纲要2.1.1什么是hibernate?它是连接JAVA应用程序和关系数据库的中间件它对JDBC API进行了封装，负责JAVA对象的持久化在分层的软件架构中它位于持久化层，封装了所有数据访问细节，使业务逻辑层可以专注于实现业务逻辑。
它是一种ORM映射工具，能够建立面向对象的域模型和关系数据模型之间的映射2.1.2HIBERNATE原理依赖的技术有：JAVA反射机制（在org.hibernate.property中得到较多应用，通过INVORK()方法调用POJO对象的setter,getter方法设置和获取属性的值）i.Class类ii.getMethods方法得到Method类iii.Method类iv.invoke方法用来调用被反射类的方法CGLIB（用于对持久化类进行延迟加载时生成代理类）i.以asm项目为基础，对asm的功能进行封装和扩展，实现并扩展了JAVA的反射功能，可以在运行时状态下实现JAVA接口，扩展JAVA类ii.Asm项目是一个简洁的字节码工具，能够在运行的状态下动态的修改编译完成的JAVA类JAVASSIST（同CGLIB，是另一套解决方案，可以通过修改org.hibernate.cfg.Environment.java原码进行设置）i.是一个执行字节码操作的强有力的驱动代码库。
它允许开发者在代码被JAVA虚拟机载入之前定义一个新类或者修改类的的原代码。
XML技术（DOM4J）i.用来解析XML配置文件Antlr（another tool for language recognition）i.它是一个开源的工具，利用后缀为“.g”的文件来定义语法规则ii.Hibernate提供的语法规则有iii.Hql.giv.Hql-sql.gv.Sql-gen.gvi.Hibernate通过调用这些生成的解析类完成把HQL语句转为SQL语句的工作2.1.3HIBERNATE方法的内部实现略2.1.4Hibernate能做什么？2.1.5hibernate应用在哪些方面2.1.6Hibernate关联关系1.一对多关联<many-to-one name=”customer”column=”CUSTOMER_ID”class=”mypack.Customer”lazy=”false” not-null=”true”/>此种情况下不会加载关联的临时对象。
Criteria查询分析
User user = (User) it.next();
System.out.println("用户名：" + user.getName());
}
session.close();
sessionFactory.close();
Criteria查询表达式2-2
使用aS询ded条s(s)件添ionn加eFw查acCtoornyfisgeusrsaitoion返nF(a回).cc条toon件ryfi实g=u例re()
criteria.add(Restrictions.or(
Restrictions.eq("price", new Double(2300)),
Restrictions.like("title", "%地铁%")));
List result = criteria.list(); Iterator it = result.iterator(); while (it.hasNext()) {
}
session.close();
sessionFactory.close();
Restrictions常用限定查询方法
方法 Restrictions.eq()
Restrictions.allEq()
Restrictions.gt() Restrictions.ge() Restrictions.lt() Restrictions.le() Restrictions.between() Restrictions.like() Restrictions.in() Restrictions.and() Restrictions.or() Restrictions.not()
Hibernate学习总结
一．对象语言和操作数据库不匹配：模型不匹配（阻抗不匹配）①．可以使用JDBC手动转换；sql参数和jdbc中用对象赋值②．使用ORM（Object Relation Mapping对象关系映射）框架：hibernate 二．Hibernate安装配置①．配置文件Hibernate.cfg.xml和Hibernate.properties②．映射文件xxx.hbm.xml：对象模型和关系模型的映射三．开发流程1.由Domain Object -> mapping -> db2.有DB开始，用工具生成mapping和Domain Object3.由配置文件开始四．Domain Object限制1.默认的构造方法（必须的）2.有无意义的标示符id(主键) 可选3.非final的，对懒加载有影响可选Configuration SessionFactory Session Transaction Query CriteriaConfiguration类Configuration类负责配置并启动Hibernate，创建SessionFactory对象。
在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory 对象。
SessionFactory接口SessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理，并负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。
Criteria的几种查询方法使用
Criteria的几种查询方法使用Criteria的几种查询方法使用QBC常用限定方法Restrictions.eq --> equal,等于.Restrictions.allEq --> 参数为Map对象,使用key/value进行多个等于的比对,相当于多个Restrictions.eq的效果Restrictions.gt --> great-than > 大于Restrictions.ge --> great-equal >= 大于等于Restrictions.lt --> less-than, < 小于Restrictions.le --> less-equal <= 小于等于Restrictions.between --> 对应SQL的between子句Restrictions.like --> 对应SQL的LIKE子句Restrictions.in --> 对应SQL的in子句Restrictions.and --> and 关系Restrictions.or --> or 关系Restrictions.isNull --> 判断属性是否为空,为空则返回trueRestrictions.isNotNull --> 与isNull相反Restrictions.sqlRestriction --> SQL限定的查询Order.asc --> 根据传入的字段进行升序排序Order.desc --> 根据传入的字段进行降序排序MacthMode.EXACT :字符串精确匹配。
相当于like …value?MathMode.ANYWHERE:字符串在中间匹配.相当于like …%value%?MathMode.START:字符串在最前端匹配位置.相当于:like …value%?MatchMode.END:字符串在最后端匹配.相当于:like …%value?1.查询年龄在20-30之间的所有学生对象。
criteriaquery select 字段
criteriaquery select 字段CriteriaQuery是JPA规范中的一种查询方式，用于编写类型安全的查询语句。
它相比于传统的JPQL（Java Persistence Query Language）查询具有更高的可读性和可维护性，并且支持更多的查询功能。
CriteriaQuery的核心目标是创建类型安全的查询表达式。
它由两个主要组件组成：CriteriaBuilder和Root对象。
CriteriaBuilder是CriteriaQuery的工厂类，用来创建各种查询表达式的方法。
它提供了一系列方法来创建查询过滤条件、投影查询、排序等。
Root对象表示实体类的根节点，用于指定查询的主体。
通过Root对象，可以获取实体类的属性，并对其进行筛选、排序和投影查询。
通过CriteriaQuery的select方法，可以指定查询返回的字段。
select方法接受一个Selection类型的参数，Selection是一个通用的查询结果的表示，可以是列、实体类、元组等。
1.查询返回单个字段：```CriteriaBuilder criteriaBuilder =entityManager.getCriteriaBuilder();CriteriaQuery<String> query =criteriaBuilder.createQuery(String.class);Root<EntityClass> root = query.from(EntityClass.class);query.select(root.get("fieldName"));```这段代码使用CriteriaBuilder的createQuery方法创建一个String类型的查询，通过Root对象获取实体类的字段名，并使用select方法指定返回的字段。
2.查询返回多个字段：```CriteriaBuilder criteriaBuilder =entityManager.getCriteriaBuilder();CriteriaQuery<Object[]> query =criteriaBuilder.createQuery(Object[].class);Root<EntityClass> root = query.from(EntityClass.class);query.select(criteriaBuilder.array(root.get("field1"), root.get("field2")));```这段代码使用CriteriaBuilder的createQuery方法创建一个Object[]类型的查询，通过Root对象获取实体类的多个字段，并使用select方法指定返回的字段。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Criteria 实现聚合统计 用 Projection(投射)对象
1）得到Criteria对象
2)调用Criteria对象的setProjection方法设置投射，其中投射对象是用
Projections对象的静态方法获得的。
创建criteria对象（条件对象）------等价于Query对象
代码： Criteria cr= se.createCriteria(Street.class);
3）调用criteria的 add方法 添加规则对象（封装表达式条件的对象）
其中规则对象是用Restrictions类的静态方法获得的
/*cr.add(Restrictions.eq("username", u.getUsername()));
cr.add(Restrictions.eq("password", u.getPassword()));*/
cr.add(Example.create(u));//就等价于上边两句注释的代码
//设置投射对象， 用Projections的静态方法获得投射对象
cr.setProjection(Projections.avg("price"));//平均值
List s= cr.list();
System.out.println(s.get(n(Projections.rowCount());//统计行数
s= cr.list();
System.out.println(s.get(0));
例如Projections.avg("price") 意思就是求price的平均值。
示例：
Session se = DaoUtil.getSessionFactory().openSession();
Criteria cr = se.createCriteria(House.class);
List result = cr.list();
Criteria排序 它是给Criteria对象添加排序对象。
步骤： 用你的Criteria对象的 cr.addOrder方法添加Order对象。
其中Order对象 是通过Order类的静态方法asc desc得到的
map.put("username","zhangsir");
cr.add(Restrictions.allEq(map));
执行查询cr.list;
Example 简化条件查询，以实体类作为等值查询条件：
它会按照实体对象中除ID以外的非空属性的值，
代码: cr.add(Restrictions.eq("name", "中华大街"));
4)调用criteria.list()方法执行查询 ----等价于query对象的list()
5）关闭 session......
补充：Restrictions.allEq(map)
（按照eq 等于）创建规则对象（表达式对象）。
方式：Example的静态方法 Example.create(传实体类对象);
例如
Usersx u = new Usersx();
u.setUsername("zhangsan");
u.setPassword("12345");
//----------做查询以前是dao中传入的上面这样一个实体
Session se = DaoUtil.getSessionFactory().openSession();
Criteria cr = se.createCriteria(Usersx.class);
Criteria:它是hibernate提供的一个纯面向对象的查询方式。
它将查询条件封装成了对象的形式
Criteria执行查询的使用步骤：
1)创建session对象..
2)通过session.createCriteria(传入实体类类型如:Street.class)；
语法： cr.addOrder(Order.desc("实体类的属性名"));
这样就按照这个属性降序
分页：
和Query分页一样。
在执行list方法之前，
调用Criteria对象的setFirstResult方法设置起始行位置
用setMaxResults方法设置最大返回的行数。
他生成一个查询条件是 按照map中所有的key值表达的属性名，以及对应的
值，按照等于做条件
比如 查Usersx, 我想查name是“张三”而且
username是 "zhangsir"的数据
Map map = new HashMap();
map.put("name","张三");