应用程序二级缓存的原理和基本实现

笔者最近自己实现了一遍二级缓存，对其中的一些原理有了一些体悟，在这里记录一下，当然如果有错误之处，还望各位看官不吝指教

---

本片文章承接自上一篇《Redission中分布式锁的简单应用》，相关的方法并入其中即可执行

一、二级缓存的实现原理

二级缓存的原理其实就是：jvm + redis的组合。所谓的jvm就是服务器端的设置的一个Map集合，用该集合来收集热点数据存。当大量的请求发送过来的时候，先查询服务器端的这个Map集合，有的话直接返回数据，没有的话再查询redis，redis中也没有才查询数据库

二、二级缓存的简单实现

本篇中的jvm缓存主要运用了谷歌的guava插件中的Cache类，该类可以设置初始化容量大小，数据过期时间，能有效的解决一些缓存所需要而Map中没有的配置问题

1、需要依赖

<!-- 引入google开源工具用于本地缓存配置 -->
<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>30.1.1-jre</version>
</dependency>

2、简单的实现

对应的本地缓存LocalCache实体类

package com.muyichen.demo.cache;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.Cache;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;

/**
 * 本地缓存实体类
 */
@Slf4j
@Component
public class LocalCache<T> {

    private Cache<String, T> localCache = null;

    @PostConstruct
    private void init() {
        localCache = CacheBuilder.newBuilder()
                //设定本地缓存的初始容量
                .initialCapacity(10)
                //设定本地缓存的最大容量
                .maximumSize(500)
                //设定本地缓存的过期时间
                .expireAfterWrite(60, TimeUnit.SECONDS).build();
    }

    public void setLocalCache(String key, T t) {
        localCache.put(key, t);
    }

    public T getLocalCache(String key) {
        return localCache.getIfPresent(key);
    }

}

业务逻辑上的实现

@Autowired
private LocalCache<User> cache;

/**
 * 使用二级缓存
 * @param id
 * @return
 */
private User getUseSecondCache(Long id) {
    //先从本地缓存中查询数据是否存在
    User resultUser = cache.getLocalCache("User:" + id);
    if (null != resultUser) {
        return resultUser;
    }
    resultUser = redisOpsUtil.get("User:" + id, User.class);
    if (null != resultUser) {
        cache.setLocalCache("User:" + id, resultUser);
        return resultUser;
    }
    // 获取当前查询所对应的锁
    RLock lock = redissonClient.getLock("Lock:" + id);
    try {
        //判断是否能拿到锁
        if(lock.tryLock(0, 5, TimeUnit.SECONDS)) {
            //如果能拿到锁，则去数据库中查询数据
            resultUser = userMapper.selectOne(Wrappers.lambdaQuery(User.class).eq(User::getId, id).last("limit 1"));
            log.info("走数据库：{}", id);
            if (null == resultUser) {
                return null;
            }
            //并将查询出的数据放入本地缓存中
            cache.setLocalCache("User:" + id, resultUser);
            //并将查询出的数据放入二级缓存中
            redisOpsUtil.set("User:" + id, resultUser, 360L, TimeUnit.SECONDS);
        } else {
            Thread.sleep(50);
            //如果拿不到锁则回调当前方法
            getUseSecondCache(id);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if(lock.isLocked() && lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
    return resultUser;
}