Hibernate一级缓存（基于查询分析）

首先我们应该弄清什么是hibernate缓存:hibernate缓存是指为了降低应用程序对物理数据源的访问频次，从而提高应用程序的运行性能的一种策略。我们要将这个跟计算机内存或者cpu的缓存区分开。

一、hibernate查询的几种方式

既然是基于查询分析hibernate一级缓存，我们就来分析分析hibernate查询方式

1、通过session对象的get()方法

我们通过查看hibernate的api文档找到了session接口，并重点看了get()方法，我们主要使用一下两种get()方法：

通过传入由实体类获得的Class类对象（姑且叫做类类型）和该类的唯一标识符两个参数，返回一个Object类型的查询对象。

通过传入实体类名和该类对象的唯一标识符两个参数，返回一个Object类型的查询对象。

代码示例：

package com.third;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.third.Dao2.Students2;
import com.third.Dao2.Students2PartInfo;

public class Test3 {
    private static SessionFactory sessionFactory;
    private static Session session;
    private static Transaction transaction;
    @Before
    public void init(){
        //先获取配置对象，匹配hibernate.cfg.xml文件
        Configuration config=new Configuration().configure();
        //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
        sessionFactory=config.buildSessionFactory(serviceRegistry);
    }
    
    @Test
    public void test3(){
        //通过sessionFactory对象获取session对象
        session=sessionFactory.openSession();
        //通过session对象开启事务，并且返回事务(transaction)对象
        transaction=session.beginTransaction();    
    
        //第一个session对象通过get()方法第一次查询相同记录
        Students2 stu1=(Students2) session.get(Students2.class, 1);
        //第一个session对象通过get()函数第二次查询相同记录
        Students2 stu2=(Students2) session.get(Students2.class, 1);
        System.out.println("学号："+stu1.getSid()
            +"  姓别："+stu1.getSgender()+"  姓名："+stu1.getSname());
        System.out.println("学号："+stu2.getSid()
        +"  姓别："+stu2.getSgender()+"  姓名："+stu2.getSname());
        
        //重新获得一个session对象，再一次执行session对象的get()方法查询相同记录
        Session session1=sessionFactory.openSession();
        Students2 stu3=(Students2) session1.get(Students2.class, 1);
        System.out.println("学号："+stu3.getSid()
            +"  姓别："+stu3.getSgender()+"  姓名："+stu3.getSname());
        
        
    }
    
    @After
    public void destory(){
        transaction.commit();
        //关闭开启的资源
        if(session!=null){
            session.close();
        }
        if(sessionFactory!=null){
            sessionFactory.close();
        }
    }
}

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美

分析：在同一个session对象的条件下查询同一表格记录，hibernate解析的SQL语句只会执行一次，重新获得一个session对象后，再去查询相同的表格记录时，hibernate解析而成的SQL语句会在执行一次。

我们不难得出：在同一个session对象的情况下，使用get()方法查询相同的对象会使用到缓存（一级缓存），不同的session对象在查询相同对象正常情况下是不会使用缓存。

2、通过session的load()方法

我们通过查看hibernate的api文档找到了session接口，并重点看了load()方法，我们主要使用一下两种load()方法：

通过传入由实体类获得的Class类对象（姑且叫做类类型）和该类的唯一标识符两个参数，返回一个Object类型的查询对象。

通过传入实体类名和该类对象的唯一标识符两个参数，返回一个Object类型的查询对象。

代码示例：

package com.third;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.third.Dao2.Students2;
import com.third.Dao2.Students2PartInfo;

public class Test3 {
    private static SessionFactory sessionFactory;
    private static Session session;
    private static Transaction transaction;
    @Before
    public void init(){
        //先获取配置对象，匹配hibernate.cfg.xml文件
        Configuration config=new Configuration().configure();
        //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
        sessionFactory=config.buildSessionFactory(serviceRegistry);
    }
    
    @Test
    public void test3(){
        //通过sessionFactory对象获取session对象
        session=sessionFactory.openSession();
        //通过session对象开启事务，并且返回事务(transaction)对象
        transaction=session.beginTransaction();    
        
        //第一个session对象通过get()方法第一次查询相同记录
        Students2 stu1=(Students2) session.load(Students2.class, 1);
        //第一个session对象通过get()函数第二次查询相同记录
        Students2 stu2=(Students2) session.load(Students2.class, 1);
        System.out.println("学号："+stu1.getSid()
            +"  姓别："+stu1.getSgender()+"  姓名："+stu1.getSname());
        System.out.println("学号："+stu2.getSid()
        +"  姓别："+stu2.getSgender()+"  姓名："+stu2.getSname());
        
        //重新获得一个session对象，再一次执行session对象的get()方法查询相同记录
        Session session1=sessionFactory.openSession();
        Students2 stu3=(Students2) session1.load(Students2.class, 1);
        System.out.println("学号："+stu3.getSid()
            +"  姓别："+stu3.getSgender()+"  姓名："+stu3.getSname());
        
    }
    
