Hibernate缓存以及哪些操作会向缓存中读取和存放数据

Hibernate缓存以及哪些操作会向缓存中读取和存放数据

---

Hibernate缓存

Hibernate有两级缓存，分别是一级缓存和二级缓存。一级缓存也叫Session级缓存，默认情况下就可以用，无需配置。一级缓存生命周期由Session对象决定，Session对象关闭，一级缓存也就消失。二级缓存也叫SessionFactory级缓存，需要配置后才能使用。二级缓存的生命周期比一级缓存的生命周期长，由SessionFactory对象决定，SessionFactory对象关闭，二级缓存也就消失。

哪些操作会向缓存中读取和存放数据？

测试之前先说一下Hibernate访问数据库，Hibernate对传统的JDBC进行了封装，一般我们访问数据库无非就是增、删、改、查这四个操作，而这四个操作均通过各自的SQL语句完成，所以Hibernate对数据库进行这四个操作时也离开不了SQL语句，如果我们配置Hibernate时配置了show_sql这个属性的话，一旦Hibernate对数据库进行了增、删、改、查操作的话，控制台就会将执行的SQL语句打印出来，这也就是下面我们为什么能将控制台有没有打印SQL语句作为Hibernate有没有访问数据库的原因。下面开始测试：

测试环境：
系统：Windows 10
JDK：1.8.102
Hibernate：5.2.10
软件：MyEclipse 2016

我们先看查询，查询我们常见的有get()、load()以及HQL中的Query对象的list()方法（后面为方便，我们称为query.list()）和uniqueResult()方法（后面为方便，我们称为query.uniqueResult()）这些方法。

先上结果：
get()、load()均会向缓存中存放以及读取数据，而query.list()和query.uniqueResult()会向缓存存放数据但不会从缓存中读取数据

get()方法：

测试之前先说一下get()方法是怎么查找数据的，它会先到一级缓存中去找，没有的话，它会到二级缓存中继续找，二级缓存中还没有的话，就会立马生成相应的查询SQL，并把这个SQL发送到数据库，到数据库中去找编号为7499的员工，如果数据库中也没找到的话，就会返回null。如果数据库中有的话就会返回查询结果，在它返回查询结果的同时，它还会把查到的结果放进缓存中（一二级缓存都会放）。

测试get()方法代码：

    // get()会向缓存中存放和读取数据测试
    public static void testGetCache(Session session){
        try {
            Employee emp6=session.get(Employee.class, 7499);
            System.out.println(emp6);
            Employee emp7=session.get(Employee.class, 7499);
            System.out.println(emp7);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            session.close();
        }
    }

运行结果：

Hibernate: 
    select
        employee0_.empno as empno1_0_0_,
        employee0_.ename as ename2_0_0_,
        employee0_.job as job3_0_0_,
        employee0_.sal as sal4_0_0_,
        employee0_.deptno as deptno5_0_0_,
        employee0_.hiredate as hiredate6_0_0_,
        employee0_.comm as comm7_0_0_,
        employee0_.mgr as mgr8_0_0_ 
    from
        SCOTT.Emp employee0_ 
    where
        employee0_.empno=?
员工姓名：ALLEN  员工编号7499
员工姓名：ALLEN  员工编号7499

代码中我们查询编号7499的员工查了2次，但运行结果中只打印了第一次查询的SQL语句，说明第一次是到数据库中查的，第二次没有去数据库中查，但第二次却依然查到了编号7499的员工，原因是因为Hibernate的缓存机制，第一次找到编号为7499的员工到后就会把7499的员工信息放进缓存中，当我们第二次再次查找的7499的员工信息时，由于在缓存中已经找到了，所以就直接返回结果，就不会到数据库中去查了，因此控制台并没有打印第二次的SQL语句。也就是说第二次查询是从缓存中查（读取）出来的。所以结果很明显：get()会向缓存中存放以及读取数据。
get()测试结果：get()会向缓存中存放以及读取数据

load()方法：

load()和get()查找数据的方式差不多，但又有点区别。load()也是先到一级缓存中去找，没找到的话继续到二级缓存中找，二级缓存中还没找到的话，它会返回一个查询结果的代理对象，当后面我们用到查询结果时，这个时候它才会生成相应的SQL语句，并把SQL发送到数据库，到数据库中去找，你后面如果没用到查询结果的话它不会生成查询的SQL，不会到数据库中去找。换句话说，就是你什么时候用到查询结果，他就什么时候去数据库中找，如果在数据库中没找到的话，就会报错，会报org.hibernate.ObjectNotFoundException的异常，导致程序中断。如果数据库中有的话就会返回查询结果，在它返回查询结果的同时，它还会把查到的结果放进缓存中（一二级缓存都会放）

