struts缓存

hibernate一级缓存

这里要说hibernate一级缓存，也就是事务级缓存。首先，我们要知道什么是缓存，缓存的概念。
缓存：所谓的缓存,就是将程序或系统经常要调用的对象存在内存中,一遍其使用时可以快速调用,不必再去创建新的重复的实例。
然后我们得清楚hibernate持久化对象的四个状态。他们分别为瞬时态、持久态、托管态、删除态。

瞬时态：也称为临时态，他是实例化对象时所存在的一种状态，不存在OID，没有与session与数据库关联。

持久态：对面已经被session管理，例如在运行session.get()方法时，对象就被纳入了session管理，此时就是持久态,存在OID。

托管态：session被关闭后，此时就进入了托管态，存在OID

删除态：session与数据库中都没有数据

首先，我们来说说一级缓存。在hibernate中，一级缓存是默认打开的，当我们在查询一个对象时，hibernate就自动将持久化对象进行缓存，同时，hibernate也会将所得到的数据复制一份到快照中。在我们进行事务提交时，hibernate会自动的将一级缓存与快照进行对比，若存在差异，则进行同步，同时将数据同步到数据库.。那么，一级缓存如何清除呢？下面，我会介绍三种方式。

 1. 调用close()方法，直接关闭session。为什么我说直接关闭session会清除一级缓存呢？那是一级缓存的存储范围是事务级的，你关闭了session，事务也就不存在了，都没有地方存储了，当然也就清除了缓存。

 2. 调用clear()方法，hibernate也会帮助你清除你所有的缓存。

 3. 调用evict()方法，hibernate会帮助你清除你想要清除的对象。

下面，我们来体验一下hibernate的一级缓存。

代码

public class Test {
	//定义对象
     private Configuration configuration ;
     private SessionFactory sessionFactory ;
     private Session session;
    //初始化对象
    {
        configuration = new Configuration().configure();
        sessionFactory = configuration.buildSessionFactory();
        session = sessionFactory.openSession();
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.get();
    }
	//一级缓存
    public void get(){
        Transaction transaction = session.beginTransaction();
        Student student = session.get(Student.class,1);
        System.out.println(student.getName());
        Student student1 = session.get(Student.class,1);
        System.out.println(student1.getName());;
        transaction.commit();
        session.close();
    }
}

结果

从这里我们可以看出来 ，我们进行了两次查询，结果只进行了一次数据库操作，说明第二次查询是从缓存中直接取出来的。这样就会减少数据库的操作次数，提高程序的性能。

二级缓存

hibernate二级缓存是SessionFactory来管理的,是夸session共享的。
由于hibernate的二级缓存是由第三方提供的，所以我们需要导入第三方jar包，分别是ehcache-2.10.6.jar,hibernate-ehcache-5.4.6.Final.jar,slf4j-api-1.7.25.jar

hibernate二级缓存实例

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!-- path : 指定在硬盘上存储对象的路径-->
    <!--
　　     指定二级缓存存放在磁盘上的位置，可以使用磁盘目录，
        也可以使用Java System Property目录，
        user.home是用户目录、
        user.dir是用户当前工作目录、
        java.io.tmpdir是默认临时文件路径
　　-->
<!--    <diskStore path="java.io.tmpdir/Tmp_EhCache" />-->
    <diskStore path="I:/"/>
    <!-- defaultCache：默认的管理策略-->
    <!-- eternal : 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断-->
    <!-- maxElementsInMemory : 内存中最大缓存对象数 -->
    <!-- overflowToDisk : 配置此属性，当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中。 -->
    <!-- diskPersistent：是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false -->
    <!-- timeToIdleSeconds : 对象空闲时间(单位：秒)，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问-->
    <!-- timeToLiveSeconds : 对象存活时间(单位：秒)，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问 -->
    <!-- memoryStoreEvictionPolicy：缓存的3 种清空策略
            FIFO：first in first out (先进先出)
            LFU：Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存
            LRU：Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存
    -->
    <defaultCache
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU" />
    <!--想使用查询缓存，这两个类需要添加-->
    <cache name="org.hibernate.cache.spi.TimestampsCache"
           maxElementsInMemory="5000"
           eternal="true"
           overflowToDisk="true" />
    <cache name="org.hibernate.cache.internal.StandardQueryCache"
           maxElementsInMemory="10000"
           timeToLiveSeconds="120"
           overflowToDisk="true" />
    <cache name="javaClassName"
           maxElementsInMemory="2000"
           timeToIdleSeconds="120"
           timeToLiveSeconds="120"
           overflowToDisk="true" />

</ehcache>

class_range_hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

    <class name="com.hibernateDemo.entity.ClassRange" table="class_range">
        <cache usage="read-write"/>
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="range" column="range" type="java.lang.String"/>
        <property name="studentName" column="student_name" type="java.lang.String"/>
    </class>
</hibernate-mapping>

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/huashy?useSSL=false&amp;serverTimezone=UTC</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>

        <!-- 配置数据库方言-->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <!-- 本地事务 -->
        <property name="hibernate.current_session_context_class">thread</property>
<!--        &lt;!&ndash; 全局事务&ndash;&gt;-->
<!--        <property name="hibernate.current_session_context_class">jta</property>-->

        <!--开启查询缓存-->
        <property name="hibernate.cache.use_query_cache">true</property>
        <!--开启二级缓存-->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <!--EhCache驱动-->
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.internal.SingletonEhcacheRegionFactory</property>
        <mapping resource="com/hibernateDemo/class.range.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

Test.java(测试类)

package com.hibernateDemo.test;

import com.hibernateDemo.entity.ClassRange;
import com.hibernateDemo.entity.Student;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import java.util.List;


public class Test {
     private Configuration configuration ;
     private SessionFactory sessionFactory ;
     private Session session;
    {
        configuration = new Configuration().configure();
        sessionFactory = configuration.buildSessionFactory();
        session = sessionFactory.openSession();
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.getTwo();
    }
    /**
     * 二级缓存
     */
    public void getTwo(){
        Transaction transaction = session.beginTransaction();//创建事务
        ClassRange classRange=session.get(ClassRange.class,1);//查询id为1的数据
        System.out.println(classRange.getStudentName());
        transaction.commit();//提交事务
        session.close();//关闭session

        Session session1 = sessionFactory.openSession();
        ClassRange classRange1 = session1.get(ClassRange.class,1);
        System.out.println(classRange1.getStudentName());
        session1.close();
    }
}

控制台打印结果

根据输出我们可以看出，一共只对数据库进行了一次操作，第二次的输出结果是直接从缓存中拿的。