若依框架去掉Redis

这篇文章全是按照我的实战操作来的，本文一是记录一下这个过程，二是帮助更多的人少走弯路。
接下来我们看实战：

第一步毋庸置疑，就是找到配置文件application.yml里面大redis配置部分，直接注释掉
注意这里的data:这是否注释无伤大雅

第二步找到framework下RedisConfig的配置，

全部注释掉，如图，代码如下：

package com.ruoyi.framework.config;import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.StringRedisSerializer;/*** redis配置* * @author ruoyi*/
@SuppressWarnings("deprecation")
//@Configuration
//@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{
//    @Bean
//    @SuppressWarnings(value = { "unchecked", "rawtypes" })
//    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
//    {
//        RedisTemplate<Object, Object> template = new RedisTemplate<>();
//        template.setConnectionFactory(connectionFactory);
//
//        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
//
//        // 使用StringRedisSerializer来序列化和反序列化redis的key值
//        template.setKeySerializer(new StringRedisSerializer());
//        template.setValueSerializer(serializer);
//
//        // Hash的key也采用StringRedisSerializer的序列化方式
//        template.setHashKeySerializer(new StringRedisSerializer());
//        template.setHashValueSerializer(serializer);
//
//        template.afterPropertiesSet();
//        return template;
//    }
//
//    @Bean
//    public DefaultRedisScript<Long> limitScript()
//    {
//        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
//        redisScript.setScriptText(limitScriptText());
//        redisScript.setResultType(Long.class);
//        return redisScript;
//    }
//
//    /**
//     * 限流脚本
//     */
//    private String limitScriptText()
//    {
//        return "local key = KEYS[1]\n" +
//                "local count = tonumber(ARGV[1])\n" +
//                "local time = tonumber(ARGV[2])\n" +
//                "local current = redis.call('get', key);\n" +
//                "if current and tonumber(current) > count then\n" +
//                "    return tonumber(current);\n" +
//                "end\n" +
//                "current = redis.call('incr', key)\n" +
//                "if tonumber(current) == 1 then\n" +
//                "    redis.call('expire', key, time)\n" +
//                "end\n" +
//                "return tonumber(current);";
//    }
}

第三步写一个自己的类MyCache,放在

跟RedisCache同目录

代码如下：

package com.ruoyi.common.core.redis;import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;
import org.springframework.stereotype.Component;import java.util.Collection;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;@Component
public class MyCache implements Cache {// 使用ConcurrentHashMap作为数据的存储private Map<String, Object> storage = new ConcurrentHashMap<>();// getName获取cache的名称，存取数据的时候用来区分是针对哪个cache操作@Overridepublic String getName() {return null;}@Overridepublic Object getNativeCache() {return null;}public boolean hasKey(String key){return storage.containsKey(key);}@Overridepublic ValueWrapper get(Object key) {String k = key.toString();Object value = storage.get(k);// 注意返回的数据，要和存放时接收到数据保持一致，要将数据反序列化回来。return Objects.isNull(value) ? null : new SimpleValueWrapper(value);}@Overridepublic <T> T get(Object key, Class<T> type) {return null;}@Overridepublic <T> T get(Object key, Callable<T> valueLoader) {return null;}// put方法，就是执行将数据进行缓存@Overridepublic void put(Object key, Object value) {if (Objects.isNull(value)) {return;}//存值storage.put(key.toString(), value);}// evict方法，是用来清除某个缓存项@Overridepublic void evict(Object key) {storage.remove(key.toString());}// 删除集合public boolean deleteObject(final Collection collection){collection.forEach(o -> {storage.remove(o.toString());} );return true;}// 获取所有的keyspublic Collection<String> keys(final String pattern){return storage.keySet();}@Overridepublic void clear() {}
}

第四步修改原来的RedisCache，代码如下：

