【Hibernate】---- 数据缓存

最新推荐文章于 2022-05-16 21:34:06 发布

EricaLSR

最新推荐文章于 2022-05-16 21:34:06 发布

阅读量651

点赞数 1

分类专栏： ------hibernate

本文链接：https://blog.csdn.net/lishaoran369/article/details/52791854

版权

------hibernate 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

学习hibernate知识的关于数据缓存的笔记

【概述】

对于ORM实现而言，缓存显得尤为重要，它是持久层性能提升的关键。相对JDBC数据存取，ORM存取往往需要更加复杂的机制，以实现内部状态的管理、OR关系的映射等。

这些额外的开销使得ORM数据访问效率相对较低。如何弥补这里产生的性能差距？数据缓存是其中一个关键策略。

【原理】

ORM在进行数据读取时，会根据其缓存管理策略，首先在缓存中查询，如果在缓存中发现所需数据，则直接以此数据作为结果加以利用，从而避免了数据库调用的性能开销。

【Hibernate数据缓存】

Hibernate数据缓存可分为两个层次，分别为：

1. 内部缓存（SessionLevel，也称为一级缓存）

2. 二级缓存（SessionFactoryLevel）

Hibernate中，缓存在一下情况会起作用：

1. 通过id（主键）加载数据。

2. 延迟加载。

【一级缓存】

1. 定义：一级缓存生命周期很短和session的生命周期一致，一级缓存也叫session级的缓存或事务级缓存。

2. 代码示例：

/**
     * 在同一个session中发出两次load查询
     */
    public void testCache1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());
            
            //不会发出查询语句，load使用缓存
            student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());
            
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    } 
    /**
     * 在同一个session中发出两次iterate查询,查询实体对象
     */
    public void testCache3() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Iterator iter = session.createQuery("from Student s where s.id<5").iterate();
            while (iter.hasNext()) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            System.out.println("--------------------------------------");
            //它会发出查询id的语句，但不会发出根据id查询学生的语句，因为iterate使用缓存
            iter = session.createQuery("from Student s where s.id<5").iterate();
            while (iter.hasNext()) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    } 
    /**
     * 在同一个session中发出两次iterate查询,查询普通属性
     */ 
    public void testCache4() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Iterator iter = session.createQuery("select s.name from Student s where s.id<5").iterate();
            while (iter.hasNext()) {
                String name = (String)iter.next();
                System.out.println(name);
            }
            System.out.println("--------------------------------------");
            
            //iterate查询普通属性，一级缓存不会缓存，所以发出查询语句
            //一级缓存是缓存实体对象的
            iter = session.createQuery("select s.name from Student s where s.id<5").iterate();
            while (iter.hasNext()) {
                String name = (String)iter.next();
                System.out.println(name);
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }          
    /**
     * 在两个session中发load查询
     */
    public void testCache5() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student = (Student)session.load(Student.class, 1);
            //会发出查询语句，session间不能共享一级缓存数据
            //因为他会伴随着session的消亡而消亡
            System.out.println("student.name=" + student.getName());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
    }

3. 小结：

通过以上几个方法的测试，我们可以通过在控制台打印SQL语句看看每个方法的调用都执行了怎样的操作，也就可以判断是否使用了缓存。

方法1根据主键load方法查询，第一次会发出SQL，第二次就直接从缓存中获取，不再发出SQL。

方法3根据主键iterate方法查询，第一次SQL语句都会发出，第二次只会发出查询主键语句，而不会发出根据每个主键查询实体对象信息，也是从缓存中获取。

方法4根据主键查询普通属性，每次都会发出SQL，因为一级缓存只对查询实体对象起作用，查询普通属性不会写入缓存中。

方法5是在两个session中执行load方法，因为session间不能共享以及缓存，所以两个load方法都会发出相应的SQL。

【二级缓存】

1. 定义：二级缓存也称为进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享；二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存

2. 配置及使用：

* 将ehcache.xml文件拷贝到src下

* 在hibernate.cfg.xml文件中加入缓存产品提供商

* 启用二级缓存，这也是它的默认配置

* 指定哪些实体类使用二级缓存，可以在映射文件中采用<cache>标签指定或在hibernate.cfg.xml文件中统一指定，注意使用的策略，通常采用read-only和read-write

3. 代码实现：

hibernate.cfg.xml:
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        ...
        <!-- 配置缓存提供商 -->
        <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
        
        <!-- 启用二级缓存，这也是它的默认配置 -->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        
        <mapping resource="com/bjpowernode/hibernate/Student.hbm.xml"/>
        <mapping resource="com/bjpowernode/hibernate/Classes.hbm.xml"/>
        
        <!-- 
            指定Student使用二级缓存
         -->
        <class-cache class="com.bjpowernode.hibernate.Student" usage="read-only"/>
    </session-factory>
</hibernate-configuration>

测试方法：

/**
     * 开启二级缓存
     * 
     * 在两个session中发load查询
     */
    public void testCache1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student = (Student)session.load(Student.class, 1);
            
            //不会发出查询语句，因为配置二级缓存，session可以共享二级缓存中的数据
            //二级缓存是进程级的缓存
            System.out.println("student.name=" + student.getName());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
    } 
    /**
     * 开启二级缓存
     *  
     * 一级缓存和二级缓存的交互 
     */
    public void testCache4() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            //禁止将一级缓存中的数据放到二级缓存中
            session.setCacheMode(CacheMode.IGNORE);
            Student student = (Student)session.load(Student.class, 1);
            System.out.println("student.name=" + student.getName());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            Student student = (Student)session.load(Student.class, 1);
            
            //会发出查询语句，因为禁止了一级缓存和二级缓存的交互
            System.out.println("student.name=" + student.getName());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

3. 小结：

方法1在两个session中执行load方法，只会发出一次SQL，因为二级缓存是生命周期是SessionFactory而不再是session.

方法2禁用了一级缓存与二级缓存的交互，所以仍会发出两次SQL。

【总结】

缓存对性能的提升有着很大的作用，利用适当的缓存策略，对ORM的实现也是弥补了其它的开销。但也并不是对所有的数据都应该采用缓存策略，纳入缓存管理也需要满足一些条件：如数据不会被第三方应用修改；数据大小在可接受的范围内；数据更新频率低等。

EricaLSR

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
23
评论
【Hibernate】---- 数据缓存

【概述】对于ORM实现而言，缓存显得尤为重要，它是持久层性能提升的关键。相对JDBC数据存取，ORM存取往往需要更加复杂的机制，以实现内部状态的管理、OR关系的映射等。这些额外的开销使得ORM数据访问效率相对较低。如何弥补这里产生的性能差距？数据缓存是其中一个关键策略。【原理】 ORM在进行数据读取时，会根据其缓存管理策略，首先在缓存中查询，如
复制链接

扫一扫