【入门】SpringBoot配置redis

最新推荐文章于 2022-09-02 10:19:38 发布
最新推荐文章于 2022-09-02 10:19:38 发布
阅读量200 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37099009/article/details/103839543
版权

Pom文件

 <!--springboot- 整合redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

yml文件

spring:
  #redis配置信息
  redis:
    #redis 服务器地址
    host: 49.235.155.13
    #redis端口
    port: 6379
    #redis 密码
    password: bbbbbccc
    #客户端超时时间单位是毫秒 默认是2000
    timeout: 5000
    #最大空闲数
    maxIdle: 20
    #连接池的最大数据库连接数
    maxActive: -1
    #控制一个pool可分配多少个jedis实例,用来替换上面的maxActive
    maxTotal: 100
    #最大建立连接等待时间。如果超过此时间将接到异常
    maxWaitMillis: 100
    #连接的最小空闲时间
    minEvictableIdleTimeMillis: 864000000
    #每次释放连接的最大数目
    numTestsPerEvictionRun: 10
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程
    timeBetweenEvictionRunsMillis: 300000
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    testOnBorrow: true
    #在空闲时检查有效性
    testWhileIdle: false
    #数据库
    database: 1

配置redis序列化方法

package com.jy.chat_status_server.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;




/**
 * redis 配置类
 *
 * @author： jy Ps：我是抄袭网上大佬的配置
 * @create: 2020/1/3
 */
@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        //配置Jackson2JsonRedisSerializer
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //配置stringRedisSerializer
        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;
    }
}

写一个工具类

package com.jy.chat_status_server.common.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis 工具类
 * @author： example
 * @create: 2019/5/31
 */
public class RedisUtil {
    /**
     * 日志对象
     */
    private static Logger logger = LoggerFactory.getLogger(RedisUtil.class);

    /**
     * The constant RUN_MESSAGE.
     */
    private static RedisTemplate redisTemplate = (RedisTemplate)ApplicationHelper.getBean("redisTemplate");
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public static boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils expire(String key,long time) failure."+e.getMessage());
            return false;
        }
    }

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

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public static boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            logger.error("RedisUtils hasKey(String key) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public static 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 static Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public static boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils set(String key,Object value) failure."+e.getMessage());
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public static 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) {
            logger.error("RedisUtils set(String key,Object value,long time) failure."+e.getMessage());
            return false;
        }
    }

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

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

    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public static Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

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

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public static boolean hmset(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils hmset(String key, Map<String,Object> map) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public static 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) {
            logger.error("RedisUtils hmset(String key, Map<String,Object> map, long time) failure."+e.getMessage());
            return false;
        }
    }

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

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public static 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) {
            logger.error("RedisUtils hset(String key,String item,Object value,long time) failure."+e.getMessage());
            return false;
        }
    }

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

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

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

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

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

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

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static  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) {
            logger.error("RedisUtils sSetAndTime(String key,long time,Object...values) failure."+e.getMessage());
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public static  long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            logger.error("RedisUtils sGetSetSize(String key) failure."+e.getMessage());
            return 0;
        }
    }

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

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

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public static  long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            logger.error("RedisUtils lGetListSize(String key) failure."+e.getMessage());
            return 0;
        }
    }

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

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

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public static  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) {
            logger.error("RedisUtils lSet(String key, Object value, long time) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public static  boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils lSet(String key, List<Object> value) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public static  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) {
            logger.error("RedisUtils lSet(String key, List<Object> value, long time) failure."+e.getMessage());
            return false;
        }
    }

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

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



}

获取Bean的工具类

