Hibernate 中的HQL查询的总结(夏杰)

hibernate的查询SQL,HQL,QBC。

最早接触Hibernate是在2004年，当时怀着忐忑和不安的心情来学习这门技术。

经过这几年的使用和研究，也积累了一定的经验，下面就HQL和QBC查询来谈一下我从工作中得到的一些总结。

本文不会讲什么是Hibernate、什么是ORM、更不会谈怎样使用HQL与QBC.本文的目的是让大家对平常使用最多，也是最广泛的与数据库打交道的两种方式，有一个新的认识。

恩，如果你还不知道Hibernate，大象建议你先去学一下再来看本文，如果你已经是这方面的高手，大可以关掉浏览器，千万不要因为本人的愚见，让你对大象口诛笔伐，进行人身攻击。

HQL和QBC都是查询检索的方式，最开始，我一直使用的都是HQL，因为以前一直用的都是SQL，觉得这东西和SQL差不多，上手很快。

后来又用QBC，因为QBC是基于接口和类的对象化查询，使代码变得很清晰，很整洁。

下面是查询用户表中，id为2，年龄等于21，并且名字以J开头的两种查询语句，它们的结果都是一样，只是不同的表现方式。

HQL:Query query = session.createQuery("from User u where u.id = 2 and u.age = 21 and like 'J%'");List list = query.list();QBC：Criteria criteria = session.createCriteria(User.class);List list = criteria.add(Expression.eq("id", 2)).add(Expression.eq("age", 2)).add(Expression.like("name", "J%")).list();如果查询再复杂一点，需要关联多张表，那上面这个HQL语句就会显得很复杂，比较难以阅读。

1. 查询整个映射对象所有字段//直接from查询出来的是一个映射对象，即：查询整个映射对象所有字段String hql = "from Users";Query query = session.createQuery(hql);List<Users> users = query.list();for(Users user : users){System.out.println(user.getName() + " : " + user.getPasswd() + " : " + user.getId());}输出结果为：name1 : password1 : 1name2 : password2 : 2name3 : password3 : 32.查询字段//查询其中几个字段String hql = " select name,passwd from Users";Query query = session.createQuery(hql);//默认查询出来的list里存放的是一个Object数组List<Object[]> list = query.list();for(Object[] object : list){String name = (String)object[0];String passwd = (String)object[1];System.out.println(name + " : " + passwd);}输出结果为：name1 : password1name2 : password2name3 : password33.修改默认查询结果(query.list())不以Object[]数组形式返回，以List形式返回//查询其中几个字段,添加new list(),注意list里的l是小写的。

hibernate使⽤sql进⾏查询在我们的hibernate中，除了我们常⽤的HQL查询以外，还⾮常好的⽀持了原⽣的SQL查询，那么我们既然使⽤了hibernate，为什么不都采⽤hibernate推荐的HQL查询语句呢？这是因为HQL查询语句虽然⽅便我们查询，但是基于HQL的查询会将查询出来的对象保存到hibernate 的缓存当中，如果在我们的⼀个⼤型项⽬中(数据量超过了百万级)，这个时候如果使⽤hibernate的HQL查询的话，会⼀次将我们查询的对象查询出来后放到缓存中，这个时候会影响我们的效率，所以当在⼤型项⽬中使⽤hibernate时我们的最佳实践就是--使⽤原⽣的SQL查询语句，⽽不使⽤HQL语句，因为通过SQL查询的话，是不会经过hibernate的缓存的。

