Hibernate 的几种查询方式和二级缓存的使用(10)

Hibernate的几种查询方式和二级缓存

一. Hibernate的查询方式

主要包括以下几种

1)  Get/load主键查询
2)  对象导航查询
3)  HQL查询,  Hibernate Query language  hibernate 提供的面向对象的查询语言。
4)  Criteria 查询,   完全面向对象的查询(Query By Criteria  ,QBC)
5)  SQLQuery, 本地SQL查询
缺点:不能跨数据库平台: 如果修改了数据库,sql语句有肯能要改
使用场景: 对于复杂sql,hql实现不了的情况,可以使用本地sql查询。

1.1 HQL查询,先创建两个实体类,并且配置好映射

Dept.java

package com.mrq.entity;

import java.util.HashSet;
import java.util.Set;

public class Dept {
    private Integer deptId;
    private String deptName;
    private Set emps =  new HashSet<>();//一对多:一个部门对应多个员工
    public Integer getDeptId() {
        return deptId;
    }
    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }
    public String getDeptName() {
        return deptName;
    }
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
    public Set getEmps() {
        return emps;
    }
    public void setEmps(Set emps) {
        this.emps = emps;
    }
    @Override
    public String toString() {
        return "Dept [deptId=" + deptId + ", deptName=" + deptName + ", emps=" + emps + "]";
    }
    
    public Dept() {
        // TODO Auto-generated constructor stub
    }
    public Dept(Integer deptId, String deptName) {
        super();
        this.deptId = deptId;
        this.deptName = deptName;
    }   
}

Employee.java

package com.mrq.entity;

public class Employee {
    private Integer empId;
    private String empName;
    private Double salary;
    private Dept dept; //多对一:多个员工对应一个部门
    public Integer getEmpId() {
        return empId;
    }
    public void setEmpId(Integer empId) {
        this.empId = empId;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public Double getSalary() {
        return salary;
    }
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    public Dept getDept() {
        return dept;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    @Override
    public String toString() {
        return "Employee [empId=" + empId + ", empName=" + empName + "]";
    }   
}

映射文件

Dept.hbm.xml





    
        
            
        
        
        
        
        
        
            
            
        
        
    
    
    
    
        
        
    

Employee.hbm.xml





    
        
            
        
        
        
          
        
              
    

  • 各种查询对应的格式和要点

App.java

    /*
     * 1)   Get/load主键查询
        2)  对象导航查询
        3)  HQL查询,  Hibernate Query language  hibernate 提供的面向对象的查询语言。
        4)  Criteria 查询,   完全面向对象的查询(Query By Criteria  ,QBC)
        5)  SQLQuery, 本地SQL查询

     */

    
    //1.HQL查询
    @Test
    public void testQuery() {
        Session session = sf.openSession();
        session.beginTransaction();
        //1.主键查询
        Dept dept = (Dept) session.get(Dept.class, 1);
        System.out.println(dept);
        
        /*
         * 2.对象导航查询:通过一个对象查询另外的对象的信息,比如通过部门,查询该部门下的员工和员工信息
         * */
        Dept dept = (Dept)session.get(Dept.class, 1);
        System.out.println(dept.getEmps());
        
        //3.HQL查询 
        //方式一:
        Query query = session.createQuery("from Dept");
        System.out.println(query.list());
        //方式二
        Query query = session.createQuery("select d from Dept d");
        System.out.println(query.list());
        
        //查询指定的column
        //1.返回特定对象数组Object[]
        Query query = session.createQuery("select d.deptId,d.deptName from Dept d");
        System.out.println(query.list());
        
        //2.返回封装的对象:要提供对应的构造函数
        Query query = session.createQuery("select new Dept(d.deptId,d.deptName) from Dept d");
        System.out.println(query.list());
        
        //条件查询:一个条件/多个条件and or/between and/模糊查询
        //1.使用?占位符
        Query query = session.createQuery("from Dept d where deptName=?");
        query.setParameter(0, "技术部");
        System.out.println(query.list());
        
        //2.使用命名参数:command
        Query query = session.createQuery("from Dept d where deptId= :id or deptName= :name");
        query.setParameter("id", 1);
        query.setParameter("name", "技术部");
        System.out.println(query.list());
        
        //范围查询 between
        Query query = session.createQuery("from Dept d where deptId between ? and ?");
        query.setParameter(0, 1);
        query.setParameter(1, 5);
        System.out.println(query.list());
        
        //模糊查询 like
        Query query = session.createQuery("from Dept d where deptName like ?");
        query.setParameter(0, "%部%");
        System.out.println(query.list());
        
        //聚合函数查询
        Query query = session.createQuery("select count(*) from Dept");
        Long count = (Long) query.uniqueResult();
        System.out.println(count);
        
        //分组查询:查找相同部门的员工
        Query query = session.createQuery("select e.dept,count(*) from Employee"
                + " e group by e.dept");
        System.out.println(query.list());
        
        
        session.getTransaction().commit();
        session.close();
    }
  • 常见的连接查询
    @Test
    public void join() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        //1.内连接
        Query query = session.createQuery("from Dept d inner join d.emps");
        System.out.println(query.list());
        
        //2.左外连接
        Query query = session.createQuery("from Dept d left join d.emps");
        System.out.println(query.list());
        
        //3.右外链接
        Query query = session.createQuery("from Dept d right join d.emps");
        System.out.println(query.list());
        
        session.getTransaction().commit();
        session.close();
    }
  • 迫切连接fetch查询
public void fetch() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        //1.迫切内连接,使用fetch,会把右表的数据填充到左表数据中
//      Query query = session.createQuery("from Dept d inner join fetch d.emps");
//      System.out.println(query.list());
        
