spring整合ehcache和redis缓存

1.redis已在上一篇中集成，这里就直接上ehcache了

https://blog.csdn.net/qweasdassd/article/details/108551393

需要jar报：ehcache-2.10.5.jar
ehcache-core-2.4.5.jar
ehcache-spring-annotations-1.2.0.jar

2.配置ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache dynamicConfig="false" monitoring="off" updateCheck="false"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

    <!-- diskStore：ehcache其实是支持内存+磁盘+堆外内存，几个层级的缓存 -->
    <!-- 在这里设置一下，但是一般不用的 ，这里是基于磁盘的缓存-->
    <diskStore path="java.io.tmpdir/Tmp_EhCache" />

    <!-- defaultCache，是默认的缓存策略 -->
    <!-- 如果你指定的缓存策略没有找到，那么就用这个默认的缓存策略 -->
    <!-- external：如果设置为true的话，那么timeout就没有效果，缓存就会一直存在，一般默认就是false -->
    <!-- maxElementsInMemory：内存中可以缓存多少个缓存条目，在实践中，
    		你是需要自己去计算的，比如你计算你要缓存的对象是什么？有多大？最多可以缓存多少MB，或者多少个G的数据？除以每个对象的大小，计算出最多可以放多少个对象 -->
    <!-- overflowToDisk：如果内存不够的时候，是否溢出到磁盘 -->
    <!-- diskPersistent：是否启用磁盘持久化的机制，在jvm崩溃的时候和重启之间，不用 -->
    <!-- timeToIdleSeconds：对象最大的闲置的时间，如果超出闲置的时间，可能就会过期，我们这里就不用了，缓存最多闲置5分钟就被干掉了 -->
    <!-- timeToLiveSeconds：对象最多存活的时间，我们这里也不用，超过这个时间，缓存就过期，就没了 -->
    <!-- memoryStoreEvictionPolicy：当缓存数量达到了最大的指定条目数的时候，需要采用一定的算法，
    		从缓存中清除一批数据，LRU，最近最少使用算法，最近一段时间内，最少使用的那些数据，就被干掉了 -->
    <defaultCache
            eternal="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="3600"
            memoryStoreEvictionPolicy="LRU" />

    <!-- 手动指定的缓存策略 -->
    <!-- 比如你一个应用吧，可能要缓存很多种不同的数据，比如说商品信息，或者是其他的一些数据 -->
    <!-- 对不同的数据，缓存策略可以在这里配置多种 -->
    <cache
            name="authCache"
            eternal="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="300"
            timeToLiveSeconds="0"
            memoryStoreEvictionPolicy="LRU" />

</ehcache>

3.spring加载EhcacheConfig

package com.efiles.common.ehcache;

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.ClassPathResource;

/**
 * @author 小李
 * @date 2020/9/10 21:59
 *
 * 本地堆缓存配置类
 */

@Configuration
@EnableCaching
public class EhcacheConfig {

    @Bean
    public EhCacheManagerFactoryBean ehCacheManagerFactoryBean() {
        EhCacheManagerFactoryBean cacheManagerFactoryBean = new EhCacheManagerFactoryBean();
        cacheManagerFactoryBean.setConfigLocation(new ClassPathResource("/ehcache/ehcache.xml"));
        cacheManagerFactoryBean.setShared(true);
        return cacheManagerFactoryBean;
    }

    @Bean
    @Primary	//默认使用ehcache去缓存
    public EhCacheCacheManager eCacheCacheManager(EhCacheManagerFactoryBean bean) {
        return new EhCacheCacheManager(bean.getObject());
    }
}

4.ehcache所缓存工具类EhcacheUtils

/**
 * Copyright © 2019- 航天开元科技有限公司
 */
package com.efiles.common.util;

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

/**
 * 
 * @description ehcache缓存工具类
 * @author shirb
 * @createDate 2019年8月21日
 * @since v1.0.0
 */
public class EhcacheUtils {

	private static final String path = "/ehcache/ehcache.xml";

	private CacheManager manager;

	private static EhcacheUtils ehCache;

	private EhcacheUtils(String path) {
		manager = CacheManager.create(getClass().getResource(path));
	}

	public static EhcacheUtils getInstance() {
		if (ehCache == null) {
			ehCache = new EhcacheUtils(path);
		}
		return ehCache;
	}

	/**
	 * 缓存一个对象
	 *
	 * @param cacheName
	 *            缓存的名字
	 * @param key
	 *            缓存的KEY
	 * @param value
	 *            缓存的值
	 */
	public void put(String cacheName, String key, Object value) {
		Cache cache = manager.getCache(cacheName);
		Element element = new Element(key, value);
		cache.put(element);
	}

	/**
	 * 获取一个缓存的对象，没有返回NULL
	 *
	 * @param cacheName
	 * @param key
	 * @return
	 */
	public Object get(String cacheName, String key) {
		Cache cache = manager.getCache(cacheName);
		Element element = cache.get(key);
		return element == null ? null : element.getObjectValue();
	}

	public Cache get(String cacheName) {
		return manager.getCache(cacheName);
	}

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

}

5.使用

EhcacheUtils utils = EhcacheUtils.getInstance();
if (utils.get("authCache", "authInfo") != null) {
	utils.get("authCache", "authInfo");
}