心得11-hibernate.的HQL语句
1. Hibernate查询介绍
Hibernate HQL查询、Criteria查询、调用存储过程
Hibernate事务管理和并发控制
Hibernate 延迟加载策略、抓取策略、一级二级缓存管理
Hibernate整合Struts
2. HQL介绍
HQL：Hibernate查询语言，它是Hibernate提供的一种面向对象的查询语言。
(1)在查询语句中设定各种查询条件
(2)支持动态绑定参数（类似sql语句中的预处理，？赋值）
(3)支持投影查询（纵向查询，后面会举例具体说明）、分页查询、连接查询、分组查询，子查询
(4) 内置了一些聚集函数
Hibernate中的Query接口就是专门用来执行HQL语句的查询接口。
HQL查询的主要步骤：
《1》.创建查询对象
Query query=session.createQuery(“from Dept”);
《2》.执行查询列出结果
1）列出所有的结果
List<Dept> depts=query.list();
for(Dept dept:depts){…}
2)列出单个结果
Query query=session.createQuery(“from Dept where id=1”);
query.setMaxResults(1);
Dept dept=(Dept)query.uniqueResult();
3)迭代访问结果；使用情况较少，麻烦
Iterator<Dept> it=query.iterate();
While(it.hasnext()){
}
3. HQL基本语法：持久化类名区分大小写
1）选择要查询的持久化类。
String hql=“from Dept”
Query query=session.createQuery(hql);
String hql=“from Dept as d”;
as是其别名的意思，可以省略，后面举例会具体说明
2）.针对选定属性创建一个类，提供以这两个属性为参数的构造方法，使用此类来封装查询结果。
3）where 条件子句
• String hqlString="from Dept d where d.createdTime>='2010-01-01'";
• Query query=session.createQuery(hqlString);
• String hqlString="from Dept d where d.name like'java%' and d.employees is not empty and d.createdTime<current_date()";
4）. 绑定查询参数
• 按参数名字绑定,这里用到了方法链
String hql=“from Dept where id>:id and name like:likeName”
List<Dept> dept=session.createQuery(hql).setLong(“id”,new Long(ingputID)).setString(“likeName”,”%”+inputName+”%”).list();
5）distinct 过滤重复值
Select distinct createTime from Dept
6）聚集函数(计数)
select count(id) from Dept d
7）order by 排序（asc升序，desc降序）
From Dept d order by d.createdTime asc,d.name desc
8）group by 对记录分组
Select count(e) from Employee e group by e.dept;
9）having 对分组后数据进行条件过滤
Select e.dept.name from Eployee e group by e.dept having count(e)>1
4.其他知识点
分页查询
Query接口提供两个用于分批显示查询结果的方法
setFirstResult(int firstResult)：在记录集中从第几条记录开始取数据。默认是0。
session.beginTransaction();
String hql = "from Employee";
List<Employee> empls = session.createQuery(hql).setMaxResults(pageSize) .setFirstResult((pageNo - 1) * pageSize).list();
session.getTransaction().commit();
setMaxResults(int maxResults)：设置每次查询返回的最大对象数。
批量修改和删除：直接通过SQL语句操作数据库，执行完后，当前session缓存中的数据与数据库中的数据不是同步的。
String hql=“delete Dept as d where d.name like:likeName”;
Query query=session.createQuery(hql).setString(“likeName”,”%三%”);
int count= query.executeUpdate();
连接查询
• Inner join （内连接） left outer join（左外连接）
• Right outer join （右外连接） full join（全连接）
String hql = "FROM Dept d JOIN d.employees e "
+ " WHERE d.name LIKE :likeName";
抓取连接查询 fetch与懒加载相对
抓取：是指从数据库加载一个对象数据时，同时把它所关联的对象和集合的数据一起加载出来，以便减少SQL语句的数据，从而提高查询效率。
From Dept d left join Fetch d.employees e where d.name like “%web%”
5. 以上知识点的案例的分析
package com.hbsi.one2many;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.hibernate.Query;
import org.hibernate.Session;
import org.junit.Test;
import com.hbsi.utils.HibernateSessionFactory;
public class AppHql {
@Test
public void find(){
Session session = HibernateSessionFactory.getSession();
/*//简单查询,返回结果为list
Query query = session.createQuery("from Department");
List<Department> list = query.list();
for(Department dep : list){
System.out.println(dep.getDepId()+"---"+dep.getDepName());
}
*/
/*//简单查询，返回结果为类对象
String hql = "from Department where id>1";
//setMaxResults(1)是设置最大查询结果为1 ，否则你后面用的uniqueResult（）方法会出错，改方法返回的结果是唯一值。
Query query = session.createQuery(hql).setMaxResults(1);
Department dep = (Department) query.uniqueResult();
System.out.println(dep.getDepId()+"---"+dep.getDepName());
*/
/*//投影查询（即纵向查询，就是查找某一字段的记录），选择部分属性,list中的元素是:object[];由于使用较麻烦，所以实际开发中不建议使用映射查询
String hql = "select depId,depName from Department";
Query query = session.createQuery(hql);
List list = query.list();
for(int i=0;i<list.size();i++){
Object[] obj = (Object[]) list.get(i);
System.out.println(obj[0]+"---"+obj[1]);
System.out.println("-----------------");
}*/
/*//通过一个类来封装部分查询的结果，简化操作,但是执行效率不高
String hql = "select new com.hbsi.one2many.DepartRow(d.depId,d.depName) from Department d";
Query query = session.createQuery(hql);
List<DepartRow> list = query.list();
for(DepartRow dr : list){
System.out.println(dr.getId()+"-----"+dr.getName());
}*/
/*//查询某一个属性的时候不需要再封装多余的属性类了，直接返回一个该属性类型的list
String hql = "select depName from Department";
Query query = session.createQuery(hql);
List<String> list = query.list();
for(String s : list){
System.out.println(s);
}*/
/*//查询包含员工的部门 is empty的应用
String hql = "from Department d where d.emp is not empty ";
Query query = session.createQuery(hql);
List<Department> list = query.list();
for(Department d : list){
System.out.println(d.getDepName());
for(Employee e : d.getEmp()){
System.out.println("|----"+e.getEmpName());
}
}*/
//绑定查询参数 ： ？的下标由0开始
/*String hql = "from Department d where d.depId>? and depName=?";
Query query = session.createQuery(hql);
query.setInteger(0,1);
query.setString(1,"软件系");
List<Department> dep = query.list();
for(Department d : dep){
System.out.println(d.getDepId()+"----"+d.getDepName());
}*/
//通过名字 （：名字）这种方法是给条件赋名称的方法来避免不知道哪个问号赋的什么值
/*String hql = "from Department d where d.depId>:ids and depName=:name";
Query query = session.createQuery(hql).setInteger("ids",1).setString("name","软件系");
List<Department> dep = query.list();
for(Department d : dep){
System.out.println(d.getDepId()+"----"+d.getDepName());
}
*/
//统计部门数,一般通过统计id数来达到功能，不推荐使用count（*）;下面两种方法的后台sql语句一样
/*String hql = "select count(depId) from Department";
Query query = session.createQuery(hql);
//方法一：通过获取总记录数统计
List list = query.list();
System.out.println(list.get(0));
//方法二：uniqueResult方法获取到的是Lang类型，不是Integer类型，强转为Integer类型会出错
Long dep = (Long) query.uniqueResult();
System.out.println(dep);*/
//统计各个部门员工人数 部门名 ，人数 ;这里统计的是人数，不是部门数
/*String hql = "select e.dep.depName,count(e.empId) from Employee e group by e.dep having count(e.empId)>=1";
Query query = session.createQuery(hql);
List list = query.list();
for(int i=0;i<list.size();i++){
Object[] obj = (Object[]) list.get(i);
System.out.print(obj[0]+"--");
System.out.println(obj[1]);
}*/
//用hql语句删除用户，这里的hql删除的是数据库表中的数据，但是session缓存中还保留着数据;这里调用的是executeUpdate更新语句，所以要开启事务，否则会回滚导致数据库的数据也没有被删除
/*session.beginTransaction();
Employee e = (Employee) session.get(Employee.class,6);
System.out.println(e.getEmpName());
Query query = session.createQuery("delete Employee where empId=6");
query.executeUpdate();
System.out.println(e.getEmpName());
session.getTransaction().commit();
*/
//inner join 内连接;这里用到了like的模糊查询
/*String hql = "from Department d join d.emp where d.depName like:likename";
Query query = session.createQuery(hql).setString("likename", "%软件%");
List list = query.list();
for(int i=0;i<list.size();i++){
Object[] obj = (Object[]) list.get(i);
Department dep = (Department) obj[0];
Employee emp = (Employee) obj[1];
System.out.println(dep.getDepName());
System.out.println("|---"+emp.getEmpName());
}
*/
//left join 左连接
/*String hql = "from Employee e join e.dep";
Query query = session.createQuery(hql);
List list = query.list();
for(int i=0;i<list.size();i++){
Object[] obj = (Object[]) list.get(i);
Department dep = (Department) obj[1];
Employee emp = (Employee) obj[0];
System.out.println(dep.getDepName());
System.out.println("|---"+emp.getEmpName());
}*/
//fetch 抓取;
String hql = "from Department d join fetch d.emp";
Query query = session.createQuery(hql);
//这里用list集合会重复抓取，这时可以用set集合;但是用set不能保证表里的顺序了就
List<Department> list = query.list();
Set<Department> set = new HashSet<Department>(list);
for(Department d : set){
System.out.println(d.getDepName());
for(Employee e: d.getEmp()){
System.out.println("|---"+e.getEmpName());
}
}
//简单连接，多表连接的时候，内连接，左右连接、抓取表中的空部门（没有对应雇员）都不显示出来，为了测试这个的原因
/*Query query = session.createQuery("from Department");
List<Department> list = query.list();
for(Department d : list){
System.out.println(d.getDepName());
}*/
//测试分页
/*List<Employee> list = findEmployee(2,2);
for(Employee e : list){
System.out.println(e.getEmpName());
}
HibernateSessionFactory.closeSession();*/
}
//分页
public List<Employee> findEmployee(int nowPage,int pageSize){
Session session = HibernateSessionFactory.getSession();
session.beginTransaction();
Query query = session.createQuery("from Employee");
query.setFirstResult((nowPage-1)*pageSize);
query.setMaxResults(pageSize);
List<Employee> list = query.list();
session.getTransaction().commit();
HibernateSessionFactory.closeSession();
return list;
}
}
