Hibernate学习16（二级缓存）

一级不会跨Session Session关闭缓存消失

二级缓存 SessionFactory缓存

• 1.内置缓存：映射文件保存

• 2.外置缓存：存放缓存的数据

适合放的数据：

• 1.很少修改的

• 2.不是很重要，有并发

步骤：

• 1.加入jar（都在hibernate文件中）

ehcache

• 2.加入ehcache.xml配置文件 （都在hibernate文件中）

<ehcache>
    <!-- 配置磁盘缓存路径 -->
    <!-- SessionFactory关闭时目录文件会被删除 -->
    <diskStore path="java.io.tmpdir"/>


   <!-- 默认的缓存数据过期策略 -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

   <!-- 设置具体命名缓存的过期策略，每个命名缓存代表一个缓存区域 -->
   <!-- 缓存区域：一个具有名称的缓存块，可以给缓存快块设置不同的缓存策略，
                  没有设置使用默认的 
        hibernate在不同的缓存区域保存不同的类/集合
            类：区域的名称是全类名
            集合：区域名是全类名加属性名
   -->
   
    <cache name="hql.Employee"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />
        
        <!-- 
        name：设置缓存名
        maxElementsInMemory：可以在内存缓存中可存放的对象最大数目
        eternal：设置对象是否是永久的，true表示永不过期，忽略timeToIdleSeconds timeToLiveSeconds属性
        timeToIdleSeconds：对象空闲最大时间，秒为单位 对象没有在这个时间类被使用会被清除
        timeToLiveSeconds：设置对象最大生存时间，超过这个时间对象会被清除，0表示无限期
        overflowToDisk：缓存数达到内存中最大时，是否把多余的数据存放到磁盘缓存中
         -->
        
     <cache name="hql.Department.employees"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />
    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->
</ehcache>

• 3.hibernate.cfg.xml 配置
  1).开启缓存
  2).配置二级缓存产品（ehcache）
  3).配置需要缓存持久化类 和缓存策略

        <!-- 启用二级缓存 -->
        <property name="cache.use_second_level_cache">true</property>
        <!-- 配置使用二级缓存产品 ehcache-->
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.EhCacheRegionFactory</property>
        <!-- 设置启用查询缓存 -->
        <property name="cache.use_query_cache">true</property>
        
        <mapping resource="hql/Department.hbm.xml" />
        <mapping resource="hql/Employee.hbm.xml" />
        <mapping resource="chen/House.hbm.xml" />
        <mapping resource="chen/User.hbm.xml" />
        
        
        <!-- 配置那个持久化类启用二级缓存 -->
        <class-cache usage="read-write" class="hql.Employee"/> 
        <!-- 缓存集合属性 -->
        <class-cache usage="read-write" class="hql.Department"/>
        <!-- 设置集合属性为二级缓存 没有缓存集合中元素使这样设置只会缓存OID-->
        <collection-cache usage="read-write"  collection="hql.Department.employees"/>
        

夸SessionFactory缓存调用

    /**
     * 二级缓存
     * 一级不会跨Session Session关闭缓存消失
     * 二级缓存SessionFactory 缓存
     *      1.内置缓存：映射文件保存
     *      2.外置缓存：存放缓存的数据
     * 
     * 适合放的数据：
     * 1.很少修改的
     * 2.不是很重要，有并发
     * 
     * 步骤
     * 1.加入jar（都在hibernate文件中）
     * 2.加入ehcache.xml配置文件 （都在hibernate文件中）
     * 3.hibernate.cfg.xml 配置
     *      1).开启缓存 
     *      2).配置二级缓存产品（ehcache）
     *      3).配置需要缓存持久化类 和缓存策略
     * */
    public static void cache() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        Employee employee1=session.get(Employee.class, 1);
        System.out.println(employee1.getName());
        
        transaction.commit();
        session.close();
        session=null;
        transaction=null;
        
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
        Employee employee2=session.get(Employee.class, 1);
        System.out.println(employee2.getName());
        
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

集合二级缓存

• 在hibernate.cfg.xml 配置要配置元素中的持久化类配置二级缓存
• 在hibernate.cfg.xml 配置集合

查询缓存 默认无效

• 1.默认情况下 设置的缓存对HQL QBC查询时无效的

步骤：

• 1.在hibernate.cfg.xml文件声明开启查询缓存

• 2.显示调用query.setCacheable(true);

• 3.查询缓存依赖二级缓存

    /**
     * 集合二级缓存 查询缓存
     * 1.默认情况下 设置的缓存对HQL QBC查询时无效的
     * 步骤：
     * 1.在hibernate.cfg.xml文件声明开启查询缓存
     * 2.显示调用query.setCacheable(true);
     * 3.查询缓存依赖二级缓存
     * */
    public static void cacheQuery() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        String hql = "FROM Employee ";
        Query query = session.createQuery(hql);
        query.setCacheable(true);
        
        List<Employee> es = query.list();//第一次查询
        System.out.println(es.size());
        List<Employee> es2 = query.list();//二次查询
        
        
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

更新时间戳缓存

    /**
     * 更新时间戳缓存
     * 缓存被修改时 更新缓存
     * */
    public static void cacheData() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        String hql = "FROM Employee ";
        Query query = session.createQuery(hql);
        query.setCacheable(true);
        
        List<Employee> es = query.list();//第一次查询
        Employee e = session.get(Employee.class, 1);
        e.setName("我改了");
        System.out.println(es.size());
        List<Employee> es2 = query.list();//二次查询
        
        
        transaction.commit();
        session.close();
        sessionFactory.close();
    }