        //2.迫切左外连接
        Query query = session.createQuery("from Dept d left join fetch d.emps");
        System.out.println(query.list());
        
        
        session.getTransaction().commit();
        session.close();
    }
  • 从配置文件写HQL语句

在Dept.hbm.xml进行配置,加入query节点

 
    
        
        
    

测试:

    @Test
    public void hqlQuery() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Query query = session.getNamedQuery("getAll");
        query.setParameter(0, 10);
        System.out.println(query.list());
        
        session.getTransaction().commit();
        session.close();
    }
  • Criteria查询使用基本方式
//Criteria 查询
    @Test
    public void criteriaQuery() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Criteria criteria = session.createCriteria(Employee.class);
        //条件约束
        //criteria.add(Restrictions.eq("empId", 12));//empId=12的对象
        criteria.add(Restrictions.idEq(12));//也可以使用ID查询
        System.out.println(criteria.list());
        
        session.getTransaction().commit();
        session.close();
        
        
    }

  • HQL分页查询
//分页查询
    @Test
    public void pageQuery() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Query query = session.createQuery("from Employee");
        ScrollableResults scrollableResults = query.scroll();//得到结果集
        scrollableResults.last();//滚动到最后一行
        int totalCount = scrollableResults.getRowNumber()+1;//得到滚动的记录数
        
        //设置分页参数
        query.setFirstResult(0);
        query.setMaxResults(5);
        System.out.println(query.list());
        System.out.println("总的记录数 "+totalCount);
        
        session.getTransaction().commit();
        session.close();
    }
  • Hibernate支持原生SQL语句的使用
//支持原生的SQL查询
    @Test
    public void sql() {
        Session session = sf.openSession();
        session.beginTransaction();
        SQLQuery q = session.createSQLQuery("SELECT * FROM t_Dept limit 4;")
                .addEntity(Dept.class);  // 也可以自动封装对象
            System.out.println(q.list());
        session.getTransaction().commit();
        session.close();
    }

二. Hibernate的二级缓存

前面了解了Hibernate的一级缓存:session缓存
    Hibernate提供的缓存
    有一级缓存、二级缓存。 目的是为了减少对数据库的访问次数,提升程序执行效率!

一级缓存:
    基于Session的缓存,缓存内容只在当前session有效,session关闭,缓存内容失效!
    特点: 
        作用范围较小! 缓存的事件短。
        缓存效果不明显。

二级缓存:
    Hibernate提供了基于应用程序级别的缓存, 可以跨多个session,即不同的session都可以访问缓存数据。 这个换存也叫二级缓存。
    Hibernate提供的二级缓存有默认的实现,且是一种可插配的缓存框架!如果用户想用二级缓存,只需要在hibernate.cfg.xml中配置即可; 不想用,直接移除,不影响代码。
    如果用户觉得hibernate提供的框架框架不好用,自己可以换其他的缓存框架或自己实现缓存框架都可以。
    
  • 使用二级缓存进行的配置
#hibernate.cache.use_second_level_cache false【二级缓存默认不开启,需要手动开启】
#hibernate.cache.use_query_cache true      【开启查询缓存】

## choose a cache implementation        【二级缓存框架的实现】

#hibernate.cache.provider_class org.hibernate.cache.EhCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.EmptyCacheProvider
hibernate.cache.provider_class org.hibernate.cache.HashtableCacheProvider 默认实现
#hibernate.cache.provider_class org.hibernate.cache.TreeCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.OSCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.SwarmCacheProvider

二级缓存,使用步骤
1) 开启二级缓存
2)指定缓存框架
3)指定那些类加入二级缓存
4)测试
    测试二级缓存!

缓存策略

     放入二级缓存的对象,只读; 
      非严格的读写
        读写; 放入二级缓存的对象可以读、写;
       (基于事务的策略)

