hibernate框架学习之二级缓存（测试用例）

HqlDemoApp.java

package cn.itcast.h3.query.hql;

import java.io.Serializable;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import cn.itcast.h3.query.hql.vo.StudentModel;
import cn.itcast.h3.query.hql.vo.TeacherModel;
import cn.itcast.util.HibernateUtil;

public class HqlDemoApp {
    //测试是否存在二级缓存
    void testHasCache(){
        Session s = HibernateUtil.getSession();
        //读取数据，并且将数据加载入当前Session的一级缓存，
        //同时加载到当前SessionFactory的二级缓存
        TeacherModel tm1 = (TeacherModel) s.get(TeacherModel.class, 3L);
        System.out.println(tm1);
        //读取的是当前Session的一级缓存数据
        TeacherModel tm2 = (TeacherModel) s.get(TeacherModel.class, 3L);
        System.out.println(tm2);
        s.close();
        System.out.println("-----------------------------");
        Session s2 = HibernateUtil.getSession();
        //读取的是二级缓存的数据
        TeacherModel tm3 = (TeacherModel) s2.get(TeacherModel.class, 3L);
        System.out.println(tm3);
        TeacherModel tm5 = (TeacherModel) s2.get(TeacherModel.class, 3L);
        System.out.println(tm5);
        s2.close();
        System.out.println("--------------------------");
        Session s3 = HibernateUtil.getSession();
        //读取的是二级缓存的数据
        TeacherModel tm4 = (TeacherModel) s3.get(TeacherModel.class, 3L);
        System.out.println(tm4);
        s3.close();
        
    }
    //测试SQL查询数据是否加载二级缓存
    void testQueryToCache(){
        Session s = HibernateUtil.getSession();
        Query q = s.createQuery("from TeacherModel");
        q.list();
        Query q2 = s.createQuery("from TeacherModel");
        q2.list();
        s.close();
        System.out.println("--------------------");
        Session s3 = HibernateUtil.getSession();
        TeacherModel tm4 = (TeacherModel) s3.get(TeacherModel.class, 3L);
        System.out.println(tm4);
        s3.close();
    }
    //测试SQL查询是否读取二级缓存数据
    void testQueryToCache2(){
        Session s3 = HibernateUtil.getSession();
        TeacherModel tm4 = (TeacherModel) s3.get(TeacherModel.class, 3L);
        System.out.println(tm4);
        s3.close();
        System.out.println("--------------------");
        Session s = HibernateUtil.getSession();
        Query q = s.createQuery("from TeacherModel where uuid = :uuid");
        q.setLong("uuid", 3L);
        TeacherModel tm = (TeacherModel) q.uniqueResult();
        System.out.println(tm);
        s.close();
        
    }
    //测试保存数据是否影响二级缓存数据
    void testSaveToCache(){
        //保存数据
        Session s3 = HibernateUtil.getSession();
        Transaction t = s3.beginTransaction();
        TeacherModel tm = new TeacherModel();
        tm.setTeacherName("aaa");
        tm.setNick("bbb");
        
        Serializable uuid = s3.save(tm);
        
        t.commit();
        s3.close();
        
        System.out.println("--------------------");
        
        Session s = HibernateUtil.getSession();
        TeacherModel tm4 = (TeacherModel) s.get(TeacherModel.class, uuid);
        System.out.println(tm4);
        s.close();
        
    }
    //测试删除数据是否影响二级缓存数据
    void testDeleteToCache(){
        //保存数据
        Session s3 = HibernateUtil.getSession();
        Transaction t = s3.beginTransaction();
        TeacherModel tm = (TeacherModel) s3.get(TeacherModel.class, 6L);
        
        s3.delete(tm);
        
        t.commit();
        s3.close();
        
        System.out.println("--------------------");
        
        Session s = HibernateUtil.getSession();
        TeacherModel tm4 = (TeacherModel) s.get(TeacherModel.class, 6L);
        System.out.println(tm4);
        s.close();
        
    }
    //测试更新数据是否影响二级缓存数据
    void testUpdateToCache(){
        //保存数据
        Session s3 = HibernateUtil.getSession();
        Transaction t = s3.beginTransaction();
        TeacherModel tm = (TeacherModel) s3.get(TeacherModel.class, 4L);
        tm.setTeacherName("hahahh");
        s3.update(tm);
        t.commit();
        s3.close();
        
        System.out.println("--------------------");
        
        Session s = HibernateUtil.getSession();
        TeacherModel tm4 = (TeacherModel) s.get(TeacherModel.class, 4L);
        System.out.println(tm4);
        s.close();
        
    }
    //测试集合操作二级缓存
    void testCollectionToCache(){
        Session s = HibernateUtil.getSession();
        TeacherModel tm = (TeacherModel) s.get(TeacherModel.class, 1L);
        System.out.println(tm.getStudents());
        s.close();
        System.out.println("----------------");
        Session s2 = HibernateUtil.getSession();
        TeacherModel tm2 = (TeacherModel) s2.get(TeacherModel.class, 1L);
        System.out.println(tm2.getStudents());
        s2.close();
    }
    //DML影响二级缓存的操作
    void testDMLToCache(){
        Session s = HibernateUtil.getSession();
        Transaction t = s.beginTransaction();
        StudentModel tm = (StudentModel) s.get(StudentModel.class, 3L);
        System.out.println(tm);
        Query q = s.createQuery("update TeacherModel set teacherName=:teacherName where uuid = :uuid");
        q.setString("teacherName", "测试更新1");
        q.setLong("uuid", 4L);
        q.executeUpdate();
        t.commit();
        s.close();
        
        Session s2 = HibernateUtil.getSession();
        StudentModel tm2 = (StudentModel) s2.get(StudentModel.class, 3L);
        System.out.println(tm2);
        s2.close();
    }
    //查询缓存
    void testQueryToCache3(){
        Session s2 = HibernateUtil.getSession();
        Query q2 = s2.createQuery("from TeacherModel where uuid=:uuid");
        //本次查询开启查询缓存
        q2.setCacheable(true);
        System.out.println(q2.list());
        s2.close();
        System.out.println("-------------");
        Session s = HibernateUtil.getSession();
        Query q = s.createQuery("from TeacherModel where uuid = 2");
        q.setCacheable(true);
        System.out.println(q.list());
        s.close();
    }
    public static void main(String[] args) {
        new HqlDemoApp().testQueryToCache3();
    }
}

ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <diskStore path="d:cache-data"/>
    <cache
            name="c1"
            maxElementsInMemory="10"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="1200"
            overflowToDisk="true"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />
    <defaultCache
            maxElementsInMemory="10"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="1200"
            overflowToDisk="true"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />
