Redis工具类

已于 2023-10-06 22:59:21 修改
阅读量171 收藏 1
点赞数
文章标签： redis 数据库 缓存
于 2023-10-06 22:51:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57466771/article/details/133623752
版权

    这是一个用于封装与Redis缓存交互的工具类 RedisCache，该类提供了各种方法来处理不同类型的数据存储和检索。

package cn.zjy.travel.redis.utils;


import cn.zjy.travel.redis.key.KeyPrefix;
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 java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * spring redis 工具类
 *
 * @author ruoyi
 **/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache {
    public final RedisTemplate redisTemplate;

    public RedisCache(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public Long increment(String key, int incr) {
        return redisTemplate.opsForValue().increment(key, incr);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public <T> void setCacheObject(final KeyPrefix prefix, final T value, String... suffix) {
        if (prefix.getTimeout() > 0) {
            this.setCacheObject(prefix.fullKey(suffix), value, prefix.getTimeout(), prefix.getUnit());
        } else {
            this.setCacheObject(prefix.fullKey(suffix), 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);
    }

    /**
     * 针对 hash key 进行 increment
     *
     * @param prefix    前缀
     * @param hashKey   hash key
     * @param increment 自增值
     * @param suffix    后缀
     */
    public Long hashIncrement(KeyPrefix prefix, String hashKey, int increment, String... suffix) {
        Long ret = redisTemplate.opsForHash().increment(prefix.fullKey(suffix), hashKey, increment);
        if (prefix.getTimeout() != null && prefix.getTimeout() > 0 && ret == 1) {
            // 只有有设置过期时间 && 每一个用户第一次访问页面时才会+1
            expire(prefix.fullKey(suffix), prefix.getTimeout(), prefix.getUnit());
        }

        return ret;
    }

    /**
     * 针对 zset 成员进行增加分数
     *
     * @param keyPrefix 前缀
     * @param increment 增加的值
     * @param member    成员
     * @param suffix    后缀
     */
    public void zsetIncrement(KeyPrefix keyPrefix, double increment, Object member, String... suffix) {
        redisTemplate.opsForZSet().incrementScore(keyPrefix.fullKey(suffix), member, increment);
    }

    /**
     * 按照指定分数范围获取 zset 集合中的元素
     *
     * @param keyPrefix 前缀
     * @param start     开始分数
     * @param end       结束分数
     * @return 分数范围内的 member 集合
     */
    public <T> Set<T> zsetRevrange(KeyPrefix keyPrefix, int start, int end, String... suffix) {
        return redisTemplate.opsForZSet().reverseRange(keyPrefix.fullKey(suffix), start, end);
    }

    /**
     * 按照分数范围删除范围内的所有元素
     *
     * @param keyPrefix 前缀
     * @param min       最小分数
     * @param max       最大分数
     * @param suffix    后缀
     */
    public void zsetRemoveRange(KeyPrefix keyPrefix, int min, int max, String... suffix) {
        redisTemplate.opsForZSet().removeRange(keyPrefix.fullKey(suffix), min, max);
    }

    public Boolean setnx(String key, String value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }
}

下面是对这个类的主要方法的解释：

  1. public RedisCache(RedisTemplate redisTemplate)：构造函数，接受一个 RedisTemplate 对象，用于与Redis进行交互。

  2. public Long increment(String key, int incr)：增加指定键的值。适用于整数数据。

  3. public <T> void setCacheObject(final String key, final T value)：缓存一个基本对象，例如整数、字符串或实体类。

  4. public <T> void setCacheObject(final KeyPrefix prefix, final T value, String... suffix)：根据指定的 KeyPrefix 缓存对象。可以设置超时时间。

  5. public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)：缓存对象并设置自定义的超时时间。

  6. public boolean expire(final String key, final long timeout)：设置指定键的超时时间（秒）。

  7. public boolean expire(final String key, final long timeout, final TimeUnit unit)：设置指定键的超时时间，可以指定时间单位。

  8. public long getExpire(final String key)：获取指定键的剩余超时时间（秒）。

  9. public Boolean hasKey(String key)：检查指定键是否存在于Redis中。

  10. public <T> T getCacheObject(final String key)：获取缓存中的基本对象。

  11. public boolean deleteObject(final String key)：删除指定键的对象。

  12. public boolean deleteObject(final Collection collection)：删除一组对象。

  13. public <T> long setCacheList(final String key, final List<T> dataList)：缓存一个列表数据。

  14. public <T> List<T> getCacheList(final String key)：获取缓存中的列表数据。

  15. public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)：缓存一个集合。

  16. public <T> Set<T> getCacheSet(final String key)：获取缓存中的集合数据。

  17. public <T> void setCacheMap(final String key, final Map<String, T> dataMap)：缓存一个Map数据。

  18. public <T> Map<String, T> getCacheMap(final String key)：获取缓存中的Map数据。

  19. public <T> void setCacheMapValue(final String key, final String hKey, final T value)：往一个Hash中存入数据。

  20. public <T> T getCacheMapValue(final String key, final String hKey)：获取Hash中的数据。

  21. public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)：获取多个Hash中的数据。

  22. public boolean deleteCacheMapValue(final String key, final String hKey)：删除Hash中的某条数据。

  23. public Collection<String> keys(final String pattern)：根据键的前缀模式获取Redis中的键。

  24. public Long hashIncrement(KeyPrefix prefix, String hashKey, int increment, String... suffix)：根据指定的 KeyPrefix 对应的前缀，对Hash中的键进行增量操作。

  25. public void zsetIncrement(KeyPrefix keyPrefix, double increment, Object member, String... suffix)：对ZSet中的成员进行分数增量操作。

  26. public <T> Set<T> zsetRevrange(KeyPrefix keyPrefix, int start, int end, String... suffix)：按分数范围获取ZSet中的元素。

  27. public void zsetRemoveRange(KeyPrefix keyPrefix, int min, int max, String... suffix)：按分数范围删除ZSet中的元素。

  28. public Boolean setnx(String key, String value)：将键值设置到缓存中，仅在键不存在时设置成功。

    这个类为你提供了方便的方法，用于在应用程序中与Redis进行交互，包括缓存数据、设置超时、检索数据等。这对于实现缓存和数据存储功能非常有用，可以提高应用程序的性能和效率。