接下来我们就来看看hibernate的原⽣SQL查询1.标量查询在hibernate中，我们如果使⽤原⽣SQL查询的话，是通过SQLQuery接⼝进⾏的，我们⾸先来看看我们最基本的查询：session.createSQLQuery("select * from t_student s").list()session.createSQLQuery("select ID,NAME,SEX from t_student s").list()这就创建了最简单的两条SQL查询语句，此时返回的数据库表的字段值是保存在⼀个Object[]数组中的，数组中的每个元素就是查询出来的t_student表中的每个字段值，Hibernate会通过ResultSetMetadata来判断每个字段值的存放位置以及类型，接下来我们看下标量查询：List<Object[]> stus = (List<Object[]>)session.createSQLQuery("select * from t_student s").addScalar("ID").addScalar("NAME").setFirstResult(0).setMaxResults(20).list();这个查询语句指定了查询的字符串以及返回的字段和类型这条查询语句仍然会返回⼀个Object[]类型的数组，但是此时就不会通过ResultSetMetadata，⽽是我们明确指定的ID,NAME,SEX，此时虽然查询语句中有 * 将所有的字段查询出来，但是这个时候仅仅只会返回我们指定的三个字段值，其类型还是由ResultSetMetada来指定的。

Hibernate中使⽤HQL语句进⾏增,删,改,查Hibernate的所有的操作都是通过Session完成的.基本步骤如下:1:通过配置⽂件得到SessionFactory: ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); SessionFactory sessionFactory = (SessionFactory)applicationContext.getBean("sessionFactory"); //以上配置基于spring主配置⽂件配置的⽅式2:通过SessionFactory 得到⼀个SessionSession session=sessionFactory.openSession();3:通过session进⾏插⼊,删除,修改以及查询.插⼊例⼦:(1)声明⼀个事务;(2)Session执⾏save()操作;(3)事务提交;(4)关闭Session,可选.public void insert(Person p){ Transaction tran=session.beginTransaction(); session.save(p);mit(); //session.close();}修改例⼦:(1)声明⼀个事务;(2)Session执⾏update()操作;(3)事务提交;(4)关闭Session,可选.public void update(Person p){ Transaction tran=session.beginTransaction(); session.update(p); mit(); // session.close(); }通过瞬时对象修改数据JobBean aJob=new JobBean();aJob.setJobId(17);aJob.setJobDesc("编辑⼯作1");aJob.setMaxLvl(10);aJob.setMinLvl(10);s.update(aJob);mit();通过持久对象修改数据JobBean aJob=(JobBean)s.get(JobBean.class, 17);aJob.setJobDesc("编辑⼯作2");mit();持久对象 脱管对象JobBean aJob=(JobBean)s.get(JobBean.class, 17);s.evict(aJob);aJob.setJobDesc("编辑⼯作3");//这个修改不会反应到数据库mit();删除例⼦(主键删除,推荐使⽤):(1) 声明删除的SQl语句;(2)创建session的Query对象;(3)设置Query对象的参数;(4)执⾏Query的executeUpdate()操作;(5)Session事务提交public void delete(int id){ String hql="delete Person as p where p.id=?"; //此处使⽤标准语句同样适⽤:"delete from Person where id=?"; //同样select和update都适⽤ Query query=session.createQuery(hql); query.setInteger(0,id); query.executeUpdate(); session.beginTransaction().commit();}删除例⼦(对象删除):(1)声明⼀个事务;(2)Session执⾏delete()操作;(3)事务提交;(4)关闭Session,可选. public void delete(Person p){ Transaction tran = session.beginTransaction(); //Person p = new Person(); //p.setid = id;(如果传⼊的只有部分数据) session.delete(p); mit(); session.close();}删除例字(持久对象->瞬时对象):JobBean aJob=(JobBean)s.get(JobBean.class, 17);s.delete(aJob);mit();查询例⼦: 查询语句不需要事务提交(1) 声明删除的SQl语句;(2)创建session的Query对象;(3)设置Query对象的参数;public Persion queryById(int id){ String hql="from Person as p where p.id=?"; Query query=session.createQuery(hql); query.setInteger(0,id); List rsList=query.list(); iterator it=rsList.iterator(); Person person=null; while(it.haseNext()){ person=(Person)it.next(); return person;}session.delete()- -session.delete(obj)将obj的状态变为transient。

Hibernate笔记HQL查询（一）单属性，多属性查询HQL是Hiberante官方推荐的Hibernate检索方式，它使用类似SQL的查询语言，以面向对象的方式从数据库中查询。

