springboot中redisTemplate的使用

最新推荐文章于 2024-04-22 16:41:56 发布
最新推荐文章于 2024-04-22 16:41:56 发布
阅读量3.4k 收藏 4
点赞数
分类专栏： 学习 文章标签： spring boot java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zpflwy1314/article/details/122490080
版权

springboot中整合redis

springboot中redisTemplate的使用

一：springboot中整合redis

  （1）pom.xml文件中引入依赖

<!--加入redis依赖-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

# redis配置

spring.redis.host=localhost

spring.redis.password=admin

spring.redis.port=6379

spring.redis.database=2

spring.redis.lettuce.pool.max-active=200

使用

/**

 * Redis配置类

 */

@Configuration

public class RedisConfig {

    @Bean

    @ConditionalOnMissingBean(name = "redisTemplate")

    public RedisTemplate<String, Object> redisTemplate(

            RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();

        //使用fastjson序列化

        FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer(Object.class);

        // value值的序列化采用fastJsonRedisSerializer

        template.setValueSerializer(fastJsonRedisSerializer);

        template.setHashValueSerializer(fastJsonRedisSerializer);

        // key的序列化采用StringRedisSerializer

        template.setKeySerializer(new StringRedisSerializer());

        template.setHashKeySerializer(new StringRedisSerializer());

        template.setConnectionFactory(redisConnectionFactory);

        return template;

    }

    @Bean

    @ConditionalOnMissingBean(StringRedisTemplate.class)

    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

        StringRedisTemplate template = new StringRedisTemplate();

        template.setConnectionFactory(redisConnectionFactory);

        return template;

    }

}

添加工具类：

package com.glgsoft.exchange.server.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;


