Ehcache是基于Java实现的一套简单、高效且线程安全的缓存管理类库，提供了内存存储、磁盘文件存储、分布式存储等多种存储实现方案。具有快速、轻量级、可伸缩、操作简单灵活等特点，同时还支持数据持久化操作。下面我们就来详细介绍Ehcache相关内容。

Ehcache工作原理

Ehcache是基于java实现的高效缓存框架，内部采用了多线程操作实现，并且采用了LinkedHashMap作为存储单元，支持将数据持久化到物理磁盘上的操作。

特点

1. 快速：Ehcache内部采用了多线程的机制实现，数据存取能力高。
2. 轻量：Ehcache 体积小，可以实现快速方便的系统继承。
3. 可伸缩：Ehcache缓存在内存和硬盘的存储可以伸缩到数几十GB，可以实现对应的大数据场景。
4. 操作灵活：Ehcache提供了丰富的API接口，可以实现基于主键、条件等对数据进行读取，同时在Ehcache运行的时候还提供了动态修改配置的操作。极大的提升了系统的灵活性。
5. 支持多种淘汰算法：Ehcache支持最近最少使用、最少被使用和先进先出等策略。
6. 支持磁盘持久化：Ehcache支持将内存数据持久化到磁盘中的操作，在机器重启之后可以从磁盘上重新加载缓存数据。

Ehcache架构

Ehcache在架构上如图所示，由Cache Replication 、In-Process API和Core组成。其中Cache Replication存储的是缓存的副本；In-Process API是对操作缓存数据的封装，包括了Hibernate API、JMX API、Servlet Cacheing Filter API等等的操作；而Core作为Ehcache的核心部分，主要包括了用于缓存管理的CacheManager、用于缓存存储的Store和用于操作缓存的Cache API等等。NetWork API提供了各种的RestFul接口、SOAP API接口以及web接口等。

Ehcache的存储方式

Ehcache的主要存储数据的方式包括堆存储、堆外存储和磁盘存储三种。

1. 堆存储：是将缓存数据存储在Java的堆内存中，其特点就是快，但是我们知道Java堆内存的大小是有限的，所以缺点也是显而易见的。
2. 堆外存储：堆外存储是基于NIO的DirectByteBuffers来实现，将缓存数据放到堆外的内存上。其特点是要比磁盘存取的速度快，而且不会受到GC机制的影响，可以有效的保证了稳定性，但是由于分配的存储空间在堆外，所以在内存分配上要比堆内存的消耗要大，另外其存储数据必须要以字节数组的方式进行存储，所以在操作的时候必须要对数据进行序列化操作，而读取数据的时候就必须采用反序列化的方式进行操作，所以在速度上要比在堆内存中存取要慢。
3. 磁盘存储：一般的采用磁盘存储的数据都是经过了持久化操作之后的数据，这样在服务宕机重启之后就可以从磁盘上进行数据的恢复。

Ehcache的应用

在Spring Boot中使用Ehcache的组件相对比较简单，下面我们就来看看在SpringBoot中如何使用Ehcache来实现Shiro权限认证存储

第一步、引入相关的POM依赖

<!-- Shiro使用EhCache缓存框架 -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>${shiro.version}</version>
</dependency>

第二步、配置XML的配置文件

在resource目录下创建一个ehcache-shiro.xml的配置文件。

<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="select" updateCheck="false">

    <!-- 磁盘缓存位置 -->
    <diskStore path="java.io.tmpdir"/>
    
    <!-- maxEntriesLocalHeap:堆内存中最大缓存对象数，0没有限制 -->
    <!-- maxElementsInMemory： 在内存中缓存的element的最大数目。-->
    <!-- eternal:elements是否永久有效，如果为true，timeouts将被忽略，element将永不过期 -->
    <!-- timeToIdleSeconds:失效前的空闲秒数，当eternal为false时，这个属性才有效，0为不限制 -->
    <!-- timeToLiveSeconds:失效前的存活秒数，创建时间到失效时间的间隔为存活时间，当eternal为false时，这个属性才有效，0为不限制 -->
    <!-- overflowToDisk： 如果内存中数据超过内存限制，是否要缓存到磁盘上 -->
    <!-- statistics：是否收集统计信息。如果需要监控缓存使用情况，应该打开这个选项。默认为关闭（统计会影响性能）。设置statistics="true"开启统计 -->
    
    <!-- 默认缓存 -->
    <defaultCache
            maxEntriesLocalHeap="1000"
            eternal="false"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="3600"
            overflowToDisk="false">
    </defaultCache>

    <!-- 登录记录缓存 锁定10分钟 -->
    <cache name="loginRecordCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="false">
    </cache>

    <!-- 系统活跃用户缓存 -->
    <cache name="sys-userCache"
           maxEntriesLocalHeap="10000"
           overflowToDisk="false"
           eternal="false"
           diskPersistent="false"
           timeToLiveSeconds="0"
           timeToIdleSeconds="0"
           statistics="false">
    </cache>
    
    <!-- 系统用户授权缓存  没必要过期 -->
    <cache name="sys-authCache"
           maxEntriesLocalHeap="10000"
           overflowToDisk="false"
           eternal="false"
           diskPersistent="false"
           timeToLiveSeconds="0"
           timeToIdleSeconds="0"
           memoryStoreEvictionPolicy="LRU"
           statistics="false"/>
    
    <!-- 系统缓存 -->
    <cache name="sys-cache"
           maxEntriesLocalHeap="1000"
           eternal="true"
           overflowToDisk="true"
           statistics="false">
    </cache>
    
    <!-- 系统参数缓存 -->
    <cache name="sys-config"
           maxEntriesLocalHeap="1000"
           eternal="true"
           overflowToDisk="true"
           statistics="false">
    </cache>
    
    <!-- 系统字典缓存 -->
    <cache name="sys-dict"
           maxEntriesLocalHeap="1000"
           eternal="true"
           overflowToDisk="true"
           statistics="false">
    </cache>
    
    <!-- 系统会话缓存 -->
    <cache name="shiro-activeSessionCache"
           maxEntriesLocalHeap="10000"
           overflowToDisk="false"
           eternal="false"
           diskPersistent="false"
           timeToLiveSeconds="0"
           timeToIdleSeconds="0"
           statistics="false"/>
    
