SpringBoot集成Redis

最新推荐文章于 2024-10-08 15:38:37 发布
最新推荐文章于 2024-10-08 15:38:37 发布
阅读量300 收藏
点赞数
分类专栏： 工具类 数据库 java 文章标签： redis spring boot 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45191709/article/details/127314373
版权
java 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
工具类
5 篇文章 0 订阅
订阅专栏
数据库
2 篇文章 2 订阅
订阅专栏

SpringBoot集成Redis

一，导入包：

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.3.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.3.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
    </dependencies>

二，配置连接：

spring:
  redis:
    host: 127.0.0.1
    port: 6379

三，自定义的RedisTemplate

/**
 * @ClassName RedisConfig
 * @Description:
 * @Author WiWi
 * @Date 2022-10-12
 * @Version V1.0
 **/
@Configuration
public class RedisConfig {
    //自定义的RedisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        //我们为了自己开发方便，一般直接使用<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om=new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //  activateDefaultTyping用于替换上面的enableDefaultTyping（enableDefaultTyping（springboot2.3版本）已弃用）
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,ObjectMapper.DefaultTyping.NON_FINAL,JsonTypeInfo.As.WRAPPER_ARRAY);

        jackson2JsonRedisSerializer.setObjectMapper(om);
        
        //String的序列化
        StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
        //key才用string的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也才用string的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value序列化方式才用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化方式也才用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();


        return template;
    }
}

四，编写RedisUtil工具类

/**
 * @ClassName RedisUtil
 * @Description:Redis工具类
 * @Author WiWi
 * @Date 2022-10-13
 * @Version V1.0
 **/
@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 给一个指定的 key 值附加过期时间
     *
     * @param key
     * @param time
     * @return
     */
    public boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }
    /**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */
    public long getTime(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    /**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 移除指定key 的过期时间
     *
     * @param key
     * @return
     */
    public boolean persist(String key) {
        return redisTemplate.boundValueOps(key).persist();
    }

//- - - - - - - - - - - - - - - - - - - - - String类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 根据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 void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 将值放入缓存并设置时间
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒) -1为无期限
     * @return true成功 false 失败
     */
    public void set(String key, String value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value);
        }
    }

    /**
     * 批量添加 key (重复的键会覆盖)
     *
     * @param keyAndValue
     */
    public void batchSet(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSet(keyAndValue);
    }

    /**
     * 批量添加 key-value 只有在键不存在时,才添加
     * map 中只要有一个key存在,则全部不添加
     *
     * @param keyAndValue
     */
    public void batchSetIfAbsent(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
    }

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是长整型 ,将报错
     *
     * @param key
     * @param number
     */
    public Long increment(String key, long number) {
        return redisTemplate.opsForValue().increment(key, number);
    }

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是 纯数字 ,将报错
     *
     * @param key
     * @param number
     */
    public Double increment(String key, double number) {
        return redisTemplate.opsForValue().increment(key, number);
    }