import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 删除key
     * @param key
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 获取缓存
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 添加缓存
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 添加缓存并设置过期时间
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * 设置一组Map的键值对
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hGet(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmGet(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 添加一个Map类型值
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmSet(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 添加一个Map类型值
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmSetCode(String key, Map<String, Boolean> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 添加一个Map类型值并设置过期时间
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmSet(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hSet(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hSet(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hDel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hIncr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hDecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取list缓存的内容
     * @param key   键
     * @param start 开始
     * @param end   结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key   键
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<String> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

使用时直接注入redisTemplate注解

也可以使用如下：

@Bean

public <T> RedisTemplate<String, T> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

    RedisTemplate<String, T> redisTemplate = new RedisTemplate<>();

    redisTemplate.setConnectionFactory(redisConnectionFactory);

    redisTemplate.setKeySerializer(new StringRedisSerializer());

    redisTemplate.setDefaultSerializer(new GenericFastJsonRedisSerializer());

    return redisTemplate;

}

使用时使用：

@Resource
//有多个实例时使用，注意，如果存储的地方使用Autowired，获取时使用Resource就会导致有的字符存储不一致。
@Qualifier("edisTemplate")
private RedisTemplate<String, User> redisTemplate;

redisTemplate常用语法：

//从test中随机获取10个元素

redisTemplate.opsForSet().distinctRandomMembers("test", 10);

template.opsForZSet().rangeByScore("zset1",0,5)//获取score为0-5之间的值

template.opsForZSet().count("zset1",0,5)//统计score为0-5之间的总数

template.opsForZSet().size("test")//统计test的成员数,等同于zcard

template.opsForZSet().score("test","test-1")//获取指定成员test-1的score

template.opsForZSet().range("zset2",0,-1)//获取zset2的所有成员

template.opsForZSet().removeRange("zset2",1,2)//删除zset中score为1-2的成员

Cursor<ZSetOperations.TypedTuple<Object>> cursor = template.opsForZSet().scan("zzset1", ScanOptions.NONE);
    while (cursor.hasNext()){
       ZSetOperations.TypedTuple<Object> item = cursor.next();
       System.out.println(item.getValue() + ":" + item.getScore());
    }
scan遍历所有的成员

Set<ZSetOperations.TypedTuple<String>> set =redisTemplate.opsForZSet().reverseRangeByScoreWithScores("test", 0, nextScore.get(), 0, 6);//按照对应的score逆序数处0-6为止的成员,对象为TypedTuple

recommendRedisTemplate.opsForZSet().remove("test", "test1");//删除一个成员test1

redisTemplate.opsForZSet().removeRange("test", 0, 10);//删除score最小的10个

Set<ZSetOperations.TypedTuple<String>> tuples = new TreeSet<>();

tuples.add(new DefaultTypedTuple("value1", 100));

tuples.add(new DefaultTypedTuple("value2", 200));

tuples.add(new DefaultTypedTuple("value3", 300));        recommendRedisTemplate.opsForZSet().add("test", tuples);//批量按照TypedTuple增加

 tuples.clear(); //清理掉本地内存

    }

}

rangeByScore(K key, double min, double max,long offset, long count)

   根据设置的score获取区间值从给定下标和给定长度获取最终值。

rangeByScoreWithScores(K key, double min, double max, long offset, long count)

    获取RedisZSetCommands.Tuples的区间值从给定下标和给定长度获取最终值通过分值

incrementScore(K key, V value, double delta)

   修改变量中的元素的分值

reverseRangeByScore(K key, double min, double max)

   倒序排列指定分值区间元素。

reverseRangeByScore(K key, double min, double max, long offset, long count)

   倒序排列从给定下标和给定长度分值区间元素

reverseRangeByScoreWithScores(K key, double min, double max, long offset, long count)

  倒序排序获取RedisZSetCommands.Tuples的从给定下标和给定长度分值区间值。

with获取的是Tuples对象

intersectAndStore(K key, K otherKey, K destKey)

   获取2个变量的交集存放到第3个变量里面。

recommendRedisTemplate.opsForValue().multiGet(list1);批量获取多个key
recommendRedisTemplate.opsForValue().multiSet(Map);批量插入多个key

更多可参考：

RedisTemplate用法详解_李虹柏的博客-CSDN博客_redistemplate用法

RedisTemplate常用集合使用说明-opsForZSet(六)_别抢我蓝buff-CSDN博客

hero.fei
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot集成RedisTemplate
abaibai12的博客
03-23 3921
SpringBoot集成RedisTemplate，redis，redisTemplate
springboot配置redisTemplate
weixin_43119787的博客
10-14 881
@Configuration public class RedisConfig { @Bean public RedisTemplate<String, Object> template(RedisConnectionFactory factory) { // 创建RedisTemplate<String, Object>对象 RedisTemplate<String, Object> template = new Re.
SpringBoot使用RedisTemplate
热门推荐
m0_37965811的博客
02-07 1万+
目录 1.Redis五种基础数据结构 2.SpringBoot连接Redis 1 引入依赖 2 配置redis连接 3 编写测试类 3.详解 RedisTemplate 的 API 1 常用数据操作 2.几种数据结构操作的具体用法 1.Redis五种基础数据结构 参考链接：Redis入门 - 数据类型：5种基础数据类型详解 | Java 全栈知识体系，摘抄如下，更详细见原文 Redis基础文章非常多，关于基础数据结构类型，我推荐你先看下官方网站内容 (opens new window
Springboot 配置redis (使用Template)--把饭送到胃里版
最新发布
白开水
04-22 816
SpringBoot 配置redis 的方式可以有 jedis 和 Template 两种方式jedis 可以参考这篇文章SpringBoot 配置 jedis 来连接redis-CSDN博客首先配置 maven依赖，这个依赖，要结合自己的springboot 的版本去选，如果想要看自己的springboot 版本 在 启动类中去 加入，这两行代码。
SpringBoot集成Redis结合RedisTemplate操作
SmallCat0912的博客
12-26 2785
本文实现了在SpringBoot中集成Redis，使用RedisTemplate对象操作并编写了一些常用方法的工具类。
如何在SpringBoot中集成Redis(RedisTemplate)
qq_41563912的博客
10-21 4633
1、导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 如图： 2、在application.yml中配置Redis spring: redis: hos...
springboot之RestTemplateUtils
JDIT的博客
05-05 2129
回到首页☞ http请求是java web编程的核心功能，目前主流的方式三类java原生的，HttpClient和Spring的restTemplate。 对于一些老旧的jalor的系统会发现，换一拨人就会引入一个工具类，三种都用到了。 目前主流的java web框架就是spring全家桶，企业的二次封装后底层还是spring core，所以玩转restTemplate即可。 1、概述 sprin...
SpringBoot通过RedisTemplate执行Lua脚本的方法步骤
08-25
SpringBoot 通过 RedisTemplate 执行 Lua 脚本的方法步骤 Spring Boot 是一个基于 Java 的框架，用于构建企业级应用程序，而 Redis 是一个基于内存的 NoSQL 数据库，常用于缓存、消息队列和数据存储。Lua 脚本是 ...
SpringBoot通过redisTemplate调用lua脚本并打印调试信息到redis log(方法步骤详解)
08-25
SpringBoot通过redisTemplate调用lua脚本并打印调试信息到redis log是指在SpringBoot应用程序中，通过redisTemplate调用lua脚本，并将调试信息打印到redis log中。本文将详细介绍如何通过redisTemplate调用lua脚本，...
Redis在springboot中的使用教程
08-27
在 SpringBoot 中使用 Redis 需要依赖 spring-boot-starter-data-redis 依赖项。我们可以在 pom.xml 文件中添加以下依赖项： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-...
springboot中使用redis由浅入深解析
08-28
SpringBoot中使用Redis由浅入深解析 ...本文主要介绍了SpringBoot中使用Redis的方法，包括添加依赖、创建Redis连接工厂类、单元测试、使用RedisTemplate等步骤。通过这些步骤，可以轻松地在SpringBoot项目中使用Redis。
SpringBoot使用注解实现 Redis 数据库的切换.zip
04-08
4. 在业务代码中，通过`@Qualifier`注解或工具类方法选择使用哪个数据库的`RedisTemplate`。 这样，我们就能灵活地在多个Redis数据库之间切换，满足不同场景的需求。在实际开发中，还可以结合Spring的其他特性，如...
Spring Boot中RedisTemplate的使用
北辰
10-23 2280
RedisTemplate是SpringDataRedis中对JedisApi的高度封装，提供了redis各种操作、异常处理及序列化，支持发布订阅。
SpringBoot整合Redis--RedisTemplate
weixin_54345563的博客
04-03 2220
SpringBoot整合Redis--RedisTemplate快速上手
SpringBoot整合Redis（RedisTemplate5种数据类型的用法）
追寻心的步伐
08-09 1678
Spring Data Redis 是 Spring Data 系列的一部分，它提供了从 Spring 应用程序对 Redis 的轻松配置和访问。它提供了与商店交互的低级和高级抽象，使用户摆脱了对基础设施的担忧。
SpringBoot项目集成redis——RedisTemplate使用
stupidkid521的博客
02-27 1405
RedisTemplate获取相应类型进行操作
【springboot进阶】SpringBoot整合RedisTemplate配置多个redis库
06-17 1万+
SpringBoot整合RedisTemplate配置多个redis库，通过配置注入不同库的redis模板，便能灵活扩展，最后使用组件化的帮助类并对其进行操作。
SpringBoot中使用RedisTemplate
weixin_41998947的博客
05-19 537
下面是我在使用RedisTemplate在操作Redis的过程中遇到的一些问题以及解决方案。一、RedisTemplate无法序列化javabeanRedisTemplate的默认序列化的类为JdkSerializationRedisSerializer，如果使用默认的序列化类，则在取数据的时候则会报错自定义RedisTemplate的序列化方式@Bean// 使用 GenericFastJsonRedisSerializer 替换默认序列化// 设置key和value的序列化规则。
springboot使用redistemplate
05-10
Spring Boot提供了对Redis的支持，可以使用RedisTemplate来操作Redis数据库。RedisTemplate是Spring提供的一个对Redis操作的模板类，它封装了Redis的常见操作，可以方便地进行Redis数据的读写。 下面是一个使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值