AI 助理
备案控制台
开发者社区 数据库 文章 正文

若依管理系统去掉Redis相关配置

2024-02-29 133
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： 若依管理系统去掉Redis相关配置

  1. 注释掉RedisConfig.java里的注解
    image.png

  2. 在RedisCache同级目录新建MyCache.java，内容如下

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;

/**
 * @Author:sgw
 * @Date:2024/1/9
 * @Description: 为了去掉redis校验，临时加的类
 */
@Component
public class MyCache implements Cache{
   
   
    // 使用ConcurrentHashMap作为数据的存储
    private Map<String, Object> storage = new ConcurrentHashMap<>();

    // getName获取cache的名称，存取数据的时候用来区分是针对哪个cache操作
    @Override
    public String getName() {
   
   
        return null;
    }

    @Override
    public Object getNativeCache() {
   
   
        return null;
    }

    public boolean hasKey(String key){
   
   
        return storage.containsKey(key);
    }

    @Override
    public ValueWrapper get(Object key) {
   
   
        String k = key.toString();
        Object value = storage.get(k);

        // 注意返回的数据，要和存放时接收到数据保持一致，要将数据反序列化回来。
        return Objects.isNull(value) ? null : new SimpleValueWrapper(value);
    }

    @Override
    public <T> T get(Object key, Class<T> type) {
   
   
        return null;
    }

    @Override
    public <T> T get(Object key, Callable<T> valueLoader) {
   
   
        return null;
    }

    // put方法，就是执行将数据进行缓存
    @Override
    public void put(Object key, Object value) {
   
   
        if (Objects.isNull(value)) {
   
   
            return;
        }
        //存值
        storage.put(key.toString(), value);
    }

    @Override
    public ValueWrapper putIfAbsent(Object key, Object value) {
   
   
        return null;
    }

    // evict方法，是用来清除某个缓存项
    @Override
    public void evict(Object key) {
   
   
        storage.remove(key.toString());
    }

    // 删除集合
    public boolean deleteObject(final Collection collection){
   
   
        collection.forEach(o -> {
   
   
            storage.remove(o.toString());
        } );
        return true;
    }

    // 获取所有的keys
    public Collection<String> keys(final String pattern){
   
   
        return storage.keySet();
    }

    @Override
    public void clear() {
   
   

    }
}

image.png

  1. RedisCache.java为以下内容

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;

import javax.annotation.Resource;

/**
 * spring redis 工具类
 *
 * @author myt
 **/
@SuppressWarnings(value = {
   
    "unchecked", "rawtypes" })