测试load()方法代码：

    // load()会向缓存中存放和读取数据测试
    public static void testLoadCache(Session session){
        try {
          Employee emp6=session.get(Employee.class, 7369);
          System.out.println(emp6);
          Employee emp7=session.get(Employee.class, 7369);
          System.out.println(emp7);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            session.close();
        }
    }

运行结果：

Hibernate: 
    select
        employee0_.empno as empno1_0_0_,
        employee0_.ename as ename2_0_0_,
        employee0_.job as job3_0_0_,
        employee0_.sal as sal4_0_0_,
        employee0_.deptno as deptno5_0_0_,
        employee0_.hiredate as hiredate6_0_0_,
        employee0_.comm as comm7_0_0_,
        employee0_.mgr as mgr8_0_0_ 
    from
        SCOTT.Emp employee0_ 
    where
        employee0_.empno=?
员工姓名：SMITH  员工编号7369
员工姓名：SMITH  员工编号7369

代码中我们同样查询编号7369的员工查了2次，但运行结果中只打印了第一次查询的SQL语句，说明第一次是到数据库中查的，第二次没有去数据库中查，但第二次却依然查到了编号7369的员工，原因也是因为Hibernate的缓存机制，第一次找到编号为7369的员工后就会把7369的员工信息放进了缓存，第二次查找的7369的员工信息是从缓存中查（读取）出来的。所以load()也会向缓存中存放以及读取数据。
load()方法测试结果：load()会向缓存中存放以及读取数据

query.list()方法

