Hibernate之缓存机制！！！！！！

缓存：

　　是计算机领域的概念，它介于应用程序和永久性数据存储源之间。

缓存：

　　一般人的理解是在内存中的一块空间，可以将二级缓存配置到硬盘。用白话来说，就是一个存储数据的容器。我们关注的是，哪些数据需要被放入二级缓存。

缓存作用：

　　降低应用程序直接读写数据库的频率，从而提高程序的运行性能。缓存中的数据是数据存储源中数据的拷贝。缓存的物理介质通常是【内存】。

缓存分类：

　　1.Session缓存（又称作事务缓存）：Hibernate内置的，不能卸除。

　　2.SessionFactory缓存（又称作应用缓存）：使用第三方插件，可插拔。

缓存范围：

　　缓存只能被当前Session对象访问。

　　缓存的生命周期依赖于Session的生命周期，当Session被关闭后，缓存也就结束生命周期。

　　缓存被应用范围内的所有session共享,不同的Session可以共享。

　　这些session有可能是并发访问缓存，因此必须对缓存进行更新。

　　缓存的生命周期依赖于应用的生命周期，应用结束时，缓存也就结束了生命周期，二级缓存存在于应用程序范围。

一级缓存：

1.当我们通过session的save、update、saveOrUpdate方法进行操作时，如果一级缓存中没有对象，那么会从数据库中查询到这些对象，并存储到一级缓存中。
2.当我们通过session的load、get、Query的list等方法进行操作时，会先判断一级缓存中是否存在数据，如果没有才会从数据库获取，并且将查询的数据存储到一级缓存中。
3.当调用session的close方法时，session缓存将清空。

public class SessionFactoryUtil {

//    private static Configuration configuration;
//
//    private static SessionFactory factory;
//
//    static{
//        //默认加载项目根目录下的hibernate.cfg.xml
//        configuration=new Configuration().configure();
//        factory=configuration.buildSessionFactory();
//    }
//    public static synchronized Session getCureentSession()
//    {
//        return factory.getCurrentSession();
//    }



    //线程变量  get  set

    static ThreadLocal<Session> tlSession=new ThreadLocal<Session>();

    //得有SessionFactory

    public static SessionFactory factory;

    static Configuration cfg=null;

    static {

        cfg=new Configuration().configure("hibernate.cfg.xml");

        factory=cfg.buildSessionFactory();

    }



    //01.获取连接

    public static Session getSession(){

        //01.从线程变量中尝试获取

        Session session = tlSession.get();

        if (session==null){

            //用户第一次获取连接：发现线程变量中没有session，创建一个，并且放入线程变量

            session = factory.openSession();

            tlSession.set(session);

        }

        return session;

    }



    //02.释放连接

    public static void closeSession(){

        Session session = tlSession.get();

        if (session!=null){

            //线程变量set成null

            tlSession.set(null);

            session.close();

        }

    }

public class AppTest 
{
    private static Transaction transaction;
    private static Session session;

    @Before
    public void one(){

        //创建一个会话
        session= SessionFactoryUtil.getSession();
        //开启事务
        transaction=session.beginTransaction();

    }

    @After
    public void close(){
        transaction.commit();
    }

 /**
     * 是否存在一级缓存
     */