Joker_zjy
关注
封装的redisCache工具类
lzt099的博客
08-05 5674
@Service("redisCacheUtil") public class RedisCacheUtil { private static Logger logger = LoggerFactory.getLogger(RedisCacheUtil.class); @Autowired private RedisTemplateString, Object> red
Redis操作工具类（RedisCache）
qq_35097597的博客
11-02 400
【代码】Redis操作工具类（RedisCache）
06.`spring boot`集成`redis`
rmy_20的博客
09-05 364
SpringBoot集成redis
RedisCache 工具类 封装 RedisTemplate
北省的博客
03-14 362
spring redis 工具类
RedisCache——redis缓存工具类
最新发布
m0_61943950的博客
12-26 1068
【代码】RedisCache——redis缓存工具类。
Redis缓存工具类
JB091的博客
12-13 545
Component@Autowired0L : count;0L : count;0L : count;0L : count;0L : count;0L : count;} else {= null;0L : count;0L : count;
Redis In Action —— Redis Cache Client 工具类封装 —— 封装了针对于缓存穿透、缓存击穿等问题的优化 —— 缓存空值数据|缓存击穿互斥锁优化|缓存击穿逻辑过期优化
Alascanfu的博客
08-04 632
添加数据时，如果redis判断该操作会导致占用内存大小超过内存限制，就会扫描所有的key，淘汰一些。:添加数据时，如果redis判断该操作会导致占用内存大小超过内存限制，扫描那些。:添加数据时，如果redis判断该操作会导致占用内存大小超过内存限制，扫描那些。:添加数据时，如果redis判断该操作会导致占用内存大小超过内存限制，就会。:添加数据时，如果redis判断该操作会导致占用内存大小超过内存限制，就会。:添加数据时，如果redis判断该操作会导致占用内存大小超过内存限制，就会。...
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
redis工具类
02-13
基于spring和redis的redisTemplate工具类,包含hash,set,list三种集合的操作
Redis 缓存工具类
01-06
Redis 工具类，包括缓存的添加、获取、删除等等方法。
Redis工具类，方便缓存读写
02-22
redis工具整合java版代码。
java redis缓存工具类_redis工具类-JedisUtil
weixin_33737110的博客
02-24 713
redis连接的工具类1.java中的redisjava中，使用redis不会将其当作数据库来使用，更多的是作为缓存或者是消息中间件来使用。在用作缓存时，我们需要使用第三方提供的jar包来进行开发，将从数据库读取的数据放到redis中缓存起来，当使用时就直接从redis中获取不用再去查询数据库，效率将大大提高。2.redis工具类由于使用第三方开发包，考虑到性能问题，我们一般会考虑池思想来获取re...
编写Redis缓存操作工具类
qq_45813393的博客
11-01 451
编写Redis缓存操作工具类
【Redis】封装缓存工具类
liuwanqing233333的博客
12-02 499
Redis封装缓存工具类
redis操作工具类
.
01-11 1979
redis操作工具类
自定义redis缓存工具类
weixin_48909429的博客
08-18 114
【代码】自定义redis缓存工具类。
Redis注解缓存的工具类
xinlus的博客
08-24 342
工具类的出处 项目中我们使用Redis会缓存一些经常查询的数据，可能我们会直接在业务层进行缓存，可能我们也会使用拦截器缓存，也可能使用AOP,但是这样可能用起来比较麻烦，或者不同的场景都得去做大量的修改，我于是就做了一个利用注解的方式去缓存我们经常访问的数据 添加缓存注解 import com.xinlus.resp.Result; import java.lang.annotation.*; /** * @Author xinlus@126.com * @...
redis缓存工具封装类
bubbleJessica的博客
02-17 255
redis封装工具类
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值