springboot集成redis

最新推荐文章于 2025-03-25 20:51:00 发布
最新推荐文章于 2025-03-25 20:51:00 发布
阅读量311 收藏
点赞数 1
分类专栏： spring boot 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sjgllllll/article/details/115251221
版权

简介：在springboot2.x之后，原来使用的jedis被替换为lettuce
jedis：采用直连，多个线程操作不安全，如果想要避免不安全，使用Jedis pool连接池；BIO模式
lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据。NIO模式

1.引入依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

查看RedisProperties：
在这里插入图片描述

2.配置application.propertie

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0

RedisTemplate操作不同数据类型
在这里插入图片描述
测试

@SpringBootTest
class RedisSpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {

       // redisTemplate  操作不同数据类型
      /*  redisTemplate.opsForCluster();
        redisTemplate.opsForList();
        redisTemplate.opsForSet();*/

      //获取redis连接对象
       /* RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
        connection.flushAll();*/


       redisTemplate.opsForValue().set("mykey","helloword");
        System.out.println(redisTemplate.opsForValue().get("mykey"));


    }

}

对象序列化设值：

pojo：

//在企业中，我们所有的pojo都会序列化
public class User implements Serializable {

    private String name;
    private int age;
}

测试：

 @Test
    public void test() throws JsonProcessingException {
        //真实开发一般都是用json来传递对象
        User user = new User("张三",11);
       // String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));

    }

实现对象序列化！！！
但在开发中我们不可能对所有的key都序列化，所以需要我们自己编写RedisTemplate及

3.RedisConfig配置类

