把ruoyi-vue前后端分离项目的redis缓存改为本地缓存cache

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

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);
    }
  }
}