    @After
    public void destory(){
        transaction.commit();
        //关闭开启的资源
        if(session!=null){
            session.close();
        }
        if(sessionFactory!=null){
            sessionFactory.close();
        }
    }
}

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美

分析：在同一个session对象的条件下查询同一表格记录，hibernate解析的SQL语句只会执行一次，重新获得一个session对象后，再去查询相同的表格记录时，hibernate解析而成的SQL语句会在执行一次。

我们不难得出：在同一个session对象的情况下，使用load()方法查询相同的对象会使用到缓存（一级缓存），不同的session对象在查询相同对象正常情况下是不会使用缓存。

我们可以总结得到，load()函数的查询流程和get()函数的查询流程基本相同。

3、通过session对象的createQuery(String HQL)方法

我们通过查看hibernate的api文档找到了session接口，找到createQuery(String HQL)方法，该方法的返回值类型是一个Query（查询），于是，我们找到Query接口，我们找到了两个方法，是将查询结果返回的。

以List的方式返回查询结果

以迭代器的方式返回查询结果

（1）以List的方式返回查询结果

1）有select子句

package com.third;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.third.Dao2.Students2;
import com.third.Dao2.Students2PartInfo;

public class Test3 {
    private static SessionFactory sessionFactory;
    private static Session session;
    private static Transaction transaction;
    @Before
    public void init(){
        //先获取配置对象，匹配hibernate.cfg.xml文件
        Configuration config=new Configuration().configure();
        //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
        sessionFactory=config.buildSessionFactory(serviceRegistry);
    }
    
    @Test
    public void test3(){
        //通过sessionFactory对象获取session对象
        session=sessionFactory.openSession();
        //通过session对象开启事务，并且返回事务(transaction)对象
        transaction=session.beginTransaction();    
        
        //创建HQL语句用于后面的查询需要
        //查询所有记录的sid和sname信息(hql语句)
        String hql=" select sid,sname,sgender from Students2";
        
        //创建多条记录查询对象query1
        Query query=session.createQuery(hql);
        
        /*
         * 相同session对象，相同query对象，查询相同的对象
         */
        List<Object[]> list=query.list();
        for (Object[] objects : list) {
            System.out.println("学号："+objects[0]+" 姓名："+objects[1]+" 性别："+objects[2]);
        }
        
        List<Object[]> list1=query.list();
        for (Object[] objects : list1) {
            System.out.println("学号："+objects[0]+" 姓名："+objects[1]+" 性别："+objects[2]);
        }
    }
    
    @After
    public void destory(){
        transaction.commit();
        //关闭开启的资源
        if(session!=null){
            session.close();
        }
        if(sessionFactory!=null){
            sessionFactory.close();
        }
    }
}

运行结果：

Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女

2）没有select子句

package com.third;

import java.awt.event.FocusEvent;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.third.Dao2.Students2;
import com.third.Dao2.Students2PartInfo;

public class Test3 {
    private static SessionFactory sessionFactory;
    private static Session session;
    private static Transaction transaction;
    @Before
    public void init(){
        //先获取配置对象，匹配hibernate.cfg.xml文件
        Configuration config=new Configuration().configure();
        //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
        sessionFactory=config.buildSessionFactory(serviceRegistry);
    }
    
    @Test
    public void test3(){
        //通过sessionFactory对象获取session对象
        session=sessionFactory.openSession();
        //通过session对象开启事务，并且返回事务(transaction)对象
        transaction=session.beginTransaction();    
        
        String hql="from Students2";
        Query query=session.createQuery(hql);
        List<Students2> stu=query.list();
        for (Students2 stu1 : stu) {
            System.out.println("学号："+stu1.getSid()+" 姓名："+stu1.getSname()+" 性别："+stu1.getSgender());
        }
        List<Students2> stu2=query.list();
        for (Students2 stu3 : stu2) {
            System.out.println("学号："+stu3.getSid()+" 姓名："+stu3.getSname()+" 性别："+stu3.getSgender());
        }
        
        
    }
    
    @After
    public void destory(){
        transaction.commit();
        //关闭开启的资源
        if(session!=null){
            session.close();
        }
        if(sessionFactory!=null){
            sessionFactory.close();
        }        
    }    
}

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_,
        students2x0_.SNAME as SNAME2_1_,
        students2x0_.SGENDER as SGENDER3_1_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