package com.ruoyi.common.core.redis;import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;/*** spring redis 工具类** @author ruoyi**/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
//    @Autowired
//    public RedisTemplate redisTemplate;@Autowiredpublic MyCache myCache;/*** 缓存基本的对象，Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值*/public <T> void setCacheObject(final String key, final T value){myCache.put(key,value);
//        redisTemplate.opsForValue().set(key, value);}/*** 缓存基本的对象，Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值* @param timeout 时间* @param timeUnit 时间颗粒度*/public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit){myCache.put(key,value);
//        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @return true=设置成功；false=设置失败*/public boolean expire(final String key, final long timeout){return expire(key, timeout, TimeUnit.SECONDS);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @param unit 时间单位* @return true=设置成功；false=设置失败*/public boolean expire(final String key, final long timeout, final TimeUnit unit){return true;
//        return redisTemplate.expire(key, timeout, unit);}/*** 获取有效时间** @param key Redis键* @return 有效时间*/
//    public long getExpire(final String key)
//    {
//        return redisTemplate.getExpire(key);
//    }/*** 判断 key是否存在** @param key 键* @return true 存在 false不存在*/public Boolean hasKey(String key){return myCache.hasKey(key);
//        return redisTemplate.hasKey(key);}/*** 获得缓存的基本对象。** @param key 缓存键值* @return 缓存键值对应的数据*/public <T> T getCacheObject(final String key){Cache.ValueWrapper valueWrapper = myCache.get(key);if (valueWrapper == null){return null;}else {return (T) valueWrapper.get();}
//        ValueOperations<String, T> operation = redisTemplate.opsForValue();
//        return operation.get(key);}/*** 删除单个对象** @param key*/public boolean deleteObject(final String key){myCache.evict(key);return true;
//        return redisTemplate.delete(key);}/*** 删除集合对象** @param collection 多个对象* @return*/public boolean deleteObject(final Collection collection){return myCache.deleteObject(collection);
//        return redisTemplate.delete(collection) > 0;}/*** 缓存List数据** @param key 缓存的键值* @param dataList 待缓存的List数据* @return 缓存的对象*/
//    public <T> long setCacheList(final String key, final List<T> dataList)
//    {
//        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
//        return count == null ? 0 : count;
//    }/*** 获得缓存的list对象** @param key 缓存的键值* @return 缓存键值对应的数据*/
//    public <T> List<T> getCacheList(final String key)
//    {
//        return redisTemplate.opsForList().range(key, 0, -1);
//    }/*** 缓存Set** @param key 缓存键值* @param dataSet 缓存的数据* @return 缓存数据的对象*/
//    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
//    {
//        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
//        Iterator<T> it = dataSet.iterator();
//        while (it.hasNext())
//        {
//            setOperation.add(it.next());
//        }
//        return setOperation;
//    }/*** 获得缓存的set** @param key* @return*/
//    public <T> Set<T> getCacheSet(final String key)
//    {
//        return redisTemplate.opsForSet().members(key);
//    }/*** 缓存Map** @param key* @param dataMap*/
//    public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
//    {
//        if (dataMap != null) {
//            redisTemplate.opsForHash().putAll(key, dataMap);
//        }
//    }//    /**
//     * 获得缓存的Map
//     *
//     * @param key
//     * @return
//     */
//    public <T> Map<String, T> getCacheMap(final String key)
//    {
//        return redisTemplate.opsForHash().entries(key);
//    }
//
//    /**
//     * 往Hash中存入数据
//     *
//     * @param key Redis键
//     * @param hKey Hash键
//     * @param value 值
//     */
//    public <T> void setCacheMapValue(final String key, final String hKey, final T value)
//    {
//        redisTemplate.opsForHash().put(key, hKey, value);
//    }
//
//    /**
//     * 获取Hash中的数据
//     *
//     * @param key Redis键
//     * @param hKey Hash键
//     * @return Hash中的对象
//     */
//    public <T> T getCacheMapValue(final String key, final String hKey)
//    {
//        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
//        return opsForHash.get(key, hKey);
//    }
//
//    /**
//     * 获取多个Hash中的数据
//     *
//     * @param key Redis键
//     * @param hKeys Hash键集合
//     * @return Hash对象集合
//     */
//    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
//    {
//        return redisTemplate.opsForHash().multiGet(key, hKeys);
//    }
//
//    /**
//     * 删除Hash中的某条数据
//     *
//     * @param key Redis键
//     * @param hKey Hash键
//     * @return 是否成功
//     */
//    public boolean deleteCacheMapValue(final String key, final String hKey)
//    {
//        return redisTemplate.opsForHash().delete(key, hKey) > 0;
//    }/*** 获得缓存的基本对象列表** @param pattern 字符串前缀* @return 对象列表*/public Collection<String> keys(final String pattern){return myCache.keys(pattern);
//        return redisTemplate.keys(pattern);}
}

