实现一个轻量易用缓存发布于2022-06-12 15:58:26，更新于2022-07-03 08:41:34，标签：java 转载随意，文章会持续修订，请注明来源地址：https://meethigher.top/blog

生活很平淡，但是却很充实。想看的动漫很多、想写的代码很多，然后经常有时间不够用的感觉，惭愧惭愧。

真希望自己是个时间管理大师啊。

最近b站老给我推送纪晓岚和珅的视频，我就一直刷，然后趁着周末就追了个大半，正好最近也在写点东西，便记录一下。

写点东西，发现要引入缓存，但是只是一个单应用功能，redis部署麻烦且更吃内存，hazelcast是个不错的选择直接集成到项目但也是偏重量一点。

说白了，他们都是为了分布式而存在的，对于单节点的意义都是重量级的。便自己实现一套轻量缓存，好处嘛

1. 轻量、开箱即用
2. 基本单节点数据存储功能。基于map，lru策略、过时失效策略。

一、实现

缓存model

package top.meethigher.cachestore.model;

import java.io.Serializable;

public class CacheWrapper<V> implements Serializable {

    /**
     * 缓存数据
     */
    private V data;

    /**
     * 过期时间
     */
    private Long expireTs;

    /**
     * 创建时间
     */
    private Long createTs;

    public V getData() {
        return data;
    }

    public void setData(V data) {
        this.data = data;
    }

    public Long getExpireTs() {
        return expireTs;
    }

    public void setExpireTs(Long expireTs) {
        this.expireTs = expireTs;
    }

    public Long getCreateTs() {
        return createTs;
    }

    public void setCreateTs(Long createTs) {
        this.createTs = createTs;
    }
}

下面实现了两种缓存，一种是基于ConcurrentHashMap，一种是基于LinkedHashMap

基于ConcurrentHashMap的普通缓存

package top.meethigher.cachestore.cache.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import top.meethigher.cachestore.model.CacheWrapper;
import top.meethigher.cachestore.utils.AssertUtil;

import java.util.LinkedHashMap;
import java.util.Optional;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 默认内存中缓存存储实现
 *
 * @author chenchuancheng github.com/meethigher
 * @since 2022/6/4 21:59
 */
public class DefaultInMemoryCacheStore<K,V> extends AbstractCacheStore<K, V> {

    private final Timer timer;

    /**
     * 单位毫秒
     */
    private final long PERIOD = 1000;


    private final Logger log = LoggerFactory.getLogger(DefaultInMemoryCacheStore.class);

    private final ConcurrentHashMap<K, CacheWrapper<V>> cacheMap = new ConcurrentHashMap<>();


    private final ReentrantLock lock = new ReentrantLock();

    @SuppressWarnings("all")
    public DefaultInMemoryCacheStore() {
        this.timer = new Timer("cache-expire-cleaner");
        timer.scheduleAtFixedRate(new CacheExpireCleaner(), 0, PERIOD);
    }

    @Override
    public void delete(K key) {
        AssertUtil.notEmpty(key, "[delete] Cache key不能为空");
        cacheMap.remove(key);
    }

    @Override
    public LinkedHashMap<K, V> toMap() {
        LinkedHashMap<K, V> map = new LinkedHashMap<>();
        cacheMap.forEach((k, v) -> {
            map.put(k, v.getData());
        });
        return map;
    }

    @Override
    public Optional<CacheWrapper<V>> getInternal(K key) {
        AssertUtil.notEmpty(key, "[getInternal] Cache key不能为空");
        return Optional.ofNullable(cacheMap.get(key));
    }

    @Override
    public void putInternal(K key, CacheWrapper<V> cacheWrapper) {
        AssertUtil.notEmpty(key, "[putInternal] Cache key不能为空");
        cacheMap.put(key, cacheWrapper);
    }

    @Override
    public boolean putInternalIfAbsent(K key, CacheWrapper<V> cacheWrapper) {
        AssertUtil.notEmpty(key, "[putInternalIfAbsent] Cache key不能为空");
        AssertUtil.notEmpty(cacheWrapper, "[putInternalIfAbsent] Cache value不能为空");
        lock.lock();
        try {
            Optional<V> valueOptional = get(key);
            if (valueOptional.isPresent()) {
                log.info("[putInternalIfAbsent] 缓存中已经存在[{}], 不可重复存储", key);
                return false;
            }
            putInternal(key, cacheWrapper);
            return true;

        } finally {
            lock.unlock();
        }
    }


    @Override
    public void clear() {
        cacheMap.clear();
    }

    private class CacheExpireCleaner extends TimerTask {
        @Override
        public void run() {
            cacheMap.keySet().forEach(x -> {
                if (!DefaultInMemoryCacheStore.this.get(x).isPresent()) {
                    log.info("缓存[{}]已过期", x);
                }
            });
        }
    }


}

