RedisTemplate实现常用数据的缓存存储操作

于 2024-05-20 18:06:05 发布
阅读量304 收藏
点赞数 2
分类专栏： redis 文章标签： 缓存 redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42390993/article/details/138970088
版权

RedisTemplate实现常用数据的缓存存储操作：

极高的性能：由于数据存储在内存中，读写速度非常快，适用于高并发和低延迟的场景。
丰富的数据结构：支持多种复杂的数据结构和操作，适用于各种应用场景。
灵活的持久化：提供多种持久化选项，确保数据的持久性和可靠性。

由于其高速访问特性，RedisTemplate来缓存高并发的数据

工具类

package com.study.redis.service;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
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 工具类
 **/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
@Slf4j
public class RedisService
{

    @Autowired
    public RedisTemplate redisTemplate;


    public Object get(String key) {
        return key == null ? null : this.redisTemplate.opsForValue().get(key);
    }

    public Set<String> getVague(String key) {
        return key == null ? null : this.redisTemplate.keys(key);
    }

    public boolean set(String key, Object value) {
        try {
            this.redisTemplate.opsForValue().set(key, value.toString());
            return true;
        } catch (Exception var4) {
            var4.printStackTrace();
            return false;
        }
    }

    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0L) {
                this.redisTemplate.opsForValue().set(key, value.toString(), time, TimeUnit.SECONDS);
            } else {
                this.set(key, value);
            }

            return true;
        } catch (Exception var6) {
            var6.printStackTrace();
            return false;
        }
    }

    public void putHash(String key, String hashKey, String value) {
        try {
            HashOperations<String, String, String> hashOps = this.redisTemplate.opsForHash();
            hashOps.put(key, hashKey, value);
        } catch (Exception var5) {
            log.error("[REDIS] Put hash key=" + key + ", hashKey=" + hashKey + ", value=" + value);
        }

    }

    public void putHash(String key, Map<String, String> hashProperties) {
        try {
            HashOperations<String, String, String> hashOps = this.redisTemplate.opsForHash();
            hashOps.putAll(key, hashProperties);
        } catch (Exception var4) {
            log.error("[REDIS] Put hash key=" + key + ", hashKey-value=" + hashProperties);
        }

    }

    public String getHash(String key, String hashKey) {
        String result = null;

        try {
            HashOperations<String, String, String> hashOps = this.redisTemplate.opsForHash();
            result = (String)hashOps.get(key, hashKey);
            return StringUtils.isBlank(result) ? null : result;
        } catch (Exception var5) {
            log.error("[REDIS] Get hash key=" + key + ", hashKey=" + hashKey + ", value=" + result);
            return result;
        }
    }


    public void putValue(String key, String value) {
        try {
            ValueOperations<String, String> valueOps = this.redisTemplate.opsForValue();
            valueOps.set(key, value);
        } catch (Exception var4) {
            log.error("[REDIS-ERROR] put k-v key=" + key + ", value=" + value);
        }

    }

    public void putValue(String key, String value, long timeout) {
        try {
            ValueOperations<String, String> valueOps = this.redisTemplate.opsForValue();
            valueOps.set(key, value, timeout, TimeUnit.SECONDS);
        } catch (Exception var6) {
            log.info("[REDIS--ERROR] put k-v  key=" + key + ", value=" + value + ", timeout=" + timeout);
        }

    }

    public String getValue(String key) {
        String result = null;

        try {
            ValueOperations<String, String> valueOps = this.redisTemplate.opsForValue();
            result = (String)valueOps.get(key);
        } catch (Exception var4) {
            log.error("[REDIS--ERROR]-->getValue(String key)错误:" + var4);
        }

        return result;
    }

    /**
     * 缓存基本的对象，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 Long 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);
    }
}
@蓝眼睛
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
如何使用RedisTemplate缓存List的一系列操作示例
weixin_42575720的博客
06-06 5059
redisTemplate是Spring封装的一个比较强大的模板，方便在开发的时候操作redis缓存。 Redis缓存一般能存的类型有String、List、Set、Hash、Zset。 本篇主要介绍存List类型的相关操作
关于使用RedisTemplate缓存hashMap的使用小结
忆浅曦
06-10 9290
在实际项目中我们经常需要使用到Redis缓存来持久化一些我们需要的数据。很多时候这些数据是使用HashMap存储的一些对象集合，这样形式的数据我们如何正确从Redis中存取呢？ 在我实际使用的过程中使用了一个形式是Map<String, JobProperty> 的HashMap。而JobProperty是一个内部类，这个内部类的结构如下： static class JobProper...
使用(Redis)StringRedisTemplate进行缓存
weixin_51335774的博客
03-30 1092
在使用Redis进行缓存时，选择合适Redis模板，推荐使用StringRedisTemplate。
spring + RedisTemplate使用缓存
alwaysBrother的博客
05-20 1652
spring + RedisTemplate使用缓存使用步骤配置文件, 只需要配置了 redisTemplate 就可以 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3....
缓存篇-RedisTemplate常用方法
qq_41807885的博客
11-14 643
记录使用RedisTemplate操作String，List，Hash，Set，ZSet的方法
RedisTemplate存数据 序列化的两种方式
m0_55856655的博客
09-22 192
redis数据库是二进制存储数据的spring默认使用jdk序列化将数据存进redis，通用性比较好，但不存在可读性。
Redis实现缓存功能总结.docx
07-09
接下来就要在操作业务上通过增加注解来实现缓存了，注解常用的有三种：@Cacheable、@CachePut、@CacheEvict。@Cacheable 用于查询和新增可选属 性，cacheNames/value：指定缓存组件的名字；key：缓存数据使用的 key...
spring整合redis以及使用RedisTemplate的方法
08-30
在Spring框架中整合Redis是为了利用Redis的高性能特性作为缓存或者数据存储系统。Spring提供了`RedisTemplate`，一个模板类，使得操作Redis变得更加方便。本文将详细介绍如何进行Spring与Redis的整合，以及如何使用`...
Springboot加Redis缓存实现
07-05
在业务代码中，我们可以通过注入RedisTemplate或StringRedisTemplate来调用其提供的方法，实现数据的缓存操作。比如，我们可以使用`opsForValue().set()`来设置键值对，`opsForValue().get()`来获取缓存的数据。 ...
redis缓存实例
04-13
- **创建**: 为了简化代码，通常我们会创建一个`jedisUtils`工具类，封装常用的Redis操作。这个工具类通常包含初始化Jedis实例、执行命令、释放资源等方法。 - **示例**: ```java public class JedisUtils { ...
详解redis与spring的整合（使用缓存）
08-31
通过在内存中存储常用数据，Redis 能够快速响应读取请求，降低数据库负载。 在整合之前，我们需要确保引入了正确的依赖库。这里提到了两个关键的 JAR 包：jedis 和 commons-pool。这两个库之间的版本必须匹配，因为...
Redis和Spring的整合
weixin_34184561的博客
12-11 123
因为经常用到几个工具类，因此备份一下，后续可以直接copy过去 spring配置 <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> <property name="maxIdle" value="${redis.pool.maxI...
手写mybatis框架-增加缓存&事务功能
weixin_45032957的博客
09-15 141
缓存 com.simple.ibatis.cache 缓存接口-Cache 复制代码 public interface Cache { /**放入缓存*/ void putCache(String key,Object val); /**获取缓存*/ Object getCache(String key); /**清空缓存*/ void cleanCache(); /**获取缓存健数量*/ int getSize(); /**移除key的缓存*/ void removeCache(String ke
RedisTemplate 关于Map的操作实战
zgx20130619的博客
11-23 6357
RedisTemplate 关于Map的操作实战 一、模板操作的工具类 @Slf4j @Component public class RedisTools { @Autowired RedisTemplate redisTemplate; /** * 删除key * @param key */ public void delete(String key) { redisTemplate.delete(key); }
RedisTemplate存取数据
最新发布
qq_46940224的博客
12-19 1486
RedisTemplate存取数据
springboot中如何使用RedisTemplate存储实体对象
热门推荐
z1094219402的专栏
08-02 1万+
RedisTemplate是spring封装的操作redis的接口，使用起来很方便，但也有很多坑，比如存储javabean类。 网上找了很多资料，很多都语焉不详，几乎毫无作用。 redis存储对象需要对实体类进行序列化，也就是写成javabean，而不是pojo类。 其次，在存储对象的操作中，需要对实体类进行流化读写操作，就像文件的字节流的序列化操作一样，因为序列化本身就是流的转化的过程。而...
Redis( stringRedisTemplate)添加缓存数据
weixin_45934981的博客
09-06 3410
Redis( stringRedisTemplate)添加缓存数据
RedisTemplate操作Redis，这一篇文章就够了（一）
AlbenXie的博客
11-01 2887
一、SpringDataRedis简介 1、Redis redis是一款开源的Key-Value数据库，运行在内存中，由C语言编写。企业开发通常采用Redis来实现缓存。同类的产品还有memcache 、memcached 等。 2、Jedis Jedis是Redis官方推出的一款面向Java的客户端，提供了很多接口供Java语言调用。可以在Redis官网下载，当然还有一些开源爱好者提供的客户端，如Jredis、SRP等等，推荐使用Jedis。 3、Spring Data Redis Sprin
RedisTemplate redis缓存的基本使用
08-24
RedisTemplate 是 Spring Data Redis 提供的一个操作 Redis 的工具类，它封装了 Redis 的常用操作方法，可以方便地进行 Redis 缓存的基本使用。 下面是 RedisTemplate 的基本使用步骤： 1. 添加 Redis 依赖：在项目的 pom.xml 文件中添加以下依赖项： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 2. 配置 Redis 连接信息：在项目的配置文件中添加 Redis 的连接信息，例如 application.properties 文件： ``` spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password= ``` 3. 创建 RedisTemplate 对象：在需要使用 Redis 缓存的类中，注入 RedisTemplate 对象，例如通过添加 @Autowired 注解来进行自动注入。 4. 使用 RedisTemplate 进行缓存操作：通过 RedisTemplate 的方法来进行缓存操作，常见的操作包括存储数据、获取数据和删除数据。 下面是一些常见的 RedisTemplate 使用示例： - 存储数据： ```java redisTemplate.opsForValue().set("key", "value"); ``` 这个示例将键值对 "key"-"value" 存储到 Redis 中。 - 获取数据： ```java String value = redisTemplate.opsForValue().get("key"); ``` 这个示例从 Redis 中根据键 "key" 获取对应的值。 - 删除数据： ```java redisTemplate.delete("key"); ``` 这个示例从 Redis 中根据键 "key" 删除对应的数据。 除了上述示例，RedisTemplate 还提供了其他操作方法，如哈希操作、列表操作、集合操作、有序集合操作等。 这是 RedisTemplate 的基本使用方法，可以根据具体的需求进行相应的缓存操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@蓝眼睛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值