/**
 * @Description 编写自己的RedisTemplate
 */

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
            throws UnknownHostException {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //  Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有,包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会抛出异常
        //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);  //@Deprecated 已过时
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //配置具体的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);

        //hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);

        //value序列化采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

在开发中我们也不会直接使用下列方式来直接操作redis：需要我们编写RedisUtil工具类：
在这里插入图片描述

4.RedisUtil工具类：

package com.sun.utils;

/**
 * @author sun
 * @date 2021/3/26 - 20:14
 */
import java.util.Collection;
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.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    //=============================common============================
    /**
     * 指定缓存失效时间
     * @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 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================
    /**
     * 普通缓存获取
     * @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 键
     * @param by 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

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

    //================================Map=================================
    /**
     * HashGet
     * @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);
    }

    /**
     * HashSet
     * @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;
        }
    }

    /**
     * HashSet 并设置时间
     * @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);
    }

    //============================set=============================
    /**
     * 根据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=================================

    /**
     * 获取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 值
     * @param time 时间(秒)
     * @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 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> 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;
        }
    }
}

测试：

 @Autowired
    private RedisUtil redisUtil;

    @Test
    public void test1() throws JsonProcessingException {
        redisTemplate.opsForValue().set("mykey","欢迎");
        System.out.println(redisUtil.get("mykey"));

    }

完成！！！

SpringBoot教程：使用Java实现登出功能，删除Redis中的缓存session和清空Cookies
CyberByte的博客
08-14 1331
本篇文章将演示如何使用Spring Boot框架和Java语言来实现用户登出功能，并通过删除Redis中的缓存session和清空Cookies来确保用户安全退出。本文演示了如何使用Spring Boot框架和Java语言来实现用户登出功能。希望本文能够帮助你理解和实现这一功能。SpringBoot教程：使用Java实现登出功能，删除Redis中的缓存session和清空Cookies。源代码：https://github.com/example/spring-boot-logout-demo。
【springboot系列】redis安装和卸载
haibo_bear的博客
05-06 332
redis安装和卸载 文章目录redis安装和卸载一、redis卸载二、redis安装2.1、redis下载安装2.2、redis.conf配置2.3、redis服务设置为系统服务 一、redis卸载 非首次安装请看这，首次安装可跳过。 ps -ef| grep redis 查看redis是否启动，如果启动使用如下命令杀掉redis进程 kill -9 进程号 查看以下目录下是否存在redis...
SpringBoot项目依赖第三方jar，但是这个jar包含了其他的组件如redis等如何去掉
爱情的错的博客
12-20 1327
解决方法： 排除自动配置 @SpringBootApplication(exclude = {RedisAutoConfiguration.class})
Spring Boot 集成 Redis：从入门到实战的详细学习指南
最新发布
03-25 1005
例如，在电商网站中，商品详情页的访问量非常高，将商品信息缓存在 Redis 中，可以快速响应用户的请求，避免频繁查询数据库。Spring Boot 提供了丰富的 Starter POMs，这些 Starter POMs 包含了开发特定功能所需的依赖，开发者只需添加对应的 Starter POM，即可快速引入所需的依赖。需要注意的是，Redis 默认提供了 16 个数据库（从 0 到 15），但在实际开发中，通常不建议使用不同的数据库索引来分隔数据，而是通过不同的实例或 Redis 集群来隔离数据。
sprinboot启动如何清理redis缓存
weixin_29178069的博客
07-06 272
如何在Spring Boot启动时清理Redis缓存 在一些场景下，我们可能需要在Spring Boot应用启动时清理Redis缓存，以确保数据的准确性和一致性。本文将介绍如何在Spring Boot应用启动时清理Redis缓存，并提供详细的代码示例。 准备工作 在开始之前，我们需要确保已经在Spring Boot项目中集...
Spring Boot Redis关闭
小码蚁
03-04 4056
【代码】Spring Boot Redis关闭。
SpringBoot Redis 清除所有的key
BASK2311的博客
05-03 1375
我们可以使用RedisTemplate类的keys方法来获取Redis中所有的key，然后再遍历所有的key，使用delete方法删除每一个key来实现清除Redis中所有的数据。在方法中，我们首先使用keys方法获取所有匹配的key，其中pattern参数是一个通配符字符串，例如"prefix:*"表示获取所有以"prefix:"开头的key。在上述示例代码中，我们使用@Autowired注解注入了一个RedisTemplate对象，然后定义了一个clear方法来实现清除Redis中所有的数据的操作。
SpringBoot集成Redis
02-26
SpringBoot集成Redis是一个常见的开发需求，它使得应用可以利用Redis的高性能、内存存储特性进行数据缓存和快速访问。在本项目中，我们将探讨如何在SpringBoot应用中配置和使用Redis，以及如何利用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的自动配置
热门推荐
刚好五个字的博客
07-05 3万+
因为要配置对个redis链接，所以将系统自带的配置排除，分别是 RedisAutoConfiguration.class 和 RedisRepositoriesAutoConfiguration.class 两个自动配置类 @SpringBootApplication(exclude={ RedisAutoConfiguration.class, RedisR...
在springboot中redis优雅批量匹配并删除（scan迭代查询，循环删除，非阻塞）
HD243608836的博客
06-08 6145
在搭建了项目之后，由于需要通过触发动作，并删除redis中多个key。 在查询了jedis并没有类似的删除方法之后，事情就变得清晰起来。完成上述任务，分为两个步骤： 从找到要删除的key来说，有两种方法，一种是通过jedis的keys方法来获得；另外一种是通过scan方法获得。 使用keys方法，寻找包含指定参数的key，其中“*”是匹配符，要是想找前缀就在其后加*，要是找后缀就在传入参数后面加*，而要是图省事方便，前后加*即可。12345678910 使用scan方法，寻找包含
SpringBoot + Redis 实现增删改查的缓存
weixin_47009272的博客
12-11 1269
SpringBoot + Redis 实现增删改查的缓存
SpringBoot如何在排除不需要的依赖 DataSource/mongoDB/redis/RabbitMQ
Genmer的博客
03-25 2637
前言 最近在搭建eureka服务发现以来了之前的模块，但是有很多不需要的依赖一直自动装配，如数据源、mongoDB，redis，RabbitMQ 直接上代码,启动类加注解 @SpringBootApplication (exclude = { // 排除数据源 DataSourceAutoConfiguration.class, // 禁止mongodb自动装配 MongoAutoConfiguration.class, // 禁止red
java redis 批量删除_在Spring中使用Redis Lua脚本批量删除缓存
weixin_31889665的博客
02-13 586
背景之前分享了一篇利用lua脚本批量删除redis的key的文章.现在项目中我打算使用spring的缓存,而Spring缓存以前我是用ehcache来做实现的.没发现什么问题..这次我换成redis来做缓存了..一般也没什么大问题...目前唯一遇到的一个比较坑的问题就是缓存通过注解删除不了..我想想好像也算正常吧.因为java里面做缓存的话可能会使用map类似的结构,我remove掉一个key,不...
fastjson 如何忽略@type类型解析
程序员星痕的博客
09-14 4727
最新使用Springboot redisTemplate遇到一个问题，自定义RedisSerializer中使用了fastjson进行序列化，调用JSON.toJSONString函数时添加了SerializerFeature.WriteClassName参数，导致反序列化的时候报错，，原因就是反序列化指定的类类型与序列化的时候不一致，虽然类名一样，但是全路径不一样。通常在不同的系统间进行交互，使用同一个redis集群中的资源时会出该问题。自定义AutoTypeCheckHandler，进行全局配置。
SpringBoot和Redis的交互数据操作以及Redis的持久化/删除策略和缓存问题
weixin_71072718的博客
08-17 1455
当我们客户端访问不存在的数据时，先请求redis，但是此时redis中没有数据， 此时会访问到数据库，但是数据库中也没有数据，这个数据穿透了缓存，直击数据库，我们都知道数据 库能够承载的并发不如redis这么高，如果大量的请求同时过来访问这种不存在的数据，这些请求就都会 访问到数据库，简单的解决方案就是哪怕这个数据在数据库中也不存在，我们也把这个数据存入到redis 中去，这样，下次用户过来访问这个不存在的数据，那么在redis中也能找到这个数据就不会进入到缓存了。是用于指定该实体类对应的数据库表名。
springboot整合Redis
珍爱飞的博客
05-15 234
使用redis的前提是安装了Redis服务，并正常启动着，可参考：Linux下安装Redis 1.配置依赖，并排除data-redis默认使用的lettuce工具，使用jedis作为连接Redis的工具 <!-- springboot整合Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactI
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 ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值