Hibernate（10）- 查询方式

朴灿烈づ我的快乐病毒、 2024-04-17 23:45 58阅读 0赞

### **一.hibernate中的5种检索方式** ###

1.  导航对象图检索方式：根据已经加载的对象导航到其他对象
2.  OID检索方式
3.  HQL检索方式
4.  QBC检索
5.  本地SQL查询：使用标准的SQL语句来编写

## ##

### 二.导航对象图检索方式 ###

例如：在前面的各种映射关系中，实体类包含对其他类对象的引用。

Dept d = (Dept) session.get(Dept.class,2);

d.getStaffSet().size();　　//d对象关联Staff集合，hibernate会自动检索Staff数据。如何检索的，看下面图中发送的sql语句。

![format_png][]

## ##

### 三.OID检索方式 ###

按照对象的OID来检索对象

例如：session.get()/session.load()

这个大家度很熟悉了，就不用在这里过多的阐述了。

## ##

### 四.HQL检索方式 ###

**1.简介**

HQL:Hibernate Query Language ,是面向对象的查询语言，它和SQL查询语言有些相似，在Hibernate提供的各种检索方式中，HQL是使用的最广的一种检索方式，

注意：HQL操作的全是POJO类中的属性，而不是操作数据库表中的字段。

*  1.3.1、在查询语句中设定各种查询条件
 *  1.3.2、支持投影查询，即仅检索出对象的部分属性
 *  1.3.3、支持分页查询
 *  1.3.4、支持连接查询
 *  1.3.5、支持分组查询，允许使用HAVING 和 GROUP BY 关键字
 *  1.3.6、提供内置聚集函数，如SUM(),MIN(),MAX()等
 *  1.3.7、能够调用用户定义的SQL函数或标准的SQL函数
 *  1.3.8、支持子查询
 *  1.3.9、支持动态绑定参数

**2.HQL对比SQL：**

*  HQL查询语句是面向对象的，Hibernate负责解析HQL查询语句，然后根据对象-关系映射文件中的映射信息，把HQL查询语句翻译成相反的SQL语句。HQL查询语句中的主体是域模型中的类及类的属性
 *  SQL查询语句是与关系数据库绑定在一起的，SQL查询语句中的主体是数据库表及表的字段

**3.使用HQL检索步骤：**

1.  获得session
2.  编写HQL
3.  通过session.createQuery(HQL)创建Query对象
4.  为Query对象设置条件参数(如果HQL中需要填充参数的话)  
    hibernate的参数绑定机制依赖于JDBC API中的PrepareStatement的预定义SQL语句功能。
    
    1.  HQL的参数绑定有两种形式：
        
        1.  按参数名字绑定：在HQL查询语句中定义命名参数，命名参数以“：”开头
            
                @Test
                public void testHQL(){
                	//1.编写HQL
                	//基于命名参数
                	String hql="FROM Employee e WHERE e.salary >:sal AND e.email like :email " ;
                	
                	//2.创建Query对象
                	Query query =session.createQuery(hql);
                 
                	//3.绑定参数
                	//Query 对象调用setXxx 方法支持方法链的编程风格
                	query.setFloat("sal",6000);
                	     .setString("email","%A%")
                	    
                	
                	//4.执行查询
                	List<Employee> emps=query.list();
                	System.out.prinltn(emps.size());
                }
        2.  按参数位置绑定：在HQL查询语句中用“？”来定义参数位置，使用ORDERBY关键字
            
                @Test
                public void testHQL(){
                	//1.编写HQL
                	//基于位置的参数
                	String hql="FROM Employee e WHERE e.salary >? AND e.email like ? AND e.dept=?" + "ORDER BY e.salary";
                	
                	//2.创建Query对象
                	Query query =session.createQuery(hql);
                 
                	//3.绑定参数
                	//Query 对象调用setXxx 方法支持方法链的编程风格
                	Department dept=new Department();
                	dept.setId(80);
                	query.setFloat(0,6000);
                	     .setString(1,"%A%")
                	     .setEntity(2,dept);
                	
                	//4.执行查询
                	List<Employee> emps=query.list();
                	System.out.prinltn(emps.size());
                }
    2.  相关方法：
        
        1.  setEntity()：把参数与一个持久化类绑定
        2.  qurey接口支持方法链编程风格，它的setXxx()方法返回自身实例，而不是void类型
        3.  setparamenter():绑定任意类型的参数，该方法的第三个参数显示指定Hibernate映射类型
5.  执行查询 
    
    1.  list()：返回一个集合列表，有可能集合中装的是数组，有可能是POJO对象。
    2.  uniqueResult()：返回一个查询结果，在已知查询结果只有一个或者0个时，使用是没有问题的，如果返回结果有多个，那么就会报异常