Hibernate: 
    select
        students2x0_.SID as SID1_1_,
        students2x0_.SNAME as SNAME2_1_,
        students2x0_.SGENDER as SGENDER3_1_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女

分析：相同session，甚至相同query对象情况下，查询相同的对象，hibernate解析的SQL语句在数据库执行了两次。

很明显能看出：session.createQuery(hql).list()方法，不会使用缓存。

（2）以迭代的方式返回查询结果

代码示例：

package com.third;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.third.Dao2.Students2;
import com.third.Dao2.Students2PartInfo;

public class Test3 {
    private static SessionFactory sessionFactory;
    private static Session session;
    private static Transaction transaction;
    @Before
    public void init(){
        //先获取配置对象，匹配hibernate.cfg.xml文件
        Configuration config=new Configuration().configure();
        //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
        sessionFactory=config.buildSessionFactory(serviceRegistry);
    }
    
    @Test
    public void test3(){
        //通过sessionFactory对象获取session对象
        session=sessionFactory.openSession();
        //通过session对象开启事务，并且返回事务(transaction)对象
        transaction=session.beginTransaction();    
        
        /*
         * 这里我们执行带有select子句的查询
         */
        //创建HQL语句用于后面的查询需要
        //查询所有记录的sid和sname信息(hql语句)
        String hql=" select sid,sname,sgender from Students2";
        
        //创建多条记录查询对象query1
        Query query=session.createQuery(hql);
        System.out.println("*************带有select子句的查询*********************");
        Iterator it=query.iterate();
        while(it.hasNext()){
            Object[] obj=(Object[])it.next();
            System.out.println("学号："+obj[0]+" 姓名："+obj[1]+" 性别："+obj[2]);
        }
        //在同一session同一query1对象下查询相同的对象
        System.out.println("同一个session并且同一个query对象下查询相同对象：");
        Iterator it2=query.iterate();
        while(it2.hasNext()){
            Object[] obj=(Object[])it2.next();
            System.out.println("学号："+obj[0]+" 姓名："+obj[1]+" 性别："+obj[2]);
        }
        System.out.println("**************不带select子句的查询**********************");
        /*
         * 这里我们执行不带有select子句的查询
         */
        Session session1=sessionFactory.openSession();
        String hql1="from Students2";
        Query query1=session.createQuery(hql1);
        Iterator<Students2> it1=query1.iterate();
        while(it1.hasNext()){
            Students2 stu=it1.next();
            System.out.println("学号："+stu.getSid()
            +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
        }
        //在同一session同一query1对象下查询相同的对象
        System.out.println("在同一session同一query1对象下查询相同的对象:");
        Iterator<Students2> it3=query1.iterate();
        while(it3.hasNext()){
            Students2 stu=it3.next();
            System.out.println("学号："+stu.getSid()
            +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
        }
        //在同一个session但是不是一个query对象下查询相同对象
        System.out.println("在同一个session但是不是一个query对象下查询相同对象:");
         Query query2=session.createQuery(hql1);
            Iterator<Students2> it4=query2.iterate();
            while(it4.hasNext()){
                Students2 stu=it4.next();
                System.out.println("学号："+stu.getSid()
                +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
            }
        //在不同的session中，查询相同的对象
            System.out.println("在不同的session中，查询相同的对象:");
            Session session2=sessionFactory.openSession();
            String hql2="from Students2";
            Query query3=session2.createQuery(hql1);
            Iterator<Students2> it5=query3.iterate();
            while(it5.hasNext()){
                Students2 stu=it5.next();
                System.out.println("学号："+stu.getSid()
                +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
            }
    }
    
    @After
    public void destory(){
        transaction.commit();
        //关闭开启的资源
        if(session!=null){
            session.close();
        }
        if(sessionFactory!=null){
            sessionFactory.close();
        }
    }
}

运行结果：

*************带有select子句的查询*********************
Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
同一个session并且同一个query对象下查询相同对象：
Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
**************不带select子句的查询**********************
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：2  姓别：男  姓名：小泽
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：3  姓别：女  姓名：小敏
在同一session同一query1对象下查询相同的对象:
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
学号：1  姓别：女  姓名：小美
学号：2  姓别：男  姓名：小泽
学号：3  姓别：女  姓名：小敏
在同一个session但是不是一个query对象下查询相同对象:
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
学号：1  姓别：女  姓名：小美
学号：2  姓别：男  姓名：小泽
学号：3  姓别：女  姓名：小敏
在不同的session中，查询相同的对象:
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：2  姓别：男  姓名：小泽
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：3  姓别：女  姓名：小敏

分析：以迭代器方式返回的查询，执行我们分成使用select子句和没有使用select子句的查询：

1）使用了select子句的查询，是不会使用缓存的

2）不使用select子句的查询，情况可以分为在同一个session下和不同的session下查询相同的对象。在同一个session下，第一次查询缓存中不存在的对象时，会先到数据库中查询要查对象的主键，然后依靠主键使用where子句限定主键，然后一一按照主键到数据库中执行SQL语句查询对象；再次查询相同对象时，会现在缓存中查询对象的编号，找到相同编号的返回，找不到的，再到数据库去按照编号查找。在不同session下，缓存一般不能使用。

二、一级缓存相关介绍

1、hibernate一级缓存也称为“会话级缓存”、“session缓存”。

2、一级缓存的生命周期和session相同，session销毁，缓存也销毁。

3、一级缓存数据的使用范围，或者说是作用域为当前会话。

4、hibernate一级缓存的API

一级缓存无法取消，用两个方法管理。

evict()：用于将某个对象从session中的一级缓存中清除。

clear()：用于将一级缓存中的对象全部清除。

package com.third;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.third.Dao2.Students2;

public class Test3 {
    private static SessionFactory sessionFactory;
    private static Session session;
    private static Transaction transaction;
    @Before
    public void init(){
        //先获取配置对象，匹配hibernate.cfg.xml文件
        Configuration config=new Configuration().configure();
        //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
        sessionFactory=config.buildSessionFactory(serviceRegistry);
    }
    
    @Test
    public void test3(){
        //通过sessionFactory对象获取session对象
        session=sessionFactory.openSession();
        //通过session对象开启事务，并且返回事务(transaction)对象
        transaction=session.beginTransaction();    
        
        Students2 stu1=(Students2) session.get(Students2.class, 1);
        Students2 stu2=(Students2) session.get(Students2.class, 2);
        Students2 stu3=(Students2) session.get(Students2.class, 3);
        
        System.out.println("第一遍查询：");
        System.out.println("学号："+stu1.getSid()+" 姓名："+stu1.getSname()+" 性别："+stu1.getSgender());
        System.out.println("学号："+stu2.getSid()+" 姓名："+stu2.getSname()+" 性别："+stu2.getSgender());
        System.out.println("学号："+stu3.getSid()+" 姓名："+stu3.getSname()+" 性别："+stu3.getSgender());
        
        //先使用evict()方法，然后在查询相同session下之前查过的对象
        System.out.println("先使用evict()方法，然后在查询相同session下之前查过的对象:");
        session.evict(stu1);
        Students2 stu4=(Students2) session.get(Students2.class, 1);
        System.out.println("学号："+stu4.getSid()+" 姓名："+stu4.getSname()+" 性别："+stu4.getSgender());
        
        //使用clear()方法，然后再查询相同session下之前查过的对象。
        System.out.println("使用clear()方法，然后再查询相同session下之前查过的对象:");
           session.clear();
        Students2 stu5=(Students2) session.get(Students2.class, 1);
        Students2 stu6=(Students2) session.get(Students2.class, 2);
        Students2 stu7=(Students2) session.get(Students2.class, 3);
        
        System.out.println("学号："+stu5.getSid()+" 姓名："+stu5.getSname()+" 性别："+stu5.getSgender());
        System.out.println("学号："+stu6.getSid()+" 姓名："+stu6.getSname()+" 性别："+stu6.getSgender());
        System.out.println("学号："+stu7.getSid()+" 姓名："+stu7.getSname()+" 性别："+stu7.getSgender());
    }
    
    @After
    public void destory(){
        transaction.commit();
        //关闭开启的资源
        if(session!=null){
            session.close();
        }
        if(sessionFactory!=null){
            sessionFactory.close();
        }        
    }    
}

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
第一遍查询：
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
先使用evict()方法，然后在查询相同session下之前查过的对象:
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1 姓名：小美 性别：女
使用clear()方法，然后再查询相同session下之前查过的对象:
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女

三、总结：

（1）一级缓存的数据的作用范围为一个session，缓存会随着session的销毁而销毁。

（2）其中通过get()、load()、和以Iterator（迭代器）方式返回无select子句查询都会使用到缓存，但是通过以list方式和Iterator（迭代器）方式返回的有select子句的查询不会使用缓存。

（3）其中以Iterator（迭代器）方式返回的hibernate查询都是先从数据库中查询对象的编号，然后到缓存中查找匹配的编号，找到了直接返回，找不到通过where子句限定以编号去数据库中查找，然后返回。

一级缓存查询的流程图：