在hibernate.cfg.xml中配置二级缓存


        
        true
        
        org.hibernate.cache.HashtableCacheProvider
        
        true
        
        
        
        
        

测试二级缓存:

@Test
    public void testCache() {
        Session session1 = sf.openSession();
        session1.beginTransaction();
        
        //进行一次查询
        Dept dept = (Dept)session1.get(Dept.class,5);
        dept.getEmps().size();
        System.out.println(dept);
        
        session1.getTransaction().commit();
        session1.close();
        
        System.out.println("开启第二次查询");
        
        Session session2 = sf.openSession();
        session2.beginTransaction();
        
        dept = (Dept)session2.get(Dept.class,5);
        dept.getEmps().size();
        System.out.println(dept);
        
        session2.getTransaction().commit();
        session2.close();
        
    }

不使用二级缓存的输出:可以得出两次查询都是同样的操作:向数据库查询

Hibernate: select dept0_.deptId as deptId0_0_, dept0_.deptName as deptName0_0_ from t_dept dept0_ where dept0_.deptId=?
Hibernate: select emps0_.dept_id as dept4_0_1_, emps0_.empId as empId1_, emps0_.empId as empId1_0_, emps0_.empName as empName1_0_, emps0_.salary as salary1_0_, emps0_.dept_id as dept4_1_0_ from t_employee emps0_ where emps0_.dept_id=?
Dept [deptId=5, deptName=技术部3, emps=[Employee [empId=10, empName=李四3], Employee [empId=9, empName=张三3]]]
开启第二次查询
Hibernate: select dept0_.deptId as deptId0_0_, dept0_.deptName as deptName0_0_ from t_dept dept0_ where dept0_.deptId=?
Hibernate: select emps0_.dept_id as dept4_0_1_, emps0_.empId as empId1_, emps0_.empId as empId1_0_, emps0_.empName as empName1_0_, emps0_.salary as salary1_0_, emps0_.dept_id as dept4_1_0_ from t_employee emps0_ where emps0_.dept_id=?
Dept [deptId=5, deptName=技术部3, emps=[Employee [empId=9, empName=张三3], Employee [empId=10, empName=李四3]]]

开启二级缓存的输出:第一次查询向数据库发送了SQL语句,第二次查询没有向数据库查询,而是从缓存中获取

Hibernate: select dept0_.deptId as deptId0_0_, dept0_.deptName as deptName0_0_ from t_dept dept0_ where dept0_.deptId=?
Hibernate: select emps0_.dept_id as dept4_0_1_, emps0_.empId as empId1_, emps0_.empId as empId1_0_, emps0_.empName as empName1_0_, emps0_.salary as salary1_0_, emps0_.dept_id as dept4_1_0_ from t_employee emps0_ where emps0_.dept_id=?
Dept [deptId=5, deptName=技术部3, emps=[Employee [empId=9, empName=张三3], Employee [empId=10, empName=李四3]]]
开启第二次查询
Dept [deptId=5, deptName=技术部3, emps=[Employee [empId=9, empName=张三3], Employee [empId=10, empName=李四3]]]

2.1 list二级缓存策略,可以使用setCacheable(true)显示指定从二级缓存获取或者放入二级缓存中

        Session session1 = sf.openSession();
        session1.beginTransaction();
        
        //setCacheable 指定从二级缓存找,或者放入二级缓存
        Query query = session1.createQuery("from Dept").setCacheable(true);
        System.out.println(query.list());
        
        session1.getTransaction().commit();
        session1.close();
        
        System.out.println("第二次查询");
        
        Session session2 = sf.openSession();
        session2.beginTransaction();
        
        query = session2.createQuery("from Dept").setCacheable(true);
        System.out.println(query.list());
        
        session2.getTransaction().commit();
        session2.close();

四. 项目中session的创建方式

session.openSession();方法每次都会创建一个新的session
session.getCurrentSession();方法则是从当前线程获取session或者创建session放入线程中,使用这种方式,需要在配置文件进行配置:
thread

测试代码

    @Test
    public void testSession() {
            //openSession:  创建Session, 每次都会创建一个新的session
            Session session1 = sf.openSession();
            Session session2 = sf.openSession();
            System.out.println(session1 == session2);
            session1.close();
            session2.close();
            
            //getCurrentSession 创建或者获取session
            // 线程的方式创建session  
            // 一定要配置:thread
            Session session3 = sf.getCurrentSession();// 创建session,绑定到线程
            Session session4 = sf.getCurrentSession();// 从当前访问线程获取session
            System.out.println(session3 == session4);
            
            // 关闭 【以线程方式创建的session,可以不用关闭; 线程结束session自动关闭】
            //session3.close();
            //session4.close(); 报错,因为同一个session已经关闭了!   

    }

结果输出:false true

你可能感兴趣的:(Hibernate 的几种查询方式和二级缓存的使用(10))