可以使用HQL 查询具有继承、多态和关联关系的数据。

在检索数据时应优先考虑使用HQL方式。

本笔记将会沿用前面所使用的dept部门表，emp员工表。

dept部门表emp员工表1 查询实体hibernate的session.createQuery()方法是使用HQL语句查询对象的。

hql：是查询对象的，例如："from User"，其中from不区分大小写，而User是区分大小写，因为它是对象。

是User类返回Query对象。

执行这条语句后，Hibernate会根据配置文件中所配置的数据库适配器自动生成相应数据库的SQL语句。

sql: select * from dept; from 后面是表名hql: form Dept; from 后面是类。

可以对类起别名，有两种方法。

hql: from Dept dhql：from Dept as d以上两种起别名方法皆可。

public void Test1() throws Exception{Configuration config=new Configuration().configure();SessionFactory sessionFactory= config.buildSessionFactory();Session session=null;Transaction tr=null;try{session= sessionFactory.openSession();tr=session.beginTransaction();String hql="from Dept"; //定义String类型hql，写入hql语句。

Query query=session.createQuery(hql);List<Dept> list = query.list();for(Dept dept:list){System.out.print("部门编号： "+dept.getDid() +" ");System.out.println("部门名称： "+dept.getDname());}mit();}catch(Exception e){tr.rollback();}finally{if(session!=null){session.close();}if(sessionFactory!=null){sessionFactory.close();}}}执行结果Hibernate: select dept0_.did as did1_, dept0_.dname as dname1_, dept0_.daddress as daddress1_ from dept dept0_ 部门编号： 1 部门名称：业务部部门编号： 2 部门名称：技术部部门编号： 3 部门名称：管理部部门编号： 4 部门名称：财务部部门编号： 5 部门名称：人力资源部2 查询表中单个属性sql: select ename from depthql: select ename from Dept对属性也可以设置别名hql:select ename as from Deptas 必须加。

上次我们一起学习了用Criteria进行相关的操作，但由于Criteria并不是Hibernate官方推荐的查询方式，我们也并不多用。

现在我们来看一下官方推荐的HQL，一起学习一下它的强大。

说是HQL，也就是Hibernate查询语句，和SQL有什么区别呢？一个字母的区别，哈哈。

当然不是这样，HQL和SQL的区别在于思想的不同，HQL是用面向对象的方向进行查询，而SQL则是对数据库二维表进行查询，这里包含的是思想的不同。

HQL实际上也是SQL，它由Hibernate帮我们在内部进行转换，生成SQL。

1）废话不多说，我们直接看一下它的强大。

Java代码1.from User这个代码很熟悉吧，因为我们在SQL中经常也用到from 表名，但这里有点不同的是User在这里并不是表名，而是实体类的名称，由hibernate帮我们进行映射。

联想SQL语句，如果我们想查出某个属性，并且根据某个属性进行条件限制，很简单可以得到类似语句：Java代码1.select ,usr.age from User where usr.age > 20 and usr.age < 60这样我们就查出了年龄大于20且小于60的User的姓名和年龄。

很容易理解。

SQL语句中的and,or,like,<,>,=等都可以在HQL中进行使用。

需要注意的是当我们查询多个属性时，返回的结果是一个Object[]数组，而只有单个时是返回Object，这个需要不同的解析方式，所以在查询时需要注意。

2）当然，我们前面说了HQL是面向对象的，而我们这样做，就不是面向对象的思想了。

我们来改一下：Java代码1.select new User(,usr.age) from User usr where usr.age >20这样我们就把查询到的结果放到了User对象中，注意，这里调用的是User 的构造函数，User类中必须存在接收两个参数的User构造函数，否则会报错，错误信息大概如下：Java代码1.Unable to locate appropriate constructor on class [org.hibernater]它找不到合适的构造函数。

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 后用表中字段做条件，这也就是面向对象和面向数据库的一个区别。

hibernatehql语句详解Hibernate HQL语句详解1. 什么是Hibernate HQL语句？Hibernate HQL（Hibernate Query Language）是Hibernate框架提供的一种面向对象的查询语言。