**4.分页查询**

*  setFirstResult(intfirstResult):设定从哪一个对象开始检索，参数firstResult表示这个对象在查询结果中的索引位置，索引位置的起始值为0，默认情况下，Query从查询结果中的第一个对象开始检索。
 *  setMaxResult(intmaxResult):设定一次最多检索出的对象的数目，在默认情况下，Query和Criteria接口检索出的查询结果中所有的对象
 *  示例：
    
        @Test
        public void testPageQuery(){
        	String hql="FROM Empoyee";
        	Query query =session.createQuery(hql);
        	
        	int pageNo=4;	//查询第4页
        	int pageSize=5;	//每页5条数据
        	
        	List<Employee> emps = query.setFirstResult((pageNo - 1)* pageSize).setMaxResults(pageSize).list();
        	System.out.println(emps);

**5.在映射文件中定义命名查询语句**

*  Hibernate允许在映射文件中定义字符串形式的查询语句。
 *  <query>元素用于定义一个HQL查询语句，它和<class>元素并列。
 *  在程序中通过Session的getNamedQuery()方法获取查询语句对应的Query对象。
 *  示例：  
    在Employee.hbm.xml中
    
        <class></class>	
        <query name="salaryEmps">
        	<![CDATA[
        		FROM Empoyee e WHERE e.salary > :minSal AND e.salary < : maxSal
        	]]>
        </query>
    
        @Test
        public void testNameQuery(){
        	Query query =session.getNameQuery(salaryEmps);
        	
        	List<Employee> emps=query.setFloat("minSal",5000)
        				 .setFloat("max",10000)
        				 .list();
        	
        	System.out.println(emps.size());
        }

**6.投影查询**

*  投影查询：查询结果仅包含实体的部分属性，通过SELECT关键字实现。
 *  Query的list()方法返回的集合中包含的是数组类型的元素，每个对象数组代表查询结果的一条记录。
 *  可以在持久化类中定义一个对象的构造器来包装投影查询返回的记录，是程序代码能完全运行面向对象的语义来访问查询结果集。
 *  可以通过DISTINCT关键字来保证查询结果不会返回重复元素。
 *  第一种：普通查询
    
        @Test
        public void testLeftJoinFetch(){
        	
        	String hql="FROM Department d LEFT JOIN  d.emps";
        	Query query=session.createQuery(hql);
         
         
        	List<Object []> result=query.list();  //list()方法中获得是数组
        	result=new ArraryList<>(new LinkedHashSet(result));//去除重复的数据,效果不好
        	System.out.println(result);
        	
        	for(Object [] objs:result){
        		System.out.println(Arrays.asList(objs));
        }
 *  第二种：投影查询
    
    1.  第一步：在持久化类中定义一个对象的构造器来包装投影查询返回的记录（在Employee.java中定义一个带有email，salary，dept属性的构造器，顺序要对）
        
            public Employee(String email,float salary,Department dept){
            	super();
            	this.email=email;
            	this.salary=salary;
            	this.dept=dept;
            }
            //同样还需要无参的构造器
            public Employee(){
            }
    2.  第二步：
        
            @Test
            public void testFieldQuery2(){
            	//查询结果仅包含实体的部分属性，通过SELECT关键字实现
            	String hql = "SELECT new Employee(e.email,e.salary,e.dept) FROM Employee e EHERE e.dept= :dept2";
            	Query query= session.createQuery(hql);
             
            	Department dept3=new Deparment();
            	dept3.setId(80);
             
            	//query的list()方法返回的集合中包含的是数组类型的元素
            	List<Employee> result=query.setEntity("dept2":dept3).list();
             
            	for(Employee emp:result){
            		System.out.println(emp.getId() + "," + emp.getEmail() + "," + emp.getSalary + "," + emp.getDept());
            	}

**7.报表查询**

报表查询用于对数据分组和统计，与SQL一样，HQL利用GROUPBY关键字对数据分组，用HARING关键字对分组数据设定约束条件。  
在HQL查询语句中可以调用以下聚集函数

*  count()
 *  min()
 *  max()
 *  sum()
 *  arg()

@Test
    public void testGroupBy(){
    	String hql="SELECT min(e.salary), max(e.salary) FROM Employee e GROUP BY e.dept HAVING min(salary) > :minSal";
     
    	Query query= session.createQuery(hql);
     
    	List<Object []> result=query.setEntity("minSal",8000).list();
    	for(Object [] objs:result){
    		System.out.println(Arrays.asList(objs));
    }

**8.左外连接：left outer join，可以省略outer，直接left join**

*  LEFT JOIN关键字表示左外连接查询
 *  list()方法返回的集合中存放的是对象数组类型
 *  根据配置文件来决定Employee集合的检索策略
 *  如果希望list()方法返回的集合中仅包含Department对象，可以在HQL查询语句中使用SELECT关键字
 *  第一种：
    
        @Test
        public void testLeftJoinFetch(){
        	
        	String hql="FROM Department d LEFT JOIN  d.emps";
        	Query query=session.createQuery(hql);
         
         
        	List<Object []> result=query.list();  //list()方法中获得是数组
        	result=new ArraryList<>(new LinkedHashSet(result));//去除重复的数据,效果不好
        	System.out.println(result);
        	
        	for(Object [] objs:result){
        		System.out.println(Arrays.asList(objs));
        }
 *  第二种：
    
        @Test
        public void testLeftJoinFetch(){
        	//添加DISTINCT d 表示获得的是Department对象，并且去掉d.id重复的数据
           	String hql="SELECT DISTINCT d FROM Department d LEFT JOIN FETCH d.emps";
        	Query query=session.createQuery(hql);
         
         
        	List<Department> depts=query.list();
        	System.out.println(depts.size());
        	
        	for(Department dept:depts){
        		System.out.println(dept.getName());
        }

**9.迫切左外连接**

*  LEFT JOINFEICH关键字表示迫切左外连接检索策略
 *  list()方法返回的集合中存放实体对象的引用，每个Department对象关联的Employee集合都被初始化，存放所有关联的Employee的实体对象
 *  查询结果中可能会包含重复元素，可以通过一个HashSet来过滤重复元素。
 *  示例
    
        @Test
        public void testLeftJoinFetch(){
        	//加入SELECT DISTINCT d是去除department.id相同重复的数据
             //	String hql="SELECT DISTINCT d FROM Department d LEFT JOIN FETCH d.emps";
        	String hql="FROM Department d LEFT JOIN FETCH d.emps";
        	Query query=session.createQuery(hql);
         
        	List<Department> depts=query.list();
        	depts=new ArraryList<>(new LinkedHashSet(depts));//去除department.id重复的数据
        	System.out.println(depts.size());
        	
        	for(Department dept:depts){
        		System.out.println(dept.getName()+ "-" + dept.getEemps().size());
        }

**10.内连接**

*  INNER JOIN关键字表示内连接，也可以省略INNER关键字
 *  list()方法返回的集合中存放的每个元素对应查询结果的一条记录，每个元素都是对象数组类型
 *  如果希望list()方法返回的集合仅包含Department对象，可以在HQL查询语句中使用SELECT关键字
 *  内连接返回的list中是Object\[\]，而迫切内连接返回的list中是POJO类对象

**11.迫切内连接**

*  INNER JOIN FETCH关键字表示迫切内连接，也可以省略INNER关键字
 *  list()方法返回的集合中存放Department对象的引用，每个Department对象的Employee集合都被初始化，存放所有关联的Employee对象
 *  示例
    
        //注意，hql操作的是POJO，而不是表中字段，所以s.dept这里不能写成Dept或者dept，
                //不用写ON后面的连接条件，因为hibernate映射文件我们已经全部写好了。
                String hql = "from Dept d inner join fetch d.staffSet";
                Query hqlQuery = session.createQuery(hql);
                //使用的是迫切内连接，其list中放的就是Dept对象了，注意并没有包含staffSet。放的是from后面跟的POJO，如果是Staff。那么这里就放的Staff。
                //所以自己重写了toString方法的人这里会报错，
                List list = hqlQuery.list();    //集合中存放的是Dept。
                System.out.println(list);
         
        //结果
        Hibernate: 
            select
                dept0_.id as id0_0_,
                staffset1_.id as id1_1_,
                dept0_.name as name0_0_,
                staffset1_.name as name1_1_,
                staffset1_.deptId as deptId1_1_,
                staffset1_.deptId as deptId0_0__,
                staffset1_.id as id0__ 
            from
                dept dept0_ 
            inner join
                staff staffset1_ 
                    on dept0_.id=staffset1_.deptId
        //返回那么多相同的原因是内连接，Staff中有9条记录，则部门这边也会显示9条，所以这里重复了9次。可以是用DISTINCT关键字去除重复的记录
        [Dept [id=2, name=1部门], Dept [id=2, name=1部门], Dept [id=2, name=1部门], Dept [id=2, name=1部门], Dept [id=2, name=1部门], Dept [id=2, name=1部门], Dept [id=2, name=1部门], Dept [id=2, name=1部门], Dept [id=2, name=1部门]]
    
    要想得到不重复的记录，那么就将hql改为"select distinct d from Dept d inner join fetch d.staffSet";

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvODc0NzEwLzIwMTYxMi84NzQ3MTAtMjAxNjEyMTExMjAzNDg4NTEtMTMwNzQ1ODI0My5wbmc?x-oss-process=image/format,png