开发喵星球

1、需求

ruoyi-vue前后端分离项目使用的是redis缓存，现需把redis缓存改为cache本地缓存，即内存中存储，不使用redis了。

2、解决办法

开发一个本地缓存的工具类来替代RedisCache类，然后把涉及的地方改一下即可

3、实施代码

1 去掉redis的maven依赖

注意：是去掉或者注释掉

 <!-- redis 缓存操作 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2 编写本地缓存工具类，类似于redis

位置：本地缓存类Localcache.java，放在ruoyi-common模块中

package com.ruoyi.common.core.cache;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

/**
 * 本地缓存方式
 *
 */
@SuppressWarnings(value = { "unchecked" })
@Component
public class Localcache {

    private Map<String,Object> persistentCache;

    /**
     * token认证cache - 会自动过期的map
     */
    private Cache<String, Object> tokenCache;

    /**
     * 防止重复提交
     */
    private Cache<String, Object> repeatSubmitCache;

    /**
     * 验证码服务
     */
    private Cache<String, Object> captchaCache;

    @PostConstruct
    public void init() {

        persistentCache = new ConcurrentHashMap<String, Object>(1024);

        tokenCache = Caffeine.newBuilder()
        .expireAfterWrite(30, TimeUnit.MINUTES)     //30分钟
        .initialCapacity(100)
        .maximumSize(10000)
        .build();


        repeatSubmitCache = Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.SECONDS)     //10秒
                .initialCapacity(100)
                .maximumSize(10000)
                .build();

        captchaCache = Caffeine.newBuilder()
                .expireAfterWrite(2, TimeUnit.MINUTES)      //2分钟
                .initialCapacity(100)
                .maximumSize(10000)
                .build();
    }

    /**
     * Get方法, 转换结果类型并屏蔽异常, 仅返回Null.
     */
    public <T> T get(String key) {
        try {
            Object obj = persistentCache.get(key);

            if( null == obj ) {
                obj = tokenCache.getIfPresent(key);
            }

            if( null == obj ) {
                obj = captchaCache.getIfPresent(key);
            }

            if( null == obj ) {
                obj = repeatSubmitCache.getIfPresent(key);
            }

            return (T) obj;
        } catch (RuntimeException e) {

            return (T)null;
        }
    }

    public List<String> keys(String key){
        List<String> keyList = new ArrayList<String>();
        List<String> keys = new ArrayList<String>(persistentCache.keySet());
        for(int i=0;i<keys.size();i++){
            if(keys.get(i).startsWith(key)){
                keyList.add(keys.get(i));
            }
        }
        return keyList;
    }

    /**
     * 异步Set方法, 不考虑执行结果.
     * @param key
     * @param value
     * @param expiredTime   单位：秒
     */
    public void set(String key, Object value, int expiredTime ) {
        if( 0 == expiredTime ) {
            persistentCache.put(key,value);
        }else if( expiredTime <= 60 ) {     //TTL少于1分钟
            repeatSubmitCache.put(key, value);
        }else if( expiredTime <= 300 ) {    //TTL少于5分钟
            captchaCache.put(key, value);
        }else {
            tokenCache.put(key, value);
        }
    }


    /**
     * 持久化保存
     * @param key
     * @param value
     */
    public void set(String key, Object value) {
        try {
            this.set(key, value, 0 );
        } catch (Exception e) {

        }
    }

    /**
     * 异步 Delete方法, 不考虑执行结果.
     */
    public void delete(final String key) {
        persistentCache.remove(key);
        captchaCache.invalidate(key);
        tokenCache.invalidate(key);
        //防止重复提交和token过期，不存在删除的方法
    }

    public void delete(final Collection<String> keys) {
        for( String key : keys ) {
            delete(key);
        }
    }

}

3 其他修改

把所有使用到RedisCache的地方，改成Localcache就可以了。

全部修改完成后，若依分离版的redis缓存已经成功修改为本地缓存cache。