    @Test
    public void test13(){
        Criteria criteria=session.createCriteria(District.class);
        District load = (District) session.load(District.class, 1);
        System.out.println(load.getName());
        System.out.println("==================");
        District load2 = (District) session.get(District.class, 1);
        System.out.println(load2.getName());
    }

　　在这里控制台输出一条SQL时证明一级缓存存在

二级缓存：

　　SessionFactory级别的缓存，可以跨越Session存在，可以被多个Session所共享。

　　在cfg.xml文件中配置相关的节点

<!--开启hibernate需要的2级缓存 -->
 <property name="cache.use_second_level_cache">true</property>
<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

<!--指定那个类需要开启二级缓存 -->

<class-cache class="com.msss.pojo.District" usage="read-write"></class-cache>

ehcache.xml 配置

<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User's home directory
         user.dir - User's current working directory
         java.io.tmpdir - Default temp file path -->
　　
　　<!--指定二级缓存存放在磁盘上的位置-->
    <diskStore path="user.dir"/>　　

　　<!--我们可以给每个实体类指定一个对应的缓存，如果没有匹配到该类，则使用这个默认的缓存配置-->
    <defaultCache
        maxElementsInMemory="10000"　　//在内存中存放的最大对象数
        eternal="false"　　　　　　　　　//是否永久保存缓存，设置成false
        timeToIdleSeconds="120"　　　　
        timeToLiveSeconds="120"　　　　
        overflowToDisk="true"　　　　　//如果对象数量超过内存中最大的数，是否将其保存到磁盘中，设置成true
        />
　　
　　<!--
　　　　1、timeToLiveSeconds的定义是：以创建时间为基准开始计算的超时时长；
　　　　2、timeToIdleSeconds的定义是：在创建时间和最近访问时间中取出离现在最近的时间作为基准计算的超时时长；
　　　　3、如果仅设置了timeToLiveSeconds，则该对象的超时时间=创建时间+timeToLiveSeconds，假设为A；
　　　　4、如果没设置timeToLiveSeconds，则该对象的超时时间=max(创建时间，最近访问时间)+timeToIdleSeconds，假设为B；
　　　　5、如果两者都设置了，则取出A、B最少的值，即min(A,B)，表示只要有一个超时成立即算超时。
　　-->

　　<!--可以给每个实体类指定一个配置文件，通过name属性指定，要使用类的全名-->
    <cache name="com.xiaoluo.bean.Student"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->


</ehcache>

什么样的数据适合存放到第二级缓存中？ 　　
　　1.很少被修改的数据 　　
　　2.不是很重要的数据，允许出现偶尔并发的数据 　　
　　3.不会被并发访问的数据 　　
　　4. 常量数据 　　

不适合存放到第二级缓存的数据？ 　　
　　1. 经常被修改的数据 　　
　　2.绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　
　　3.与其他应用共享的数据。

一级缓存与二级缓存的对比图：

	一级缓存	二级缓存
存放数据的形式	相互关联的持久化对象	对象的散装数据
缓存的范围	事务范围，每个事务都拥有单独的一级缓存	进程范围或集群范围，缓存被同一个进程或集群范围内所有事务共享
并发访问策略	由于每个事务都拥有单独的一级缓存不会出现并发问题，因此无须提供并发访问策略	由于多个事务会同时访问二级缓存中的相同数据，因此必须提供适当的并发访问策略，来保证特定的事务隔离级别
数据过期策略	处于一级缓存中的对象永远不会过期，除非应用程序显示清空或者清空特定对象	必须提供数据过期策略，如基于内存的缓存中对象的最大数目，允许对象处于缓存中的最长时间，以及允许对象处于缓存中的最长空闲时间
物理介质	内存	内存和硬盘，对象的散装数据首先存放到基于内存的缓存中，当内存中对象的数目达到数据过期策略的maxElementsInMemory值，就会把其余的对象写入基于硬盘的缓存中
缓存软件实现	在Hibernate的Session的实现中包含	由第三方提供，Hibernate仅提供了缓存适配器，用于把特定的缓存插件集成到Hibernate中
启用缓存的方式	只要通过Session接口来执行保存，更新，删除，加载，查询，Hibernate就会启用一级缓存，对于批量操作，如不希望启用一级缓存，直接通过JDBCAPI来执行	用户可以再单个类或类的单个集合的粒度上配置第二级缓存，如果类的实例被经常读，但很少被修改，就可以考虑使用二级缓存，只有为某个类或集合配置了二级缓存，Hibernate在运行时才会把它的实例加入到二级缓存中
用户管理缓存的方式	一级缓存的物理介质为内存，由于内存的容量有限，必须通过恰当的检索策略和检索方式来限制加载对象的数目，Session的evit（）方法可以显示的清空缓存中特定对象，但不推荐	二级缓存的物理介质可以使内存和硬盘，因此第二级缓存可以存放大容量的数据，数据过期策略的maxElementsInMemory属性可以控制内存中的对象数目，管理二级缓存主要包括两个方面：选择需要使用第二级缓存的持久化类，设置合适的并发访问策略；选择缓存适配器，设置合适的数据过期策略。SessionFactory的evit（）方法也可以显示的清空缓存中特定对象，但不推荐