@Component
public class RedisCache
{
   
   
    /*@Autowired
    public RedisTemplate redisTemplate;*/
    @Resource
    public MyCache myCache;
    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
   /* public <T> void setCacheObject(final String key, final T 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)
    {
        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 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 redisTemplate.hasKey(key);
    }

    *//**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     *//*
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    *//**
     * 删除单个对象
     *
     * @param key
     *//*
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }

    *//**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     *//*
    public boolean deleteObject(final Collection 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 redisTemplate.keys(pattern);
    }*/
    /**
     * 缓存基本的对象，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);
    }
}
  1. 去除redis配置文件内容

image.png

  1. 修改DictUtils类里的getDictCache方法如下
/**
     * 获取字典缓存
     *
     * @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;
    }
  1. RateLimiterAspect.java类全部注释掉

最后重启即可

文章标签：
云数据库 Tair（兼容 Redis）
NoSQL
Redis
关键词：
云数据库 Tair（兼容 Redis）配置
系统云数据库 Tair（兼容 Redis）
云数据库 Tair（兼容 Redis）若依
系统云数据库 Tair（兼容 Redis）配置
云数据库 Tair（兼容 Redis）管理系统
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
1932836719192345
目录
相关文章
东方睿赢
|
26天前
|
消息中间件 缓存 NoSQL
Redis 是一个高性能的键值对存储系统，常用于缓存、消息队列和会话管理等场景。
【10月更文挑战第4天】Redis 是一个高性能的键值对存储系统，常用于缓存、消息队列和会话管理等场景。随着数据增长，有时需要将 Redis 数据导出以进行分析、备份或迁移。本文详细介绍几种导出方法：1）使用 Redis 命令与重定向；2）利用 Redis 的 RDB 和 AOF 持久化功能；3）借助第三方工具如 `redis-dump`。每种方法均附有示例代码，帮助你轻松完成数据导出任务。无论数据量大小，总有一款适合你。
东方睿赢
63 6
肾透侧视攻城狮
|
5天前
|
存储 SQL 关系型数据库
2024Mysql And Redis基础与进阶操作系列（1）作者——LJS[含MySQL的下载、安装、配置详解步骤及报错对应解决方法]
Mysql And Redis基础与进阶操作系列（1）之[MySQL的下载、安装、配置详解步骤及报错对应解决方法]
肾透侧视攻城狮
15 3
听白
|
16天前
|
存储 NoSQL Redis
Redis 配置
10月更文挑战第14天
听白
20 1
刘大猫.
|
2天前
|
JavaScript NoSQL Java
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
刘大猫.
18 0
武子康
|
26天前
|
消息中间件 NoSQL Kafka
大数据-116 - Flink DataStream Sink 原理、概念、常见Sink类型 配置与使用 附带案例1：消费Kafka写到Redis
大数据-116 - Flink DataStream Sink 原理、概念、常见Sink类型 配置与使用 附带案例1：消费Kafka写到Redis
武子康
97 0
廖文
|
30天前
|
NoSQL Ubuntu Linux
redis的基本安装配置启动使用
redis的基本安装配置启动使用
廖文
30 0
蓝易云
|
1月前
|
缓存 NoSQL 数据处理
原生php实现redis缓存配置和使用方法
通过上述步骤，你可以在PHP项目中配置并使用Redis作为高性能的缓存解决方案。合理利用Redis的各种数据结构和特性，可以有效提升应用的响应速度和数据处理效率。记得在实际应用中根据具体需求选择合适的缓存策略，如设置合理的过期时间，以避免内存过度消耗。
蓝易云
42 0
路边两盏灯
|
3月前
|
NoSQL Redis 容器
【Azure Cache for Redis】Redis的导出页面无法配置Storage SAS时通过az cli来完成
【Azure Cache for Redis】Redis的导出页面无法配置Storage SAS时通过az cli来完成
路边两盏灯
43 3
路边两盏灯
|
3月前
|
缓存 NoSQL 测试技术
【Azure Redis 缓存】Azure Redis 功能性讨论三： 调优参数配置
【Azure Redis 缓存】Azure Redis 功能性讨论三： 调优参数配置
路边两盏灯
45 1
路边两盏灯
|
3月前
|
存储 缓存 NoSQL
【Azure Redis 缓存】由Azure Redis是否可以自定义密码而引申出Azure PaaS的Redis服务是否可以和自建的Redis进行主从配置呢？
【Azure Redis 缓存】由Azure Redis是否可以自定义密码而引申出Azure PaaS的Redis服务是否可以和自建的Redis进行主从配置呢？
路边两盏灯
31 0

热门文章

最新文章

  • 1
    Windows 下安装和配置 Redis (图文教程)
  • 2
    基于Linux环境安装Redis 6.2.7（超详细）
  • 3
    tomcat session 共享 redis
  • 4
    [Redis]Redis安装与启动(Linux CentOS)
  • 5
    Spring Boot实战解决高并发数据入库: Redis 缓存+MySQL 批量入库
  • 6
    用 Redis 实现延迟队列，我研究了两种方案，发现并不简单 下
  • 7
    为什么redis是单线程的以及为什么这么快？
  • 8
    java Redis工具类
  • 9
    fpm 打包redis3.0.7
  • 10
    php-redis扩展模块安装记录
  • 1
    保护Redis：建立铁壁般的安全防线，守护你的数据财富
    100
  • 2
    Redis 服务器指南：高性能内存数据库的完整使用指南
    169
  • 3
    Redis连接：加速数据访问与保障安全传输的关键
    67
  • 4
    Redis Lua脚本：赋予Redis更强大的逻辑与功能
    139
  • 5
    Redis事务：保证数据操作的一致性和可靠性
    114
  • 6
    Redis HyperLogLog: 高效统计大数据集的神秘利器
    119
  • 7
    Redis数据类型详解：选择合适的数据结构优化你的应用
    139
  • 8
    什么是Redis的事务？
    50
  • 9
    面试官：如何搭建Redis集群？
    63
  • 10
    SpringBoot集成Redis解决表单重复提交接口幂等（亲测可用）
    482

    • 相关课程

    更多
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第三阶段
  • 大数据实战项目 - 反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第六阶段
  • 大数据实战项目 - 反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第七阶段
  • Redis入门实战演练
  • 云数据库 Redis 版使用教程
  • Redis数据库入门

    • 相关电子书

    更多
  • ApsaraDB for Redis——与创客同行
  • 微博的Redis定制之路
  • 云数据库Redis版的开源之路

    • 相关实验场景

    更多
  • 如何通过数据库Redis内网访问
  • Tair for Redis数据闪回：任意时间点数据恢复
  • 如何开通Redis的专属集群
  • 基于Redis实现在线游戏积分排行榜
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月