spring boot + spring cache 实现两级缓存（redis + ehcache）

前言

本文参考了spring boot + spring cache 实现两级缓存（redis + caffeine）。

处理流程

与spring boot + spring cache 实现两级缓存（redis + caffeine）一致：

事项

• spring cache中有实现Cache接口的一个抽象类AbstractValueAdaptingCache，包含了空值的包装和缓存值的包装，所以就不用实现Cache接口了，直接实现AbstractValueAdaptingCache抽象类
• 利用redis的pub/sub功能，实现多服务实例的本地缓存一致性
• 原来的有个缺点：服务1给缓存put完KV后推送给redis的消息，服务1本身也会接收到该消息，然后会将刚刚put的KV删除。这里把ehcacheCache的hashcode传过去，避免这个问题。
• 代码用了lombok

配置

1.@EnableCaching：启用spring cache缓存，在spring boot的启动类或配置类上需要加上此注解才会生效

2.yml

# redis-starter的配置
spring:
  cache:
    cache-names: cache1,cache2,cache3
  redis:
    timeout: 10000
    pool:
      max-idle: 10
      min-idle: 2
      max-active: 10
      max-wait: 3000
#自定义配置。expire统一单位为毫秒
cache:
  multi:
    cacheNames: cache1,cache2,cache3
    ehcache:
      expireAfterWrite: 5000
      maxEntry: 1000
    redis:
      defaultExpiration: 60000
      expires:
        cache1: 50000
        cache2: 70000
        cache3: 70000   

3.POM
依赖项

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-redisartifactId>
            <version>1.4.3.RELEASEversion>
        dependency>

        <dependency>
            <groupId>org.ehcachegroupId>
            <artifactId>ehcacheartifactId>
            <version>3.5.2version>
        dependency>

代码

定义properties配置属性类

@ConfigurationProperties(prefix = "cache.multi")
@Data
public class RedisEhcacheProperties {
    private Set cacheNames = new HashSet<>();

    /** 是否存储空值，默认true，防止缓存穿透*/
    private boolean cacheNullValues = true;

    /** 是否动态根据cacheName创建Cache的实现，默认true*/
    private boolean dynamic = true;

    /** 缓存key的前缀*/
    private String cachePrefix;

    private Redis redis = new Redis();

    private Ehcache ehcache = new Ehcache();

    public boolean isCacheNullValues() {
        return cacheNullValues;
    }

    @Data
    public class Redis {

        /** 全局过期时间，单位毫秒，默认不过期*/
        private long defaultExpiration = 0;

        /** 每个cacheName的过期时间，单位毫秒，优先级比defaultExpiration高*/
        private Map expires = new HashMap<>();

        /** 缓存更新时通知其他节点的topic名称*/
        private String topic = "cache:redis:ehcache:topic";

    }

    @Data
    public class Ehcache {

        /**
         * 访问后过期时间，单位毫秒
         */
//        private long expireAfterAccess;

        /**
         * 写入后过期时间，单位毫秒
         */
        private long expireAfterWrite;


        /**
         * 初始化大小
         */
//        private int initialCapacity;

        /**
         * 每个ehcache最大缓存对象个数，超过此数量时按照失效策略（默认为LRU）
         */
        private long maxEntry = 500;

    }
}

RedisEhcacheCache

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Slf4j
public class RedisEhcacheCache extends AbstractValueAdaptingCache {

    private String name;

    private RedisTemplate redisTemplate;

    private Cache ehcacheCache;

    private String cachePrefix;

    private long defaultExpiration = 0;

    private Map expires;

    private String topic = "cache:redis:ehcache:topic";

    protected RedisEhcacheCache(boolean allowNullValues) {
        super(allowNullValues);
    }