测试query.list()方法代码：

    // 测试query.list()会向缓存中存放数据但不会从缓存的读取数据
    public static void testQueryListCache(Session session) {
        try {
            String hql="from Employee";
            Query query=session.createQuery(hql);
            List<Employee> list=query.list();
            for (int i=0;i<2;i++) {
                System.out.println("员工编号："+list.get(i).getEmpNo()+"   员工姓名："+list.get(i).getEmpName());
            }
            System.out.println("------------------------------------------");
            Employee emp=(Employee)session.get(Employee.class, 7654);
            System.out.println("员工编号："+emp.getEmpNo()+"   员工姓名："+emp.getEmpName());
            System.out.println("------------------------------------------");
            String hql2="from Employee";
            Query query2=session.createQuery(hql2);
            List<Employee> list2=query2.list();
            for (int i=0;i<2;i++) {
                System.out.println("员工编号："+list2.get(i).getEmpNo()+"   员工姓名："+list2.get(i).getEmpName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            session.close();
        }
    }

运行结果：

Hibernate: 
    select
        employee0_.empno as empno1_0_,
        employee0_.ename as ename2_0_,
        employee0_.job as job3_0_,
        employee0_.sal as sal4_0_,
        employee0_.deptno as deptno5_0_,
        employee0_.hiredate as hiredate6_0_,
        employee0_.comm as comm7_0_,
        employee0_.mgr as mgr8_0_ 
    from
        SCOTT.Emp employee0_
员工编号：20   员工姓名：empSu2
员工编号：19   员工姓名：empSave2
------------------------------------------
员工编号：7654   员工姓名：MARTIN
------------------------------------------
Hibernate: 
    select
        employee0_.empno as empno1_0_,
        employee0_.ename as ename2_0_,
        employee0_.job as job3_0_,
        employee0_.sal as sal4_0_,
        employee0_.deptno as deptno5_0_,
        employee0_.hiredate as hiredate6_0_,
        employee0_.comm as comm7_0_,
        employee0_.mgr as mgr8_0_ 
    from
        SCOTT.Emp employee0_
员工编号：20   员工姓名：empSu2
员工编号：19   员工姓名：empSave2

测试代码中我们用query.list()方法去查询所有员工的编号和姓名查了两次（为了方便看结果，循环打印员工的编号和姓名时只循环了2次），分别在第一条虚线前和第二条虚线后。两条虚线之间我们用get()的方式查找了其中一名员工，看两条虚线间有没有打印get()查询员工的SQL语句来验证第一次query.list()查询后，有没有向缓存中存放数据。

运行结果可以看出，控制台将这两次query.list()查询所有员工的SQL语句都打印了出来，说明两次query.list()查询都是到数据库中查找的。两次query.list()查询之间我们用get()去查询了编号为7654的员工，运行结果显示我们查到了该员工的信息，但控制台却没有打印查询该员工信息的SQL语句，说明get()没有到数据库中去查，get()查到的编号为7654的员工信息不是从数据库中查到的，由于get()查找数据的顺序是先从缓存中找再到数据库中找，但我们用get()却查到了编号为7654的员工，说明get()查到的数据是从缓存中查到（读取到）的，观察整段测试代码，get()查询之前我们只进行了query.list()查询操作，所以很明显缓存中的信息是query.list()查到结果后放进去的，这就说明了query.list()会向缓存中存放数据，此时缓存中已经有了所有员工信息，但get()后面的query.list()查询操作在缓存中已经有要查找的信息时依旧是到数据库中查的，所以会发现query.list()并不会从缓存中查找（读取）数据。综上：测试query.list()会向缓存中存放数据但不会从缓存的读取数据
query.list()测试结果：query.list()会向缓存中存放数据但不会从缓存的读取数据

query.uniqueResult()方法：

测试query.uniqueResult()代码：

    //测试query.uniqueResult()会向缓存中存放数据但不会从缓存的读取数据
    public static void testQueryUniqueResultCache(Session session) {
        try {
            String hql="from Employee where empNo=7876";
            Query query=session.createQuery(hql);
            Employee emp=(Employee)query.uniqueResult();
            System.out.println("员工编号："+emp.getEmpNo()+"   员工姓名："+emp.getEmpName());
            System.out.println("-------------------------------------------------");
            //通过get()来测试query.list()有没有向缓存中存放数据
            Employee emp3=(Employee)session.get(Employee.class, 7876);
            System.out.println("员工编号："+emp3.getEmpNo()+"   员工姓名："+emp3.getEmpName());
            System.out.println("-------------------------------------------------");
            String hql2="from Employee where empNo=7876";
            Query query2=session.createQuery(hql2);
            Employee emp2=(Employee)query.uniqueResult();
            System.out.println("员工编号："+emp2.getEmpNo()+"   员工姓名："+emp2.getEmpName());
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            session.close();
        }
    }

运行结果：

Hibernate: 
    select
        employee0_.empno as empno1_0_,
        employee0_.ename as ename2_0_,
        employee0_.job as job3_0_,
        employee0_.sal as sal4_0_,
        employee0_.deptno as deptno5_0_,
        employee0_.hiredate as hiredate6_0_,
        employee0_.comm as comm7_0_,
        employee0_.mgr as mgr8_0_ 
    from
        SCOTT.Emp employee0_ 
    where
        employee0_.empno=7876
员工编号：7876   员工姓名：ADAMS
-------------------------------------------------
员工编号：7876   员工姓名：ADAMS
-------------------------------------------------
Hibernate: 
    select
        employee0_.empno as empno1_0_,
        employee0_.ename as ename2_0_,
        employee0_.job as job3_0_,
        employee0_.sal as sal4_0_,
        employee0_.deptno as deptno5_0_,
        employee0_.hiredate as hiredate6_0_,
        employee0_.comm as comm7_0_,
        employee0_.mgr as mgr8_0_ 
    from
        SCOTT.Emp employee0_ 
    where
        employee0_.empno=7876
员工编号：7876   员工姓名：ADAMS

与上面的测试query.list()类似，我们用query.uniqueResult()查编号为7876的员工查了两次，分别是在第一条虚线前和 第二条虚线后。两条虚线中间我们用get()再次查找编号7876的员工，看两条虚线之间有没有打印get()查询的SQL语句来判断query.uniqueResult()有没有向缓存中放入数据。

结果显示两条虚线之外均有打印查询的SQL，说明两次query.uniqueResult()查询都是到数据库中去查的，从运行结果来看，两条虚线之间并没有打印SQL语句，说明我们用get()查找员工7876时并没有到数据库中去查，但是依然查到了员工信息，根据get()查找数据的顺序结合此时get()并没有到数据库中去查，可以知道，get()查到员工信息是从缓存中查（读取）到的，依旧是观察整段测试代码，get()查询员工前面除了query.uniqueResult()查询操作外并没有进行其它任何操作，所以，很显然，缓存中的员工信息是前面query.uniqueResult()查到结果后放进去的。到这就说明了query.uniqueResult()会向缓存中存放数据。
再来，结合get()后面的query.uniqueResult()查询操作，在缓存中已经有要查找的员工时，却还是到数据库中去查找。所以得出结论：query.uniqueResult()不会从缓存的读取数据。
综合就是：query.uniqueResult()会向缓存中存放数据但不会从缓存的读取数据

测试结果：query.uniqueResult()会向缓存中存放数据但不会从缓存的读取数据

说完了查询，我们说添加，添加我们常见的有save()和saveOrUpdate()
先上结果：
save()和saveOrUpdate()进行添加时，均会向缓存中存放数据。

save()方法：

测试save()方法代码

    //测试save()会向缓存中存放数据
    public static void testSaveCache(Session session) {
        try {
            Transaction tr=session.beginTransaction();
            Employee emp1=new Employee();
            emp1.setEmpName("empSave2");
            session.save(emp1);
            System.out.println("添加的对象的主键为："+emp1.getEmpNo());
            Employee emp2=(Employee)session.get(Employee.class,emp1.getEmpNo());
            System.out.println("员工姓名："+emp2.getEmpName());
            tr.commit();//只有当这句代码执行时，才会向数据库发送sql
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            session.close();
        }
    }

运行结果：

Hibernate: 
    select
        hibernate_sequence.nextval 
    from
        dual
添加的对象的主键为：19
员工姓名：empSave2
Hibernate: 
    insert 
    into
        SCOTT.Emp
        (ename, job, sal, deptno, hiredate, comm, mgr, empno) 
    values
        (?, ?, ?, ?, ?, ?, ?, ?)

从代码可以看出，我们在tr.commit();这句代码之前我们又用get()查询了当前添加的对象，此时tr.commit();还没有执行，也就是事务还没提交，所以对象这个时候还没存进数据库，按理说我们应该查不到记录。

但从运行结果中可以看出，我们查到了数据，而且，控制台没有打印相关的查询SQL，说明我们用get()查找的员工信息不是从数据库中找的，结合get()查找数据是先从缓存再到数据库中找的顺序，所以我们能得出，查到的数据是从缓存中查到的，而在我们get()查询之前除了save()操作并没有其它操作，因此，缓存中的数据是save()放的，也就是说在我们调用save()添加时它会把添加的信息放进缓存里。
save()测试结果：save()会向缓存中存放数据

saveOrUpdate()方法：

测试saveOrUpdate()方法代码

    //测试saveOrUpdate()进行添加时会向缓存中存放数据
    public static void testSaveOrUpdateCache(Session session) {
        try {
            Transaction tx=session.beginTransaction();
            Employee emp3=new Employee();
            emp3.setEmpName("empSu2");
            session.saveOrUpdate(emp3);
            System.out.println("添加的对象的主键为："+emp3.getEmpNo());
            Employee emp4=(Employee)session.get(Employee.class,emp3.getEmpNo());
            System.out.println("员工姓名："+emp4.getEmpName());
            tx.commit();//只有当这句代码执行时，才会向数据库发送sql
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            session.close();
        }
    }

运行结果：

Hibernate: 
    select
        hibernate_sequence.nextval 
    from
        dual
添加的对象的主键为：20
员工姓名：empSu2
Hibernate: 
    insert 
    into
        SCOTT.Emp
        (ename, job, sal, deptno, hiredate, comm, mgr, empno) 
    values
        (?, ?, ?, ?, ?, ?, ?, ?)

和测试save()一样，我们在tx.commit();这句代码之前我们又用get()查询了当前添加的对象，此时tr.commit();还没有执行，也就是事务还没提交，所以对象还没存进数据库，按理说我们应该查不到记录。

运行结果也和上面save()的一样，控制台并没有打印相关的查询SQL说明，说明我们用get()查找的员工信息不是从数据库中找的，结合get()查找数据是先从缓存再到数据库中找的顺序，所以我们能得出，查到的数据是从缓存中查到的，而在我们get()查询之前除了saveOrUpdate()操作并没有其它操作，因此，缓存中的信息是saveOrUpdate()操作放进去的，所以，saveOrUpdate()也会向缓存中存放数据。
saveOrUpdate()测试结果：saveOrUpdate()会向缓存中存放数据

以上均为个人理解，如有错误，欢迎指正