</ehcache>

第三步、在配置文件中加入缓存管理器

    /**
     * 缓存管理器 使用Ehcache实现
     */
    @Bean
    public EhCacheManager getEhCacheManager()
    {
        net.sf.ehcache.CacheManager cacheManager = net.sf.ehcache.CacheManager.getCacheManager("test");
        EhCacheManager em = new EhCacheManager();
        if (StringUtils.isNull(cacheManager))
        {
            em.setCacheManager(new net.sf.ehcache.CacheManager(getCacheManagerConfigFileInputStream()));
            return em;
        }
        else
        {
            em.setCacheManager(cacheManager);
            return em;
        }
    }

第四步、编写缓存操作工具类用来操作缓存

public class CacheUtils
{
    private static Logger logger = LoggerFactory.getLogger(CacheUtils.class);

    private static CacheManager cacheManager = SpringUtils.getBean(CacheManager.class);

    private static final String SYS_CACHE = "sys-cache";

    /**
     * 获取SYS_CACHE缓存
     * 
     * @param key
     * @return
     */
    public static Object get(String key)
    {
        return get(SYS_CACHE, key);
    }

    /**
     * 获取SYS_CACHE缓存
     * 
     * @param key
     * @param defaultValue
     * @return
     */
    public static Object get(String key, Object defaultValue)
    {
        Object value = get(key);
        return value != null ? value : defaultValue;
    }

    /**
     * 写入SYS_CACHE缓存
     * 
     * @param key
     * @return
     */
    public static void put(String key, Object value)
    {
        put(SYS_CACHE, key, value);
    }

    /**
     * 从SYS_CACHE缓存中移除
     * 
     * @param key
     * @return
     */
    public static void remove(String key)
    {
        remove(SYS_CACHE, key);
    }

    /**
     * 获取缓存
     * 
     * @param cacheName
     * @param key
     * @return
     */
    public static Object get(String cacheName, String key)
    {
        return getCache(cacheName).get(getKey(key));
    }

    /**
     * 获取缓存
     * 
     * @param cacheName
     * @param key
     * @param defaultValue
     * @return
     */
    public static Object get(String cacheName, String key, Object defaultValue)
    {
        Object value = get(cacheName, getKey(key));
        return value != null ? value : defaultValue;
    }

    /**
     * 写入缓存
     * 
     * @param cacheName
     * @param key
     * @param value
     */
    public static void put(String cacheName, String key, Object value)
    {
        getCache(cacheName).put(getKey(key), value);
    }

    /**
     * 从缓存中移除
     * 
     * @param cacheName
     * @param key
     */
    public static void remove(String cacheName, String key)
    {
        getCache(cacheName).remove(getKey(key));
    }

    /**
     * 从缓存中移除所有
     * 
     * @param cacheName
     */
    public static void removeAll(String cacheName)
    {
        Cache<String, Object> cache = getCache(cacheName);
        Set<String> keys = cache.keys();
        for (Iterator<String> it = keys.iterator(); it.hasNext();)
        {
            cache.remove(it.next());
        }
        logger.info("清理缓存： {} => {}", cacheName, keys);
    }

    /**
     * 从缓存中移除指定key
     * 
     * @param keys
     */
    public static void removeByKeys(Set<String> keys)
    {
        removeByKeys(SYS_CACHE, keys);
    }

    /**
     * 从缓存中移除指定key
     * 
     * @param cacheName
     * @param keys
     */
    public static void removeByKeys(String cacheName, Set<String> keys)
    {
        for (Iterator<String> it = keys.iterator(); it.hasNext();)
        {
            remove(it.next());
        }
        logger.info("清理缓存： {} => {}", cacheName, keys);
    }

    /**
     * 获取缓存键名
     * 
     * @param key
     * @return
     */
    private static String getKey(String key)
    {
        return key;
    }

    /**
     * 获得一个Cache，没有则显示日志。
     * 
     * @param cacheName
     * @return
     */
    public static Cache<String, Object> getCache(String cacheName)
    {
        Cache<String, Object> cache = cacheManager.getCache(cacheName);
        if (cache == null)
        {
            throw new RuntimeException("当前系统中没有定义“" + cacheName + "”这个缓存。");
        }
        return cache;
    }

    /**
     * 获取所有缓存
     * 
     * @return 缓存组
     */
    public static String[] getCacheNames()
    {
        return ((EhCacheManager) cacheManager).getCacheManager().getCacheNames();
    }
}

总结

到这里，我们整个的Ehcache缓存操作相关的内容就介绍完了，在实际工作中，在一些较为简单的场景中我们可以使用Ehcache来完成缓存操作，但是在一些比较复杂场景，或者是说在一些数据缓存量大的场景中，我们需要根据具体的业务需求来使用对应的缓存机制。