package com.jy.chat_status_server.common.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationHelper implements ApplicationContextAware {
    private  static ApplicationContext applicationContext;

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationHelper.applicationContext= applicationContext;
    }
    public  static Object getBean(String name){
        System.out.println(applicationContext);
        return applicationContext.getBean(name);
    }
}
qq_37099009
关注
专栏目录
SpringBoot使用Redis缓存技术
AI天才研究院
07-29 1620
随着互联网应用的普及、网站功能越来越复杂、数据量增长速度加快，单个服务器性能不足已经成为一个无法避免的问题。为了应对这个挑战，很多公司开始采用分布式缓存方案，比如Redis。本文将详细介绍如何在Spring Boot项目中集成Redis，并使用它来作为缓存服务。Redis是一个开源的高级键值存储数据库，它支持多种类型的数据结构，如字符串、哈希、列表、集合、有序集合等。它提供内存保护机制，可以有效防止缓存击穿和雪崩效应。如果你的应用程序需要高速缓存访问且对可靠性要求较高，那么Redis就是一个很好的选择。
SpringBoot + redis：入门学习
weixin_39576292的博客
07-18 441
SpringBoot 结合redis写的小测试，记录一下。 首先SpringBoot 项目里添加redis依赖： &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.springframework.boot&amp;amp;lt;/groupId&amp;amp;gt; &amp;amp;lt;artifa
spring boot + redis 配置
热门推荐
jaryle的专栏
08-07 1万+
1.引入reids包 spring-boot-starter-redis(springboot版本1.4版本前)，spring-boot-starter-data-redis（1.4版本后） 选择合适的API： 这个主要是根据redis存储的数据类型需求决定，key一般都是String，但是value可能不一样，一般有两种，String和 Object；  如果k-v都是String类型，我...
springboot项目中 jedis对redis缓存的操作
TonyWu的博客
06-02 1877
1:导入依赖      &lt;!--jedis--&gt; &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;version&gt;2.5.2&lt;/version&gt; &a
SpringBoot自定义redis配置
sly1311220942的博客
01-23 4102
直接上代码 配置: redislocal: host: 192.168.50.100 port: 6379 password: 123456 ssl: false database: 0 timeout: 6000 pool: max-active: 8 #缺省值8 max-idle: 8 #缺省值8 ...
Springboot+Redis 配置和使用
笨笨CEO的博客
08-03 231
转发地址：https://blog.csdn.net/ai88030669/article/details/78686403   pom.xml 引入redis 开启缓存 &lt;!-- cache --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&l...
SpringBoot——Redis配置
专注写bug
06-05 377
一、配置连接池等信息 ## 配置redis和数据库等 spring: ## redis redis: host: 127.0.0.1 port: 6379 #password: ##没有则为空(默认为空) database: 0 ## 设置redis数据库索引，默认为0 timeout: 30000 ## 连接超时时间(毫秒) jedis: pool: max-active: 8 ##最大连接数 max-w
SpringBoot集成Redis入门实例讲解
weixin_54585403的博客
03-09 435
关于springboot集成redis，今天写了这篇博客，分享给有需要的小伙伴们，相关的学习教程是看的动力节点的视频 动力节点王鹤老师讲解的springboot教程，由浅入深，带你体验Spring Boot的极速开发过程，内容丰富，涵盖了SpringBoot开发的方方面面，并且同步更新到Spring Boot 2.x系列的最新版本。 视频链接：https://www.bilibili.com/video/BV1XQ4y1m7ex Redis 基于内存进行存储，支持key-value的存储形式，底层使
SpringBoot整合Redis使用教程
江夏、的博客
04-05 2014
redis在springboot中的简单使用
SpringBoot集成Redis快速入门Demo
最新发布
04-05
- 在`application.properties`或`application.yml`文件中，我们需要配置Redis连接的详细信息，包括主机名、端口、密码（如果有的话）和数据库索引。 ```properties spring.redis.host=localhost spring.redis.port...
SpringBoot整合Redis配置
weixin_43535259的博客
05-30 297
Redis 是一套 key-value 高性能数据库，使用它可以大大提高我们的开发效率，在SpringBoot中，自动配置也帮我们节约了大量的配置。 使用它只需要以下几步 pom <dependency> <groupId>org.springframework.boot</groupId> <art...
Spring Boot 1.4.2.RELEASE Redis Session配置
01-05 615
在配置session到redis时候，网上的几个方法试过不成功，捣鼓折腾几回终于可以了。 pom中添加依赖： org.springframework.boot spring-boot-starter-redis org.springframework.session spring-session-data-redis redis.clients jedis 2.
springboot 简单实现Redis 配置使用
风兮雨露的博客
05-28 1504
1、描述 （1）Redis 是安装在window 10 系统，本地启动Redis； (2) 使用springboot 创建项目，对Redis进行配置，简单实用； （3）使用RedisDesktopManager 作为Redis客户端查看数据。 （4）提供Git 地址：https://github.com/kinber123/redisDemo.git 2、安装本地Redis 和客户端RedisDesktopManager （1）下载百度云： 链接：h...
SpringBoot整合Redis及应用 高低版本配置详情
qq_27242695的博客
01-15 1891
文章目录SpringBoot整合Redis1整合Redis1.1 添加依赖1.2 application.properties配置1.2.1 哨兵连接配置1.2.2 单机版连接配置1.2.3 注意1.3 Redis核心配置类-RedisConfig.java1.3.1 Spring提供的序列化器（使用方式自行百度）1.3.2 为什么要序列化？2. 验证2.1 在redis中存储student对象 SpringBoot整合Redis SpringBoot版本：2.x以上 本案例版本：2.4.1 1整合Redi
SpringBoot整合redis（超简单配置）
学海无涯~
07-01 5671
看了网上很多springboot整合redis的文章，大多数都是自己写一个javaConfig配置文件，然后注入工厂、模版、连接池。完全没有发挥springboot的优势：约定大于配置 1&gt; 添加依赖： &lt;dependency&gt; &lt;groupId&gt;org.springframework.data&lt;/group...
Springboot2.x.x连接Redis配置整合
weixin_39523456的博客
11-12 5635
目录 一、必看前言 对于整篇文章要解决的问题要有一个基础的认知 了解springboot2.x.x各个版本存在的问题 二、springboot2.x.x - lettuce连接Redis配置方式 0.公共的配置文件 1.springboot2.3.x-lettuce 2.springboot2.2.x-lettuce 3.springboot2.1.x-lettuce 三、springboot2.x.x - jedis连接Redis配置方式 0.公共的配置文件 1.springb...
【Redis】Spring Boot下使用Redis，配置多个database数据源
qq_39043700的博客
09-02 5384
本文介绍在spring boot下，如何为redis配置多个database数据源。
SpringBoot 2 整合redis
wenhui 的博客
12-29 331
SpringBoot 2 整合redis 1.文件结构 2.pom.xml配置 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depen...
springboot整合redis，用户和密码的关系导致Unable to connect to Redis；
来一杯吧
03-26 5282
错误的配置 spring.redis.username=aa spring.redis.password=123456 spring: redis: database: 0 host: 127.0.0.1 port: 6379 username: aa password: 123456 timeout: 1000 今天配置的时候username也配置上了，导致Unable to connect to Redis异常，总结一下：如果有用户名的话直接配置
SpringBoot整合Redis实战：配置与测试
接下来是配置Redis的连接信息。这通常在SpringBoot的配置文件（如`application.properties`或`application.yml`）中完成，设置`spring.redis.host`为Redis服务器的IP地址（默认是本地127.0.0.1），`spring.redis....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值