第五步修改ruoyi-common下utils/DictUtils

主要修改的位置：

代码如下：

package com.it.common.utils;import java.util.Collection;
import java.util.List;import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.it.common.constant.CacheConstants;
import com.it.common.core.domain.entity.SysDictData;
import com.it.common.core.redis.RedisCache;
import com.it.common.utils.spring.SpringUtils;/*** 字典工具类* * @author ruoyi*/
public class DictUtils
{/*** 分隔符*/public static final String SEPARATOR = ",";/*** 设置字典缓存* * @param key 参数键* @param dictDatas 字典数据列表*/public static void setDictCache(String key, List<SysDictData> dictDatas){SpringUtils.getBean(RedisCache.class).setCacheObject(getCacheKey(key), dictDatas);}/*** 获取字典缓存* * @param key 参数键* @return dictDatas 字典数据列表*/public static List<SysDictData> getDictCache(String key){JSONArray arrayCache = JSONArray.parseArray(JSON.toJSONString(SpringUtils.getBean(RedisCache.class).getCacheObject(getCacheKey(key))));
//        JSONArray arrayCache = SpringUtils.getBean(RedisCache.class).getCacheObject(getCacheKey(key));if (StringUtils.isNotNull(arrayCache)){return arrayCache.toList(SysDictData.class);}return null;}/*** 根据字典类型和字典值获取字典标签* * @param dictType 字典类型* @param dictValue 字典值* @return 字典标签*/public static String getDictLabel(String dictType, String dictValue){if (StringUtils.isEmpty(dictValue)){return StringUtils.EMPTY;}return getDictLabel(dictType, dictValue, SEPARATOR);}/*** 根据字典类型和字典标签获取字典值* * @param dictType 字典类型* @param dictLabel 字典标签* @return 字典值*/public static String getDictValue(String dictType, String dictLabel){if (StringUtils.isEmpty(dictLabel)){return StringUtils.EMPTY;}return getDictValue(dictType, dictLabel, SEPARATOR);}/*** 根据字典类型和字典值获取字典标签* * @param dictType 字典类型* @param dictValue 字典值* @param separator 分隔符* @return 字典标签*/public static String getDictLabel(String dictType, String dictValue, String separator){StringBuilder propertyString = new StringBuilder();List<SysDictData> datas = getDictCache(dictType);if (StringUtils.isNull(datas)){return StringUtils.EMPTY;}if (StringUtils.containsAny(separator, dictValue)){for (SysDictData dict : datas){for (String value : dictValue.split(separator)){if (value.equals(dict.getDictValue())){propertyString.append(dict.getDictLabel()).append(separator);break;}}}}else{for (SysDictData dict : datas){if (dictValue.equals(dict.getDictValue())){return dict.getDictLabel();}}}return StringUtils.stripEnd(propertyString.toString(), separator);}/*** 根据字典类型和字典标签获取字典值* * @param dictType 字典类型* @param dictLabel 字典标签* @param separator 分隔符* @return 字典值*/public static String getDictValue(String dictType, String dictLabel, String separator){StringBuilder propertyString = new StringBuilder();List<SysDictData> datas = getDictCache(dictType);if (StringUtils.isNull(datas)){return StringUtils.EMPTY;}if (StringUtils.containsAny(separator, dictLabel)){for (SysDictData dict : datas){for (String label : dictLabel.split(separator)){if (label.equals(dict.getDictLabel())){propertyString.append(dict.getDictValue()).append(separator);break;}}}}else{for (SysDictData dict : datas){if (dictLabel.equals(dict.getDictLabel())){return dict.getDictValue();}}}return StringUtils.stripEnd(propertyString.toString(), separator);}/*** 根据字典类型获取字典所有值** @param dictType 字典类型* @return 字典值*/public static String getDictValues(String dictType){StringBuilder propertyString = new StringBuilder();List<SysDictData> datas = getDictCache(dictType);if (StringUtils.isNull(datas)){return StringUtils.EMPTY;}for (SysDictData dict : datas){propertyString.append(dict.getDictValue()).append(SEPARATOR);}return StringUtils.stripEnd(propertyString.toString(), SEPARATOR);}/*** 根据字典类型获取字典所有标签** @param dictType 字典类型* @return 字典值*/public static String getDictLabels(String dictType){StringBuilder propertyString = new StringBuilder();List<SysDictData> datas = getDictCache(dictType);if (StringUtils.isNull(datas)){return StringUtils.EMPTY;}for (SysDictData dict : datas){propertyString.append(dict.getDictLabel()).append(SEPARATOR);}return StringUtils.stripEnd(propertyString.toString(), SEPARATOR);}/*** 删除指定字典缓存* * @param key 字典键*/public static void removeDictCache(String key){SpringUtils.getBean(RedisCache.class).deleteObject(getCacheKey(key));}/*** 清空字典缓存*/public static void clearDictCache(){Collection<String> keys = SpringUtils.getBean(RedisCache.class).keys(CacheConstants.SYS_DICT_KEY + "*");SpringUtils.getBean(RedisCache.class).deleteObject(keys);}/*** 设置cache key* * @param configKey 参数键* @return 缓存键key*/public static String getCacheKey(String configKey){return CacheConstants.SYS_DICT_KEY + configKey;}
}

第六步：

package com.it.framework.aspectj;import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;
import com.it.common.annotation.RateLimiter;
import com.it.common.enums.LimitType;
import com.it.common.exception.ServiceException;
import com.it.common.utils.StringUtils;
import com.it.common.utils.ip.IpUtils;/*** 限流处理** @author ruoyi*/
//@Aspect
//@Component
public class RateLimiterAspect
{
//    private static final Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);
//
//    private RedisTemplate<Object, Object> redisTemplate;
//
//    private RedisScript<Long> limitScript;
//
////    @Autowired
//    public void setRedisTemplate1(RedisTemplate<Object, Object> redisTemplate)
//    {
//        this.redisTemplate = redisTemplate;
//    }
//
////    @Autowired
//    public void setLimitScript(RedisScript<Long> limitScript)
//    {
//        this.limitScript = limitScript;
//    }
//
////    @Before("@annotation(rateLimiter)")
//    public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable
//    {
//        int time = rateLimiter.time();
//        int count = rateLimiter.count();
//
//        String combineKey = getCombineKey(rateLimiter, point);
//        List<Object> keys = Collections.singletonList(combineKey);
//        try
//        {
//            Long number = redisTemplate.execute(limitScript, keys, count, time);
//            if (StringUtils.isNull(number) || number.intValue() > count)
//            {
//                throw new ServiceException("访问过于频繁，请稍候再试");
//            }
//            log.info("限制请求'{}',当前请求'{}',缓存key'{}'", count, number.intValue(), combineKey);
//        }
//        catch (ServiceException e)
//        {
//            throw e;
//        }
//        catch (Exception e)
//        {
//            throw new RuntimeException("服务器限流异常，请稍候再试");
//        }
//    }
//
//    public String getCombineKey(RateLimiter rateLimiter, JoinPoint point)
//    {
//        StringBuffer stringBuffer = new StringBuffer(rateLimiter.key());
//        if (rateLimiter.limitType() == LimitType.IP)
//        {
//            stringBuffer.append(IpUtils.getIpAddr()).append("-");
//        }
//        MethodSignature signature = (MethodSignature) point.getSignature();
//        Method method = signature.getMethod();
//        Class<?> targetClass = method.getDeclaringClass();
//        stringBuffer.append(targetClass.getName()).append("-").append(method.getName());
//        return stringBuffer.toString();
//    }
}

至此，修改完成，重启项目，搞定收工！