    public RedisEhcacheCache(String name, RedisTemplate redisTemplate, Cache ehcacheCache, RedisEhcacheProperties redisEhcacheProperties) {
        super(redisEhcacheProperties.isCacheNullValues());
        this.name = name;
        this.redisTemplate = redisTemplate;
        this.ehcacheCache = ehcacheCache;
        this.cachePrefix = redisEhcacheProperties.getCachePrefix();
        this.defaultExpiration = redisEhcacheProperties.getRedis().getDefaultExpiration();
        this.expires = redisEhcacheProperties.getRedis().getExpires();
        this.topic = redisEhcacheProperties.getRedis().getTopic();
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Object getNativeCache() {
        return this;
    }

    @SuppressWarnings("unchecked")
    @Override
    public  T get(Object key, Callable valueLoader) {
        Object value = lookup(key);
        if(value != null) {
            return (T) value;
        }

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock();
            value = lookup(key);
            if(value != null) {
                return (T) value;
            }
            value = valueLoader.call();
            Object storeValue = toStoreValue(valueLoader.call());
            put(key, storeValue);
            return (T) value;
        } catch (Exception e) {
            try {
                Class c = Class.forName("org.springframework.cache.Cache$ValueRetrievalException");
                Constructor constructor = c.getConstructor(Object.class, Callable.class, Throwable.class);
                RuntimeException exception = (RuntimeException) constructor.newInstance(key, valueLoader, e.getCause());
                throw exception;
            } catch (Exception e1) {
                throw new IllegalStateException(e1);
            }
        } finally {
            lock.unlock();
        }
    }

    //从持久层读取value，然后存入缓存。允许value = null
    @Override
    public void put(Object key, Object value) {
        if (!super.isAllowNullValues() && value == null) {
            this.evict(key);
            return;
        }
        long expire = getExpire();
        if(expire > 0) {
            redisTemplate.opsForValue().set(getKey(key), toStoreValue(value), expire, TimeUnit.MILLISECONDS);
        } else {
            redisTemplate.opsForValue().set(getKey(key), toStoreValue(value));
        }

        //通过redis推送消息，使其他服务的ehcache失效。
        //原来的有个缺点：服务1给缓存put完KV后推送给redis的消息，服务1本身也会接收到该消息，
        // 然后会将刚刚put的KV删除。这里把ehcacheCache的hashcode传过去，避免这个问题。
        push(new CacheMessage(this.name, key, this.ehcacheCache.hashCode()));

        ehcacheCache.put(key, value);
    }
    //key的生成    name:cachePrefix:key
    private Object getKey(Object key) {
        return this.name.concat(":").concat(StringUtils.isEmpty(cachePrefix) ? key.toString() : cachePrefix.concat(":").concat(key.toString()));
    }

    private long getExpire() {
        long expire = defaultExpiration;
        Long cacheNameExpire = expires.get(this.name);
        return cacheNameExpire == null ? expire : cacheNameExpire.longValue();
    }

    @Override
    public ValueWrapper putIfAbsent(Object key, Object value) {
        Object cacheKey = getKey(key);
        Object prevValue = null;
        // 考虑使用分布式锁，或者将redis的setIfAbsent改为原子性操作
        synchronized (key) {
            prevValue = redisTemplate.opsForValue().get(cacheKey);
            if(prevValue == null) {
                long expire = getExpire();
                if(expire > 0) {
                    redisTemplate.opsForValue().set(getKey(key), toStoreValue(value), expire, TimeUnit.MILLISECONDS);
                } else {
                    redisTemplate.opsForValue().set(getKey(key), toStoreValue(value));
                }

                push(new CacheMessage(this.name, key, this.ehcacheCache.hashCode()));

                ehcacheCache.put(key, toStoreValue(value));
            }
        }
        return toValueWrapper(prevValue);
    }

    @Override
    public void evict(Object key) {
        // 先清除redis中缓存数据，然后清除ehcache中的缓存，避免短时间内如果先清除ehcache缓存后其他请求会再从redis里加载到ehcache中
        redisTemplate.delete(getKey(key));

        push(new CacheMessage(this.name, key, this.ehcacheCache.hashCode()));

        ehcacheCache.remove(key);
    }

    @Override
    public void clear() {
        // 先清除redis中缓存数据，然后清除ehcache中的缓存，避免短时间内如果先清除ehcache缓存后其他请求会再从redis里加载到ehcache中
        Set