//- - - - - - - - - - - - - - - - - - - - - set类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 将数据放入set缓存
     *
     * @param key 键
     * @return
     */
    public void sSet(String key, String value) {
        redisTemplate.opsForSet().add(key, value);
    }

    /**
     * 获取变量中的值
     *
     * @param key 键
     * @return
     */
    public Set<Object> members(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 随机获取变量中指定个数的元素
     *
     * @param key 键
     * @param count 值
     * @return
     */
    public void randomMembers(String key, long count) {
        redisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     * 随机获取变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object randomMember(String key) {
        return redisTemplate.opsForSet().randomMember(key);
    }

    /**
     * 弹出变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object pop(String key) {
        return redisTemplate.opsForSet().pop("setValue");
    }

    /**
     * 获取变量中值的长度
     *
     * @param key 键
     * @return
     */
    public long size(String key) {
        return redisTemplate.opsForSet().size(key);
    }

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

    /**
     * 检查给定的元素是否在变量中。
     *
     * @param key 键
     * @param obj 元素对象
     * @return
     */
    public boolean isMember(String key, Object obj) {
        return redisTemplate.opsForSet().isMember(key, obj);
    }

    /**
     * 转移变量的元素值到目的变量。
     *
     * @param key 键
     * @param value 元素对象
     * @param destKey 元素对象
     * @return
     */
    public boolean move(String key, String value, String destKey) {
        return redisTemplate.opsForSet().move(key, value, destKey);
    }

    /**
     * 批量移除set缓存中元素
     *
     * @param key 键
     * @param values 值
     * @return
     */
    public void remove(String key, Object... values) {
        redisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 通过给定的key求2个set变量的差值
     *
     * @param key 键
     * @param destKey 键
     * @return
     */
    public Set<Set> difference(String key, String destKey) {
        return redisTemplate.opsForSet().difference(key, destKey);
    }


//- - - - - - - - - - - - - - - - - - - - - hash类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 加入缓存
     *
     * @param key 键
     * @param map 键
     * @return
     */
    public void add(String key, Map<String, String> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 获取 key 下的 所有 hashkey 和 value
     *
     * @param key 键
     * @return
     */
    public Map<Object, Object> getHashEntries(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 验证指定 key 下 有没有指定的 hashkey
     *
     * @param key
     * @param hashKey
     * @return
     */
    public boolean hashKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 获取指定key的值string
     *
     * @param key 键
     * @param key2 键
     * @return
     */
    public String getMapString(String key, String key2) {
        return redisTemplate.opsForHash().get("map1", "key1").toString();
    }

    /**
     * 获取指定的值Int
     *
     * @param key 键
     * @param key2 键
     * @return
     */
    public Integer getMapInt(String key, String key2) {
        return (Integer) redisTemplate.opsForHash().get("map1", "key1");
    }

    /**
     * 弹出元素并删除
     *
     * @param key 键
     * @return
     */
    public String popValue(String key) {
        return redisTemplate.opsForSet().pop(key).toString();
    }

    /**
     * 删除指定 hash 的 HashKey
     *
     * @param key
     * @param hashKeys
     * @return 删除成功的 数量
     */
    public Long delete(String key, String... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Long increment(String key, String hashKey, long number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Double increment(String key, String hashKey, Double number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 获取 key 下的 所有 hashkey 字段
     *
     * @param key
     * @return
     */
    public Set<Object> hashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    /**
     * 获取指定 hash 下面的 键值对 数量
     *
     * @param key
     * @return
     */
    public Long hashSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }

//- - - - - - - - - - - - - - - - - - - - - list类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 在变量左边添加元素值
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPush(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 获取集合指定位置的值。
     *
     * @param key
     * @param index
     * @return
     */
    public Object index(String key, long index) {
        return redisTemplate.opsForList().index("list", 1);
    }

    /**
     * 获取指定区间的值。
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<Object> range(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 把最后一个参数值放到指定集合的第一个出现中间参数的前面，
     * 如果中间参数值存在的话。
     *
     * @param key
     * @param pivot
     * @param value
     * @return
     */
    public void leftPush(String key, String pivot, String value) {
        redisTemplate.opsForList().leftPush(key, pivot, value);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void leftPushAll(String key, String... values) {
// redisTemplate.opsForList().leftPushAll(key,"w","x","y");
        redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 向集合最右边添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPushAll(String key, String value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void rightPushAll(String key, String... values) {
//redisTemplate.opsForList().leftPushAll(key,"w","x","y");
        redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void rightPushIfPresent(String key, Object value) {
        redisTemplate.opsForList().rightPushIfPresent(key, value);
    }

    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @return
     */
    public long listLength(String key) {
        return redisTemplate.opsForList().size(key);
    }

    /**
     * 移除集合中的左边第一个元素。
     *
     * @param key
     * @return
     */
    public void leftPop(String key) {
        redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public void leftPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().leftPop(key, timeout, unit);
    }

    /**
     * 移除集合中右边的元素。
     *
     * @param key
     * @return
     */
    public void rightPop(String key) {
        redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public void rightPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().rightPop(key, timeout, unit);
    }
}

五，测试使用


@RunWith(SpringRunner.class)
@SpringBootTest
public class TestDemo {

    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate redisTemplate;

    @Autowired
    private RedisUtil redisUtil;

    //不使用工具类
    @Test
    public void test() {
        //操作不同的类型
        //String opsForValue
        //List opsForList
        //Set     opsForSet
        //...
        redisTemplate.opsForValue().set("test", "wiwi");
        System.out.println(redisTemplate.opsForValue().get("test"));
    }

    //使用工具类
    @Test
    public  void test2(){
        redisUtil.set("age",26);
        System.out.println(redisUtil.get("age"));
    }

}
憨憨不敢_
关注
专栏目录
一键解决redis序列化问题
qq_35142561的博客
07-28 7090
一、spring boot 集成Redis方法 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 二、Redis
动力节点-王妈妈Springboot教程（六）Redis
A_coding的博客
01-17 546
第六章 Redis 官方下载地址 动力节点springboot资料 视频观看地址 https://www.bilibili.com/video/BV1XQ4y1m7ex Redis ： 一个NoSQL数据库， 常用作缓存使用 （cache） Redis的数据类型： string , hash ,set ,zset , list Redis是一个中间件： 是一个独立的服务器。 java中著名的客户端： Jedis ， lettuce ， Redisson Spring，SpringBoot中有
Springboot集成Redis详细教程（缓存注解使用@Cacheable,@CacheEvict,@CachePut）
热门推荐
少说，多做
05-01 1万+
文章目录一、SpringBoot集成Redis1.Pom依赖2.Spring yml文件配置（以Cluster模式为例)3.Redis类配置二、@Cacheable注解使用1.Cache和CacheManager接口说明2.@Cacheable使用2.1.代码样例2.2.@Cacheable常用属性参数2.3.key spEL表达式3.@CacheEvict使用4.@CachePut使用5.@Caching使用结尾 一、SpringBoot集成Redis Jedis和Lettuce是Java操作Redi
Redis5.0版本后使用详解
weixin_43790613的博客
07-31 1659
文章目录客户端命令数据操作命令String类型数据库 查看Redis安装目录whereis redis 客户端命令 客户端登录命令：redis-cli -h ip -p port -a "密码" ,-h后面是ip，-p后面是端口号，-a后面是密码，有的登录不支持密码，需要登录使用auth "密码"命令，才能使用命令 查看所有key值命令：keys * 数据操作命令 查看key值的数据类型：type key String类型 设置值：set key value key为变量名，value为变
spring boot 2.3x 集成redis 集群
Shiro °
04-11 244
JedisConnectionFactory 默认使用lettuce 链接方式，排除， 配置文件对应jedis <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <exclusions> <exclus...
SpringBoot之集成Redis(集群模式）
weixin_38169722的博客
08-28 218
环境 SpringBoot2.0 增加maven依赖 <!-- redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-star...
redis系列之SpringBoot整合redis
奋斗的哼哼
07-11 289
SpringBoot整合redis 上一篇写的是Spring整合redis，这一篇说一下SpringBoot整合redis。 1、 整合redis 需要的jar //这里使用的是springBoot2.3.0.RELEASE <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifac
springboot集成redis缓存
qq_36743472的博客
09-18 287
redis是一款完全基于内存的K-V数据库，由于其基于内存，因此有着极高的性能，根据redis官方给出的资料，redis的可支持的并发高达6000/s，而且，redis支持丰富的数据结构，之前也出过一篇centos7安装redis的文章小白也会操作 ！Centos7 安装redis，如果感兴趣的小伙伴可自行安装，redis有对应的Windows版本，但是目前最新的Windows版本为3.2.0，因此，如果想使用最新版的redis功能，建议使用Linux系统安装。 使用redis的必要性 ...
Springboot集成Redis
12-21
**SpringBoot集成Redis详解** 在现代的Web应用开发中，数据缓存是提高系统性能的重要手段之一，而Redis作为一款高性能的键值存储系统，因其高效、易用和丰富的数据结构，被广泛应用在缓存、消息队列等多个场景。...
springBoot集成redis
03-03
本文将详细介绍如何在Spring Boot项目中集成Redis和MyBatis，以实现数据缓存和数据库操作。 首先，为了在Spring Boot项目中引入Redis，我们需要在`pom.xml`文件中添加Spring Data Redis依赖： ```xml <groupId>...
SpringBoot学习秒杀一、SpringBoot集成Redis (使用Jedis实现)
12-22
【SpringBoot集成Redis (使用Jedis实现)】 在Spring Boot应用中集成Redis是一个常见的需求，因为Redis作为一个高性能的键值数据库，常用于缓存、消息队列等多种场景。本篇文章将介绍如何通过Jedis库来实现Spring ...
springboot集成Redis
05-08
Redis 是一个开源的 使用 ANSI C 语言编写、支持网络、可基于内存亦可持久化的日志 型、Key-Value 数据库。 Redis 的 key 是字符串类型,但是 key 中不能包括边界字符 ,由于 key 不是 binary safe 的字符串,所以像”...
Spring Boot 整合 Redis 超详细教程
weixin_44966143的博客
02-28 4629
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。话不多说直接干货！！！
SpringBoot 2.3 整合redis缓存自定义序列化
xhnb的博客
05-28 2223
1.引言 我们使用redis作为缓存中间件时，当我们第一次查询数据的时候，是去数据库查询，然后查到的数据封装到实体类中，实体类会被序列化存入缓存中，当第二次查数据时，会直接去缓存中查找被序列化的数据，然后反序列化被我们获取。我们在缓存中看到的序列化数据不直观，如果想看到类似json的数据格式，就需要自定义序列化规则。 2.整合redis pom.xml: <!--引入redis--> <dependency> <groupId>
springboot笔记
m0_72673660的博客
09-18 1472
1
springboot集成redis
weixin_40400245的博客
07-12 437
1. pom.xml添加依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupI
redis序列化自定义类,踩坑之路（感觉能踩的都踩了。。。）
qq_43227733的博客
05-27 2557
redis序列化自定义类
Redis-缓存一致性
最新发布
qq_39007838的博客
10-08 1255
自己的理解，只要是写缓存的方式，都会存在线程写入先后导致的数据不一致监听 binlogHomecanal 选择版本 1.6.1mysql: 5.7 docker环境安装。
springboot 集成 redis
08-12
在Spring Boot中集成Redis可以通过以下步骤实现： 1. 引入spring-boot-starter-data-redis依赖。在项目的pom.xml文件中，添加以下依赖项： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 这将自动引入与Redis集成所需的依赖项。 2. 在Spring Boot的核心配置文件application.properties中配置Redis连接信息。在该文件中添加以下配置项： ``` spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password=123456 ``` 根据你的实际情况，将host、port和password替换为相应的值。这些配置将用于建立与Redis服务器的连接。 通过以上步骤，你就成功地在Spring Boot应用程序中集成了Redis。现在，你可以使用Spring Data Redis的API来访问和操作Redis数据库。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [SpringBoot集成redis](https://blog.csdn.net/qq_43512320/article/details/122684865)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [springboot集成Redis](https://blog.csdn.net/m0_54853420/article/details/126515971)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值