基于LinkedHashMap的LRU策略

package top.meethigher.cachestore.cache.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import top.meethigher.cachestore.model.CacheWrapper;
import top.meethigher.cachestore.utils.AssertUtil;

import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Least Recently Used
 * 最近最少使用缓存优先淘汰
 *
 * @author chenchuancheng
 * @since 2022/6/10 15:58
 */
public class LruInMemoryCacheStore<K, V> extends AbstractCacheStore<K, V> {

    private final Logger log = LoggerFactory.getLogger(LruInMemoryCacheStore.class);
    /**
     * 定时器
     */
    private final Timer timer;

    /**
     * 单位毫秒
     */
    private final long PERIOD = 1000;


    /**
     * 读写锁
     */
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();


    /**
     * 读锁
     */
    private final Lock readLock = readWriteLock.readLock();

    /**
     * 写锁
     */
    private final Lock writeLock = readWriteLock.writeLock();


    /**
     * lruCacheMap
     */
    private final LruMap cacheMap;


    public LruInMemoryCacheStore() {
        //最大容量为int的最大值
        this(1 << 30);
    }

    @SuppressWarnings("all")
    public LruInMemoryCacheStore(int maxCapacity) {
        cacheMap = new LruMap(maxCapacity);
        this.timer = new Timer("lru-cache-expire-cleaner");
        timer.scheduleAtFixedRate(new LruInMemoryCacheStore.LruCacheExpireCleaner(), 0, PERIOD);
    }

    @Override
    public Optional<CacheWrapper<V>> getInternal(K key) {
        readLock.lock();
        try {
            AssertUtil.notEmpty(key, "[getInternal] Cache key不能为空");
            return Optional.ofNullable(cacheMap.get(key));
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void putInternal(K key, CacheWrapper<V> cacheWrapper) {
        writeLock.lock();
        try {
            AssertUtil.notEmpty(key, "[putInternal] Cache key不能为空");
            cacheMap.put(key, cacheWrapper);
        } finally {
            writeLock.unlock();
        }
    }

    @Override
    public boolean putInternalIfAbsent(K key, CacheWrapper<V> cacheWrapper) {
        AssertUtil.notEmpty(key, "[putInternalIfAbsent] Cache key不能为空");
        AssertUtil.notEmpty(cacheWrapper, "[putInternalIfAbsent] Cache value不能为空");
        writeLock.lock();
        try {
            Optional<V> valueOptional = get(key);
            if (valueOptional.isPresent()) {
                log.info("[putInternalIfAbsent] 缓存中已经存在[{}], 不可重复存储", key);
                return false;
            }
            putInternal(key, cacheWrapper);
            return true;

        } finally {
            writeLock.unlock();
        }
    }

    @Override
    public void delete(K key) {
        writeLock.lock();
        try {
            AssertUtil.notEmpty(key, "[delete] Cache key不能为空");
            cacheMap.remove(key);
        } finally {
            writeLock.unlock();
        }
    }

    @Override
    public LinkedHashMap<K, V> toMap() {
        readLock.lock();
        try {
            LinkedHashMap<K, V> map = new LinkedHashMap<>();
            cacheMap.forEach((k, v) -> {
                map.put(k, v.getData());
            });
            return map;
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void clear() {
        writeLock.lock();
        try {
            cacheMap.clear();
        } finally {
            writeLock.unlock();
        }
    }

    private class LruCacheExpireCleaner extends TimerTask {
        @Override
        public void run() {
            writeLock.lock();
            try {
                //注意不能在map遍历时删除，所以此处将keySet另存，而不是直接使用keySet
                Set<K> keySet = new HashSet<>(cacheMap.keySet());
                for (K key : keySet) {
                    if (!LruInMemoryCacheStore.this.get(key).isPresent()) {
                        log.info("缓存[{}]已过期", key);
                    }
                }
            } finally {
                writeLock.unlock();
            }

        }
    }

    private class LruMap extends LinkedHashMap<K, CacheWrapper<V>> {

        private final int maxCapacity;

        public LruMap(int maxCapacity) {
            this.maxCapacity = maxCapacity;
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry<K, CacheWrapper<V>> eldest) {
            log.info("队列中最不常用的数据key {}", eldest.getKey());
            return this.size() > maxCapacity;
        }
    }
}

二、致谢

我的源码meethigher/cache-store: java实现的轻量级缓存，支持缓存的过期失效

平时逛逛github，发现的别人的好代码，顶层接口和思想直接借用了halo，这里面好代码好多啊。

1. lishuo9527/LocalCache: JAVA LocalCache – JAVA 本地缓存工具类
2. halo-dev/halo: ✍ 一款现代化的开源博客 / CMS 系统。