Ehcache+slf4j以及hibernate整合ehcache

学习之前我们要先了解各种数据库类型：
关系型数据库：数据与数据之间存在关系（联系）的数据库 mysql/Oracle、sqlserver
非关系型数据库：数据与数据之间是不存在关系的，key-value
1、基于文件存储的数据库：ehcache
2、基于内存存储的数据库：redis、memcache
3、基于文档存储的数据库：mongodb

什么样的数据需要缓存
很少被修改或根本不改的数据，不变的存到内存里面去。

业务场景比如：耗时较高的统计分析sql、电话账单查询sql等

ehcache是什么
Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大

4. ehcache的特点
   4.1 够快
   4.2 够简单
   4.3 够袖珍
   4.4 够轻量
   4.5 好扩展
   4.6 监听器
   4.7 分布式缓存

之前都是简单介绍 下面来弄代码：
我们先用map集合虚拟一个存储过程：

代码：

public class EhcacheDemo1 {
	static Map<String, Object> map = new HashMap<String, Object>();

	public static Object getValue(String key) {
		Object value = map.get(key);
		// 判断第一次进来是否有值
		if (value == null) {
			System.out.println("Hello Yaze");
	   //开发时，相当于从数据库里面获取数据   
			map.put(key, "存入缓存数据");
			value = map.get(key);
		}
		return value;
	}

测试main方法：
public static void main(String[] args) {
		System.out.println(getValue("Yaze"));
		System.out.println(getValue("Yaze"));
	}

运行结果：

既然是一个框架，那么我们肯定需要一个配置文件：

<?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">
    <!--磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存-->
    <!--path:指定在硬盘上存储对象的路径-->
    <!--java.io.tmpdir 是默认的临时文件路径。 可以通过如下方式打印出具体的文件路径 System.out.println(System.getProperty("java.io.tmpdir"));-->
    <diskStore path="java.io.tmpdir"/>


    <!--defaultCache：默认的管理策略-->
    <!--eternal：设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断-->
    <!--maxElementsInMemory：在内存中缓存的element的最大数目-->
    <!--overflowToDisk：如果内存中数据超过内存限制，是否要缓存到磁盘上-->
    <!--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 eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false"
                  timeToIdleSeconds="0" timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU"/>


    <!--name： Cache的名称，必须是唯一的(ehcache会把这个cache放到HashMap里)-->
    <cache name="stuCache" eternal="false" maxElementsInMemory="100"
           overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"
           timeToLiveSeconds="300" memoryStoreEvictionPolicy="LRU"/>
</ehcache>

我在这里稍微解释一下：
defaultCache：决定哪些东西过期 哪些东西不过期，一般肯定是过期的。
eternal：是否永远不过期 一般而言肯定填false。
maxElementsInMemory：当数目超过你定义 的最大数目，其他就丢到硬盘里面去。
overflowToDisk：上面代码有，与max一起使用。
其他的上面有

然后我们需要在pom.xml里面添加maven：

  <dependency>
	    <groupId>net.sf.ehcache</groupId>
	    <artifactId>ehcache</artifactId>
	    <version>2.10.0</version>
	</dependency>

下载好了以后添加一个工具类：

package com.zking.night.util;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import java.io.InputStream;

public class EhcacheUtil {

    private static CacheManager cacheManager;

    static {
        try {
            InputStream is = EhcacheUtil.class.getResourceAsStream("/ehcache.xml");
            cacheManager = CacheManager.create(is);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private EhcacheUtil() {
    }

    public static void put(String cacheName, Object key, Object value) {
        Cache cache = cacheManager.getCache(cacheName);
        if (null == cache) {
            //以默认配置添加一个名叫cacheName的Cache
            cacheManager.addCache(cacheName);
            cache = cacheManager.getCache(cacheName);
        }
        cache.put(new Element(key, value));
    }


    public static Object get(String cacheName, Object key) {
        Cache cache = cacheManager.getCache(cacheName);
        Element element = cache.get(key);
        return null == element ? null : element.getValue();
    }

    public static void remove(String cacheName, Object key) {
        Cache cache = cacheManager.getCache(cacheName);
        cache.remove(key);
    }
}

这两个工具类就是我们的存和取

框架整合：

	<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-ehcache</artifactId>
    <version>5.2.12.Final</version>
</dependency>

开启缓存：

 <!-- 开启二级缓存 -->
      <property name="hibernate.cache.use_second_level_cache">true</property>
      <!-- 开启查询缓存 -->
      <property name="hibernate.cache.use_query_cache">true</property>
      <!-- EhCache驱动 -->
      <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

hbm.xml里面添加：<cache usage="read-write" region="com.zking.one.entity.User/> cache .xml里面把东西改为 <cache name="com.zking.one.entity.User

/**
 *演示查单个用户使用了缓存
 * @param args
 */
public static void main(String[] args) {
	Session session=SessionFactoryUtil.getSession();
	Transaction transaction = session.beginTransaction();
	
	User user = session.get(User.class, 3);
	System.out.println(user);
	
	User user2 = session.get(User.class, 3);
	System.out.println(user2);
	
	User user3 = session.get(User.class, 3);
	System.out.println(user3);
	
	transaction.commit();
	SessionFactoryUtil.closeSession();
}


/**
 *演示查所有用户
 * @param args
 */
public static void main(String[] args) {
	Session session=SessionFactoryUtil.getSession();
	Transaction transaction = session.beginTransaction();
	
  List list = session.createQuery(" from User").list();
  System.out.println(list.size());
  
  List list2 = session.createQuery(" from User").list();
  System.out.println(list2.size());
	
  List list3 = session.createQuery(" from User").list();
  System.out.println(list3.size());
  
	transaction.commit();
	SessionFactoryUtil.closeSession();
	
}