它类似于SQL，但是更注重于面向对象的概念和操作。

2. HQL语句的基本语法•HQL语句以FROM关键字开始，后面跟着要查询的实体类名。

•可以使用SELECT关键字来选择要查询的属性。

•可以使用WHERE关键字来添加查询条件。

•可以使用JOIN关键字来进行表连接查询。

•可以使用ORDER BY关键字来排序查询结果。

•可以使用GROUP BY关键字来进行分组查询。

3. HQL中的参数绑定•HQL语句中可以使用占位符（?）来表示参数，然后使用setXxx 方法来为占位符绑定实际的值。

•也可以使用命名参数（:name）来表示参数，然后使用setParameter方法来为参数绑定实际的值。

4. HQL中的函数HQL支持多种函数，常用的函数有：•数字函数：abs、sqrt、mod等。

•字符串函数：length、concat、substring等。

•日期函数：year、month、day等。

5. HQL中的聚合函数HQL中支持多种聚合函数，常用的聚合函数有：•avg：计算平均值。

•sum：计算总和。

•max：获取最大值。

•min：获取最小值。

•count：计算记录数。

6. HQL中的子查询•子查询是指一个查询语句内包含另一个查询语句。

•子查询可以用在WHERE子句中的条件表达式中。

•HQL支持分页查询，可以使用setFirstResult和setMaxResults方法来实现分页。

•setFirstResult用于设置查询结果的起始位置。

•setMaxResults用于设置查询结果的最大数量。

8. HQL中的更新和删除操作•HQL不仅可以用于查询，还可以用于更新和删除操作。

HibernateHQL查询中对日期的查询操作总结数据库表部分数据：SQL> select * from t_class;CLASS_IDCLASS_NAME CLASS_CREATETIME----------- ------------------------------------------------------------ --------------------------------------------------------------------------------1 班级1 22-1月 -08 03.03.52.717000 下午9 班级2 20-1月 -08 05.04.30.577000 上午18 班级3 15-3月 -08 11.08.03.204000 上午28 班级4 23-3月 -08 06.05.03.040000 下午39 班级5 24-4月 -08 01.22.50.090000 下午关键：注意类型匹配，看比较的是日期类型还是字符串类型。

//查询2008-1月-1日到2008-2月-1日建立的班级String hql = "select c.id, from MyClass c where c.createTime between ? and ?";//这里的问号要传入的是日期对象//在hql中可以使用数据库的函数,如:MySQL数据库中的date_formatSimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");List list =session.createQuery(hql).setParameter(0,format.parse("2008-01-01 00:00:00"))//此时应传入Date类型.setParameter(1,format.parse("2008-01-31 23:59:59")).list();查询2008-1月建立的班级：可以利用数据库中的函数，但要注意不同数据库的函数可能不同：例如Mysql中有date_format函数，而Oracle中则是用to_char将日期转为指定形式的字符串String hql = "select c.id, from MyClass c where to_char(c.createTime,'yyyy-MM')=?";//如果是mysql数据库，where条件应该使用date_format函数写成date_format(c.createTime,'%y-%M')=?List list = session.createQuery(hql).setParameter(0,"2008-01").list();//此时应传入字符串类型，应为to_char已将日期转为指定形式的字符串也可以使用oracle数据的函数to_date,将传入的字符串转化为指定格式的日期对象String hql = "select id,name from MyClass c where c.createTime between to_date(?,'yyyy-MM-dd HH24-mi-ss') and to_date(?,'yyyy-MM-dd HH24-mi-ss')";List list = session.createQuery(hql).setParameter(0,"2008-01-01 00:00:00").setParameter(1,"2008-01-31 23:59:59").list();注意oracle中使用to_date时有可能出现如下报错：（1）ERROR JDBCExceptionReporter:101 - ORA-01810: 格式代码出现两次这是由于输入日期模式时输入的是：yyyy-MM-dd HH24-mm-ss。

