使用Hibernate查询数据
hibernate的基本用法
hibernate的基本用法Hibernate是一个开源的Java框架,用于简化数据库操作。
它为开发人员提供了一个更加简单、直观的方式来管理数据库,同时也提高了应用程序的性能和可维护性。
本文将逐步介绍Hibernate的基本用法,包括配置、实体映射、数据操作等。
一、配置Hibernate1. 下载和安装Hibernate:首先,我们需要下载Hibernate的压缩包并解压。
然后将解压后的文件夹添加到Java项目的构建路径中。
2. 创建Hibernate配置文件:在解压后的文件夹中,可以找到一个名为"hibernate.cfg.xml"的文件。
这是Hibernate的主要配置文件,我们需要在其中指定数据库连接信息和其他相关配置。
3. 配置数据库连接:在"hibernate.cfg.xml"文件中,我们可以添加一个名为"hibernate.connection.url"的属性,用于指定数据库的连接URL。
除此之外,还需要指定数据库的用户名和密码等信息。
4. 配置实体映射:Hibernate使用对象关系映射(ORM)来将Java类映射到数据库表。
我们需要在配置文件中使用"mapping"元素来指定实体类的映射文件。
这个映射文件描述了实体类与数据库表之间的对应关系。
二、实体映射1. 创建实体类:我们需要创建一个Java类,用于表示数据库中的一行数据。
这个类的字段通常与数据库表的列对应。
同时,我们可以使用Hibernate提供的注解或XML文件来配置实体的映射关系。
2. 创建映射文件:可以根据个人喜好选择使用注解还是XML文件来配置实体类的映射关系。
如果使用XML文件,需要创建一个与实体类同名的XML文件,并在其中定义实体类与数据库表之间的映射关系。
3. 配置实体映射:在配置文件中,我们需要使用"mapping"元素来指定实体类的映射文件。
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()+"'";。
hibernate使用from (select ……)子查询的方法
今天徒弟用到了一句复杂的查询语句。
结果执行报错,但是在SQL中执行没有问题,于是来求助我了。
语句的HQL/SQL格式如下:select count(1) ,cxltype,sum(dzsje),sum(iperson)from (selectxl.cxltype,g.iperson,(select sum(y.dzsje) from Ysklist as y wherey.cykpid = g.cregno) as dzsje from Guestreg as g,Xl as xl where g.xluuid = xl.uuid ) as t where …… group by t.cxltype结果执行出错,最终发现,HQL无法支持from后面跟子查询的方式,网上查了N 多资料,发现遇到这个问题的人还真是不少,但每一个相关的问题帖都没有满意的答复,甚至于多数都是没有跟帖的。
一阵心寒,hibernate叱咤风云,竟然对这个支持如此之弱?虽然这个语句可以通过另外的方法来做(比如建视图或者直接使用SQL来做),但总是不甘心,于是又开始查阅各处资料,最后找到了思路,觉得既然HQL不支持,那么只能把这种子查询封装为对象来做了,那么肯定是需要hbm配置这种临时的子查询对象的,于是开始着手hbm配置的资料中查,hbm中配置对象的都是class标签,开始把范围缩小,针对hbm的class标签的属性资料开始翻查,找到了几个比较可能的属性,where、subselect、mutable、entity-bean,貌似这些都可能跟临时对象有关。
于是反复尝试,并继续翻查资料最终在Hibernate reference 3.2.0 ga 正式版中文参考手册中找到了一些比较可靠的资料:5.1.3. class你可以使用class元素来定义一个持久化类:<classname="ClassName"table="tableName"discriminator-value="discriminator_value"mutable="true|false"schema="owner"catalog="catalog"proxy="ProxyInterface"dynamic-update="true|false"dynamic-insert="true|false"select-before-update="true|false"polymorphism="implicit|explicit"where="arbitrary sql where condition"persister="PersisterClass"batch-size="N"optimistic-lock="none|version|dirty|all"lazy="true|false"entity-name="EntityName"check="arbitrary sql check condition"rowid="rowid"subselect="SQL expression"abstract="true|false"node="element-name"/>name (可选): 持久化类(或者接口)的Java全限定名。
hibernate like查询语句
Hibernate Like查询语句在Hibernate中,可以使用HQL (Hibernate Query Language) 或Criteria API 进行查询。
如果您想要进行"like" 查询,这取决于您的需求和您正在使用的具体查询语言。
1.使用HQL进行"like"查询:javaString hql = "FROM Employee WHERE name LIKE :pattern";Query query = session.createQuery(hql);query.setParameter("pattern", "%" + nameToSearch + "%");List results = query.list();在这里,:pattern是一个参数,它将在运行时被替换为nameToSearch的值。
%是SQL的通配符,表示任何数量的任何字符。
2.使用Criteria API进行"like"查询:javaCriteria criteria = session.createCriteria(Employee.class);criteria.add(Restrictions.like("name", nameToSearch,MatchMode.ANYWHERE));List results = criteria.list();在这里,我们使用了Restrictions.like方法,它允许我们执行一个"like"查询。
MatchMode.ANYWHERE表示我们想要在任何位置匹配搜索字符串。
请注意,这些示例假设您正在使用Hibernate 5或更高版本。
如果您使用的是早期版本,语法可能会略有不同。
hibernate envers对历史数据的记录
hibernate envers对历史数据的记录Hibernate Envers是一个开源的Java框架,用于对应用程序中的实体对象进行版本控制和审计。
它通过记录实体对象的修改历史,并将历史数据存储在数据库中,可以追踪对象的变化,并提供了一种简单的方式来查询和还原历史数据。
Hibernate Envers的历史记录功能有助于满足一些重要需求,例如数据审计、版本控制、追踪数据变更以及生成数据报告。
下面将详细介绍Hibernate Envers对历史数据的记录。
1.审计表的创建在启用Hibernate Envers之后,为每个要进行历史记录的实体对象创建一个审计表。
审计表的结构与原始实体表相似,但包含了额外的字段来记录历史数据的相关信息,如修改时间、修改者等。
每次对实体对象进行修改时,Hibernate Envers会将原始数据插入到审计表中。
2.修改历史的记录Hibernate Envers使用拦截器来捕获实体对象的修改操作。
当开发人员保存或更新实体对象时,拦截器会将修改操作的详细信息传递给Hibernate Envers,并将原始数据插入到审计表中。
该历史数据包含实体对象修改前的所有属性值,以及修改操作的时间戳和修改者信息。
3.修订信息的管理每个修改历史记录都称为一个修订版本。
修订版本包含了与修改操作相关的详细信息,并通过一个唯一的修订号来标识。
修订号可以用来查询、比较和还原历史数据。
Hibernate Envers为每个实体对象的修订版本维护了一个修订号序列,使得开发人员可以轻松地跟踪和管理修订信息。
4.历史数据的查询Hibernate Envers提供了一套简单而强大的API来查询历史数据。
使用这些API,开发人员可以根据实体对象、修订号、时间戳等条件来查询历史数据。
查询结果包含了与指定条件匹配的所有历史记录。
开发人员可以使用这些历史记录来查看对象在过去的状态、比较不同修订版本之间的变化以及还原历史数据。
hql语法
hql语法HQL(Hibernate Query Language)是Hibernate框架提供的一种面向对象的查询语言,它类似于SQL,但是是针对对象进行查询的,而不是针对数据表操作的。
HQL语法非常类似于SQL语法,只不过它是面向对象的查询语言。
以下是一些常用的HQL语法,在此进行详细介绍。
1. 查询所有数据HQL语句:from 实体类对象说明:使用from关键字可以查询指定实体类所有记录,这里的实体类是指映射到数据库表的Java类,实体类对象是Java类的实例化对象。
例如:from Employee说明:查询Employee表的所有记录。
说明:使用where子句可以指定查询条件,属性名称是指实体类中的某个属性名,属性值是指该属性所对应的值。
3. 查询满足多个条件的数据HQL语句:from 实体类对象 where 属性名称1=属性值1 and 属性名称2=属性值2说明:使用and关键字可以同时指定多个查询条件。
from Employee where name='Tom' and age=254. 查询包含某个值的数据说明:使用like关键字可以查询包含某个值的记录,%表示任意字符。
5. 查询指定字段数据6. 使用聚集函数查询说明:使用聚集函数可以进行统计查询。
7. 连接查询说明:使用join可以进行连接查询,使用on子句指定连接条件。
from Employee e inner join e.department d on e.departmentId=d.id8. 分组查询9. 排序查询说明:使用order by进行排序查询,可以指定升序或降序,默认为升序。
综上所述,HQL语法与SQL语法相似,可以使用各种关键字进行高级查询,对查询结果进行聚合计算、排序、分组、分页等各种操作,可满足日常开发中绝大部分查询需求。
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对象。
hibernate查询数据库的三种方式
Hibernate查询数据库的三种方式一、Hibernate的HQL与SQL查询1.Hql(Hibernate Query Language)是面向对象的查询查询方式,HQL查询提供了更加丰富的和灵活的查询特性,因此Hibernate将HQL查询方式立为官方推荐的标准查询方式,提供了类似标准SQL语句的查询方式,同时也提供了面向对象的封装。
HQL查询语句from关键字后面跟的类名+类对象,where后用对象的属性做条件;示例代码:(User是映射数据库的一个类)public boolean checkUser(UserForm userForm){//TODO Auto-generated method stub//String HQLString="from User u whereername='"+userForm.getUsername()+"'";String HQLString="from User u where ername=:uname";Session session=HibernateSessionFactory.currentSession();//获取事务session.beginTransaction();Query query=session.createQuery(HQLString);query.setParameter("uname",userForm.getUsername());//绑定参数Object list=query.list().get(0);//list获取数据集,get获取数据集的某条记录//提交事务session.getTransaction().commit();//关闭SessionHibernateSessionFactory.closeSession();User user=(User)list;if(user.getPassword().equals(userForm.getPassword())){return true;}else{return false;}}2.sql是面向数据库表查询,from后面跟的是表名,where后用表中字段做条件;示例代码:([xxdb].[dbo].[student]就是要查询的数据库表)public boolean checkUser(UserForm userForm){//TODO Auto-generated method stub//String SQLString="select*from[xxdb].[dbo].[student]u whereerName='"+userForm.getUsername()+"'";String SQLString=”select*from[xxdb].[dbo].[student]u whereerName=:uname”;Session session=HibernateSessionFactory.currentSession();session.beginTransaction();//Query query=session.createSQLQuery(SQLString).addEntity(User.class);//实体查询Query query=session.createSQLQuery(SQLString).addScalar("userid",StandardBasicTypes.INTEGER).addScalar("username",StandardBasicTypes.STRING).addScalar("password",StandardBasicTypes.STRING).addScalar("gender",StandardBasicTypes.INTEGER);//标量查询query.setParameter("uname",userForm.getUsername());//绑定参数Object list=query.list().get(0);//list获取数据集,get获取数据集的某条记录session.getTransaction().commit();HibernateSessionFactory.closeSession();User user=(User)list;if(user.getPassword().equals(userForm.getPassword())){return true;}else{return false;}}3.对比hql和sql查询方式我们可以发现他们之间的不同:a.首先是查询语句的不同,hql语句from后面跟的类名+类对象,where后用对象的属性做条件,而sql语句from后面跟的是表名,where后用表中字段做条件,这也就是面向对象和面向数据库的一个区别。
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();。
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多个字段了。
有没有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查询。
这些查询方式都使用内连接的方式进行关联查询,可以保证查询结果的准确性。
HibernateHQL--实体、属性查询,全参数绑定,引用查询
是Hibernate官方推荐的查询模式,比Criteria功能更强大。
1)实体查询:出现类名和属性名必须注意大小写区分;当不同路径下存在相同类名,需要写入在hql中写入包名;查询目标实体存在着继承关系,将查询目标的所有子类的库表记录一起返回。
String hql = “from TUser”;Query query = session.createQuery(hql);List list = query.list();2)属性查询:有时页面不需要取整个对象,而只取某个属性。
List list = session.createQuery(“select user.age from TUser user”).list();Iterator it = list.iterator();while(it.hasNext()){//返回的list中,每个条目都是一个对象数组,依次包含我们所获取的数据。
Object[] results = (Object[])it.next();System.out.println(results[0]);System.out.println(results[1]);}注:如果觉得返回数组的方式不够灵活,可以在HQL中构造对象实例。
List list = this.session.createQuery(“select new TUser(,user.age) from TUser user”).list();Iterator it = list.iterator();while(it.hasNext()){TUser user = (TUser)it.next();System.out.println(user.getName());}注:通过HQL动态构造对象实例,此时查询结果中的TUser对象只是一个Java对象,仅用于对查询结果的封装,除了在构造时赋予的属性值之外,其他属性均为未赋值状态,当我们通过session对此对象进行更新,将导致对user对象的数据库插入一条新数据,而不是更新原有对象。
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查询就是检索与指定样本对象具有相同属性值的对象。
hibernate hql语法
Hibernate HQL(Hibernate Query Language)是Hibernate框架中的一种查询语言,类似于SQL,但它使用的是对象和属性的名称而不是表和列的名称。
HQL提供了丰富的查询语法,用于执行各种数据库操作,如CRUD操作、联接、分组、排序等。
以下是一些HQL的基本语法示例:1. 查询所有实体:java复制代码from EntityName2. 带条件的查询:vbnet复制代码from EntityName where propertyName = 'value'3. 排序查询结果:vbnet复制代码from EntityName order by propertyName asc/desc4. 分组查询结果:vbnet复制代码select propertyName, count(*) from EntityName group by propertyName5. 联接查询:vbnet复制代码select e.propertyName, d.propertyName from EntityName e join e.propertyName d where d.propertyName = 'value'6. 分页查询:java复制代码from EntityName where propertyName = 'value' order by propertyName desc limit 0, 107. 更新实体:sql复制代码update EntityName set propertyName = 'newValue'where propertyName = 'value' 8. 删除实体:sql复制代码delete from EntityName where propertyName = 'value'除了基本的语法外,HQL还支持一些高级特性,如子查询、聚合函数、CASE语句等。
hibernate的addscalar方法
hibernate的addscalar方法Hibernate的addScalar方法是用来指定查询结果中要返回的标量值(非实体对象)的方法。
它可以在查询中的SELECT语句中使用,并且需要指定要返回的标量值的列名和数据类型。
addScalar方法的语法为:public <T> Query addScalar(String columnAlias, Class<T> type)其中,参数columnAlias指定要返回的标量值的列名,type指定要返回的标量值的数据类型。
addScalar方法可以在SQLQuery对象或者原生SQL语句中使用。
通过使用addScalar方法,可以将查询结果转换为指定的数据类型,而不仅仅限于Hibernate映射的实体对象。
以下是一个使用addScalar方法的示例:String sql = "SELECT name, age FROM User";Query query = session.createSQLQuery(sql).addScalar("name", StringType.INSTANCE).addScalar("age", IntegerType.INSTANCE);List<Object[]> results = query.list();for (Object[] result : results) {String name = (String)result[0];int age = (int)result[1];// ...}在上面的示例中,查询结果包含name和age两列,通过addScalar方法指定了name列的数据类型为StringType.INSTANCE(Hibernate提供的字符串数据类型)和age列的数据类型为IntegerType.INSTANCE (Hibernate提供的整数数据类型)。
hibernate createnativequery 使用
hibernate createnativequery 使用摘要:一、Hibernate 简介1.Hibernate 介绍2.Hibernate 的作用二、Hibernate 的NativeQuery 使用1.NativeQuery 概述2.NativeQuery 的使用场景3.NativeQuery 的优点和缺点三、Hibernate CreateNativeQuery 方法1.CreateNativeQuery 方法定义2.方法参数说明3.方法使用示例四、Hibernate CreateNativeQuery 应用实例1.实例一:使用CreateNativeQuery 查询数据2.实例二:使用CreateNativeQuery 更新数据3.实例三:使用CreateNativeQuery 删除数据正文:Hibernate 是一个开源的持久化框架,主要用于将Java 对象映射到关系型数据库中,从而实现数据持久化。
它将Java 对象与数据库表之间的映射关系以及数据库操作进行了抽象,简化了开发者在数据库操作方面的复杂性。
在Hibernate 中,有一个非常重要的功能就是NativeQuery 的使用。
NativeQuery 允许开发者使用JDBC 语句直接操作数据库,这在某些特定场景下非常有用。
例如,当需要执行复杂查询、存储过程或事务处理时,使用NativeQuery 可以提供更大的灵活性。
Hibernate 提供了CreateNativeQuery 方法,用于创建一个NativeQuery 对象。
CreateNativeQuery 方法接收一个字符串参数,即SQL 语句或命名查询,根据这个参数创建一个NativeQuery 对象。
然后,可以通过这个NativeQuery 对象执行查询、更新、删除等数据库操作。
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 语句的数据库依赖性。
hibernate query占位符参数循环处理
hibernate query占位符参数循环处理(实用版)目录1.Hibernate 查询概述2.占位符参数3.循环处理4.实际应用示例正文1.Hibernate 查询概述Hibernate 是一款流行的 Java 框架,用于将数据库中的数据与Java 对象进行映射。
在 Hibernate 中,我们可以通过编写查询语句(Query)来实现对数据库的操作,例如查询、插入、更新和删除等。
2.占位符参数在编写查询语句时,我们常常需要将某些变量或表达式的值传递给查询,以便根据不同的条件来检索数据。
在 Hibernate 中,我们可以使用占位符参数(placeholder)来实现这一目的。
占位符参数用大括号{}表示,可以出现在查询语句的任何位置。
例如,我们可以编写一个简单的查询语句,根据传入的整数值来检索对应的用户信息:```javaString hql = "from User where age = {age}";```3.循环处理在某些场景下,我们需要处理多个占位符参数。
例如,假设我们需要根据传入的多个年龄值来检索符合条件的用户信息。
为了实现这一功能,我们可以使用循环来处理占位符参数。
以下是一个使用循环处理多个占位符参数的示例:```javaString hql = "from User where age in {ages}";List<Object> params = new ArrayList<>();params.add(18);params.add(25);params.add(30);// 将参数列表转换为占位符参数字符串String[] placeholders = new String[params.size()];for (int i = 0; i < params.size(); i++) {placeholders[i] = "{ages[" + i + "]}";}// 将占位符参数字符串添加到查询语句中hql = hql.replace("{ages}", String.join(", ", placeholders));```4.实际应用示例假设我们有一个 User 实体类,包含 id、name 和 age 属性。
JavaWeb_(Hibernate框架)Hibernate中数据查询语句SQL基本用法
JavaWeb_(Hibernate框架)Hibernate中数据查询语句SQL基本⽤法本⽂展⽰三种在Hibernate中使⽤SQL语句进⾏数据查询基本⽤法 1、基本查询 2、条件查询 3、分页查询package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}//SQL条件查询public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}//SQL分页查询public void find3(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user limit ? , ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, 0);//同理query.setParameter(2, 2);query.addEntity(User.class);//唯⼀返回值List<User> list = query.list();System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}}SQLDao.java 数据库user表 向数据库中添加假数据1、SQL基本查询 //开始进⾏SQL查询 String sql = "select * from user"; //创建sql查询对象 NativeQuery query = session.createSQLQuery(sql); query.addEntity(User.class); SQLDao.java向数据库发起查询请求public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}}SQLDao.java2、SQL条件查询//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class); SQLDao.java向数据库发起查询请求public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}}SQLDao.java3、SQL分页查询 //开始进⾏SQL查询 String sql = "select * from user limit ? , ?"; //创建SQL查询对象 NativeQuery query = session.createSQLQuery(sql); //封装参数,给第⼀个?赋值 query.setParameter(1, 0); //同理 query.setParameter(2, 2); query.addEntity(User.class); //唯⼀返回值 List<User> list = query.list(); SQLDao.java向数据库发起查询请求//SQL分页查询public void find3(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user limit ? , ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, 0);//同理query.setParameter(2, 2);query.addEntity(User.class);//唯⼀返回值List<User> list = query.list();System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}//SQL条件查询public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}//SQL分页查询public void find3(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user limit ? , ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, 0);//同理query.setParameter(2, 2);query.addEntity(User.class);//唯⼀返回值List<User> list = query.list();System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}}SQLDao.java。
hibernate-聚合函数分组统计数据查询
hibernate-聚合函数分组统计数据查询聚合函数:实例:package Test;import static org.junit.Assert.*;import java.util.List;import org.hibernate.Session;import org.junit.Test;import entity.AvgSal;import util.HibernateSessionFactory;import util.HibernateUtil;public class AggTest {/*** 统计部门个数。
*/@Testpublic void test1() {Session session =HibernateSessionFactory.getSession();try {Long count = (Long) session.createQuery("select count(d) from Dept d").uniqueResult();System.out.println("共有"+count+"个部门。
");} catch (Exception e) {e.printStackTrace();System.out.println("失败");}}/*** 统计员⼯⼯资。
*/@Testpublic void test2() {Session session =HibernateSessionFactory.getSession();try {Double totalsal = (Double) session.createQuery("select sum(e.sal) from Emp e").uniqueResult();System.out.println("员⼯⼯资总数为:"+totalsal);} catch (Exception e) {e.printStackTrace();System.out.println("失败");}}/*** 统计员⼯最低⼯资。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
在HQL语句中设定查询条件,可使用如表所示各种运算。
类型 比较运算 范围运算 HQL运算符 =、<>、>、>=、<、<=、is null、is not null in、not in、between、not between
7
14.1.4 分组查询
在 测 试 类 HibernateTest 中 添 加 testHql_4() 方 法 , 并 使 用 @Test注解修饰,以餐品菜系为分组依据对所有餐品进行分 组,查询数据表meal中各种类型的餐品总数,代码如下:
// 分组统计餐品的菜系总数 String hql="select m.mealseries.seriesName,count(*) from Meal m group by m.mealseries"; Query query= session.createQuery(hql); List list=query.getResultList() ; // 遍历查找结果 Iterator iterator=list.iterator(); while (iterator.hasNext()) { Object[] object=(Object[])iterator.next(); System.out.println(“菜系:"+ object[0] + ",餐品总数 :"+ object[1]);
6
14.1.3 聚集函数
在 HQL 语句中可以使用的聚集函数包括统计记录总数( // 使用 count 统计餐品的记录总数 count )、计算最小值( min)、计算最大值(max)、计算 String hql1="select count(m) from Meal m"; 和( sum)、计算平均值(avg)。 Query query1= session.createQuery(hql1);
逻辑运算
模式匹配
and(逻辑与)、or(逻辑或)、not(逻辑非)
like
12
14.1.8 连接查询
HQL支持各种连接查询,例如:内连接、外连接和交叉连 接等。 1.内连接 内连接是指两个表中指定的关键字相等的值才会出现在查 询结果集中的一种查询方式。在 HQL 中,使用关键字“ inner join”进行内连接。在测试类HibernateTest中添加testHql_9()方 法,并使用@Test加以修饰,从数据表meal中查询菜系为“川 菜”的餐品信息。 String hql = "from Meal as m inner join m.mealseries as ms where ms.seriesName='川菜'"; HQL语句中使用inner join进行内连接,查询返回的结果并 不是 Meal 对象(虽然 from 关键字后面只有 Meal ),而是一个 对 象 数 组 , 对 象 数 组 中 的 第 一 列 是 Meal 对 象 , 第 二 列 是 13 Mealseries对象。
Long count=(Long)query1.uniqueResult(); 在实体类 Meal.java中有一个属性mealPrice,在映射文件中 // 使用avg 统计餐品的平均价 Meal.hbm.xml 中已经为 Meal.java中的属性 mealPrice 配置了 String hql2="select avg(m.mealPrice) from Meal m"; Query session.createQuery(hql2); 映 射 , query2= 对应数据 表 meal 中 的 MealPrice 字 段 。 在 测 试 类 Double money=(Double)query2.uniqueResult(); HibernateTest testHql_3()方法,并使用@Test注解加 // 使用max 和中添加 min 统计最贵和最便宜的餐品 String hql2="select max(m.mealPrice),min(m.mealPrice) 以修饰,代码如下: from Meal m"; Query query3= session.createQuery(hql3); Object[] price=(Object[])query3.uniqueResult(); System.out.println("记录总数:" +count+ ",平均金额:" +money+ ",最低价格为:"+price[0] +",最高价格为:"+price[1]);
直接针对实体类和属性进行查询,不要再编写繁琐的SQL语句。 查询结果是直接保存在List中的对象,不要再次封装。 可以通过配置dialect属性,对不同的数据库自动生成不同的用于 执行的SQL语句。
4
14.1.1 简单查询
import org.hibernate.query.Query; 从数据表 meal中查询所有的产品对象,按照名称升序排序 …… ,将查询结果输出到控制台。 @Test public void testHql_1(){ 将项目 hibernate-3 复制并命名为“hibernate-10”,再导入 // 编写HQL 语句 到 MyEclipse 开发环境中。在测试类 HibernateTest 中添加 String hql = "from Meal as m order by m.mealName asc"; testHql_1() @Test注解加以修饰。代码如下: // 创建方法,并使用 Query对象 Query<Meal> query= session.createQuery(hql,Meal. class); String hql = "from Meal as m order by m.mealName asc"; // 执行查询,获得结果 HQL 语句“from Meal as m”中Meal是类名,而不是表名 List<Meal> list=query.getResultList() ; // 遍历查找结果 ,因此需要区分大小写,关键字 from不区分大小写。 Iterator<Meal> iterator=list.iterator(); 在HQL 语句中可以使用别名,例如 while (iterator.hasNext()) { m 是 Meal 类的别名,别 Meal meal as = iterator.next(); 名可以使用关键字 指定,as关键字也可以省略。 System.out.println(meal.getMealId()+". " + meal 通过order + by" 子句将查询结果按照餐品名称升序排序。升序 .getMealName() :\t" + meal .getMealSummarize()); } 排序的关键字是 asc,降序排序的关键字是desc,查询语句 }
m.getMealName()); } Query<Meal> query= session.createQuery(hql,Meal.class);
在HQL语句中使用了 Meal类的带餐品 Id号和餐品名称两个 参数的构造方法,因此需要在实体类 Meal 类中添加这个构 造方法。
9
14.1.6 分页查询
第14章 使用Hibernate 查询数据
目
1
录
使用HQL查询数据 使用QBC查询数据
2
2
14.1
使用HQL查询数据
3
14.1 使用HQL查询数据
HQL(Hibernate Query Language)是Hibernate提供的一 种面向对象的查询语言, HQL 提供了更加丰富灵活的特性 ,提供了强大的查询能力。在Hibernate中,将HQL作为推 荐的查询模式,使用类、对象和属性概念,没有表和字段 的概念。HQL提供了更接近传统SQL语句的查询语法。 使用传统的JDBC API来查询数据,需要编写复杂的SQL语 句,然后还要将查询结果以对象的形式进行封装,放到集 合对象中保存。这种查询方式不仅麻烦,而且容易出错。 HQL查询与JDBC查询相比,具体以下优点:
然后在测试类 HibernateTest 中添加 testHql_6() 方法,并使 用@Test注解加以修饰,调用pagedSearch方法。 10
14.1.7 条件查询
实际应用中,常常需要根据指定的条件进行查询。此时, 可以使用 HQL 语句提供的 where 子句进行查询,或者使用 like关键字进行模糊查询。 根据提供的参数形式,条件查询有两种:按参数位置查询 和按参数名字查询。 1.按参数位置查询 按参数位置查询时,在HQL语句中需要使用“?”来定义参 数的位置。在测试类HibernateTest中添加testHql_7()方法,并 使用@Test注解加以修饰,按照参数位置查询的方式,查询产 品名称包含“鱼”的餐品信息。语句如下:
中默认为升序。
5
14.1.2 属性查询
简单查询的结果是对象的所有属性,如果只查询对象的部 分属性,则称为属性查询,也称为投影查询。在测试类 @Test HibernateTest中添加testHql_2()方法,并使用@Test注解加 public void testHql_1(){ 以修饰,代码如下: // 编写HQL语句,使用属性查询