</ehcache>

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!--数据库连接的配置-->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/h3</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        
        <!--方言的配置，用于区别使用何种数据库-->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        
        <!--可选配置项中，开发过程常用设置-->
        <property name="show_sql">true</property>
        <property name="format_sql">false</property>
        <!-- 开启二级缓存功能 -->
        <property name="cache.use_second_level_cache">true</property>
        <!-- 设置二级缓存供应商 -->
        <property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
        
        <!-- 开启查询缓存 -->
        <property name="cache.use_query_cache">true</property>
        
        <!-- 开启线程绑定Session -->
        <property name="current_session_context_class">thread</property>
        <!--资源文件注册-->
        <mapping resource="cn/itcast/h3/query/hql/vo/StudentModel.hbm.xml"/>
        <mapping resource="cn/itcast/h3/query/hql/vo/TeacherModel.hbm.xml"/>
        
        <!-- 二级缓存的配置(使用) -->
        <!-- 类级缓存的配置 -->
        <class-cache
            region="c1"
            usage="read-write"
            class="cn.itcast.h3.query.hql.vo.TeacherModel"
            />
        <class-cache
            region="c1"
            usage="read-write"
            class="cn.itcast.h3.query.hql.vo.StudentModel"
            />
        <!-- 集合缓存的配置 -->
        <collection-cache
            region="c1"
            usage="read-write"
            collection="cn.itcast.h3.query.hql.vo.TeacherModel.students"
            />
        
    </session-factory>
</hibernate-configuration>