Hibernate的hql语句查询HQL是Hibernate Query Language的缩写，提供更加丰富灵活、更为强⼤的查询能⼒；HQL更接近SQL语句查询语法。

查询查询全部（持久化数据）// s:是别名⼀定要给对象取别名,不能⽤*。

hibernate⾥⾯没有*String hql="select s from Student s";//查询出的是查询对象QueryQuery query=session.createQuery(hql);//.list 查询出的⼀个list的集合List<Student> list=query.list();for (Student s : list) {System.out.println(s.getName());}指定列名查询全部（⾮持久化数据）有时候数据库的数据有可能有⼗⼏列，但是需要的只有⼏列，所有就需要指定列名查询//查询指定列名的-----⾮持久态//⾮持久化：因为查询出的数据与数据库不对应//s.sid,指定的列名别名.列名String hql="select s.sid, from Student s";Query query=session.createQuery(hql);//查询出来的是⼀个object数组，不是⼀个学⽣对象List<Object[]> list = query.list();for (Object[] objects : list) {System.out.println(objects[0] "\t" objects[1]);}指定列名查询全部（持久化数据）//查询指定列名的-----持久态//在数据库有与之对应的，在student对象中//new Student(s.sid,)-------在实体类中要与之对应的构造函数String hql="select new Student(s.sid,name) from Student s";Query query=session.createQuery(hql);//查询出的就是Student对象List<Student> list=query.list();for (Student student : list) {System.out.println(student.getName());}函数查询//函数查询---最⼤值//max(别名.列名)String hql="select max(s.sid) from Student s";Query query=session.createQuery(hql);//返回时是唯⼀的结果int max=(Integer) query.uniqueResult();System.out.println("最⼤值" max);注：在查询总⾏数的时候需要⽤long类型接收占位符查询第⼀种通过取占位符名 :⾃定义名//:name ⾃定义的名称String hql="select s from Student s where like :name";//设置占位符的值 setParameter(占位符名(不需要：,赋值)); 没有顺序Query query=session.createQuery(hql).setParameter("name", "%xx%");List<Student> list = query.list();for (Student student : list) {System.out.println(student.getName());}第⼆种：通过？占位符//hibernate版本在5.版本以上的要在?后⾯加占位符的顺序//⽐如 like ?0 and s.age>?1String hql="select s from Student s where like ?0";//赋值的时候就需要有顺序从0开始Query query=session.createQuery(hql).setParameter(0, "%x%");List<Student> list = query.list();for (Student student : list) {System.out.println(student.getName());}分页查询//查询出全部String hql="select s from Student s ";int pages=1;//当前的页数int pageSize=5;//⼀页显⽰多少⾏//setMaxResults设置⼀页显⽰的最⼤数 setFirstReault设置从哪⼀页开始Query query=session.createQuery(hql).setMaxResults(pageSize).setFirstResult((pages-1)*pageSize);List<Student> list = query.list();for (Student a : list) {System.out.println(a.getName());}下⾯有连接查询(我使⽤的是⼀对多的关系)//连接查询(全连接)//c.province.pid c⾥⾯的province对象⾥⾯的pid与p对象⾥⾯的pidString sql="select c from City c inner join Province p on c.province.pid=p.pid";Query query = session.createQuery(sql);List<City> list = query.list();for (City c : list) {System.out.println(c.getCname());}⼦连接//查询城市带汉的所有省份名称String hql="select p from Province p where p.pid in(select c.province.pid from City c where ame like :cname)"; Query query = session.createQuery(hql).setParameter("cname", "%汉%");List<Province> list=query.list();for (Province province : list) {System.out.println(province.getPname());}⼦连接2//查询城市带湖的所有省份名称-----⼀个表的查询条件是另⼀个表的查询的结果String hql="select p from Province p where p.pid in(select c.province.pid from City c where ame like :cname)"; Query query = session.createQuery(hql).setParameter("cname", "%汉%");List<Province> list=query.list();for (Province province : list) {System.out.println(province.getPname());}来源：https:///content-4-321451.html。

是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 中的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()+"'";。

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。