Windows10系统Springboot2.x集成Redis集群(二：系统集成）

最新推荐文章于 2024-05-23 11:06:16 发布
置顶 最新推荐文章于 2024-05-23 11:06:16 发布
阅读量1.9k 收藏 3
点赞数 3
分类专栏： 系统整合 文章标签： springboot2.x集成redis集群 redis管理session springboot+redis springboot2.x + redis + session redis+session共享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37063785/article/details/88107630
版权

Windows10系统Springboot2.x集成Redis集群(一：集群构建）

在上一篇博客中详细描述了windows系统下redis集群的构建，本篇继续为大家演示springboot2.x与redis集群的整合。
从工程构建开始，现在idea中构建一个springboot工程，如下：
springboot初始工程
下面需要引入redis相关依赖：

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

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

<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-pool2</artifactId>
</dependency>

修改application.yml:

spring:
  # redis配置
  redis:
    cluster:
      nodes: 127.0.0.1:6379, 127.0.0.1:6380, 127.0.0.1:6381
      max-redirects: 3
    lettuce:
      pool:
        max-active: 1000  # 连接池最大连接数
        max-idle: 10      # 连接池最大空闲连接
        min-idle: 5       # 连接池最小空闲连接
        max-wait: -1ms    # 连接池最大阻塞时间
    timeout: 3000ms

  session:
    store-type: redis
    timeout: 30m
    redis:
      namespace: redis:session

重写redis的key/value序列化策略：

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author ：duc
 * @Description ：重写redis序列化策略
 * @date ：Created in 2019/3/4 上午 11:12
 */
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        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 = 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类：


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author ：duc
 * @Description ：
 * @date ：Created in 2019/3/4 上午 11:14
 */
@Component
public class RedisUtil {
    private static final Logger log = LoggerFactory.getLogger(RedisUtil.class);

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

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

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

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            log.info("判断key是否存在，key:{}", key);
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            log.info("判断key是否存在error，key:{}", key);
            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(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);
            log.info("保存缓存, key:{}, value:{}", 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);
            }
            log.info("保存缓存并设置时间, key:{}, value:{}, time:{}", key, value, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于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 delta 要减少几(小于0)
     * @return
     */
    public 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 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)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

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

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     */
    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 值 可以是多个
     */
    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 值 可以是多个
     */
    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代表所有值
     */
    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 键
     */
    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倒数第二个元素，依次类推
     */
    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 值
     */
    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 时间(秒)
     */
    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 值
     */
    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 时间(秒)
     */
    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 值
     */
    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 值
     */
    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;
        }
    }
}

建立测试类：

import com.springdataredis.demo.util.RedisUtil;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author ：duc
 * @Description ：
 * @date ：Created in 2019/3/4 上午 11:15
 */
@RestController
public class Test {

    @Resource
    private RedisUtil redisUtil;

    @RequestMapping("/test")
    public void test(){
        redisUtil.set("test111", 111);
        redisUtil.set("test222", 111);
        redisUtil.set("test333", 111);
        redisUtil.set("test444", 111);
        redisUtil.set("test555", 111);
        redisUtil.set("test666", 111);
        redisUtil.set("test777", 111);
        redisUtil.set("test888", 111);
    }

    @RequestMapping("/test2")
    public void test2(){
        System.out.println(redisUtil.get("test111"));
        System.out.println(redisUtil.get("test333"));
        System.out.println(redisUtil.get("test555"));
        System.out.println(redisUtil.get("test888"));
    }
}

分别在浏览器访问localhost:8080/test,localhost:8080/test2， 结果如下：
可以看到数据已被分别保存至不同的节点，获取的时候也是从对应节点取值
redis测试
redis库
到这里springboot与redis集群整合已经完成，细心的同学可能已经发现，上面的两个配置似乎没有用到：


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



 session:
   store-type: redis
   timeout: 30m
   redis:
     namespace: redis:session

按名称可以看出这两个配置都和session有关，那这里继续为大家演示使用redis来保存session：
我们先来新建一个LoginInterceptor

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * @author ：duc
 * @Description ：
 * @date ：Created in 2019/3/4 上午 11:59
 */
@Controller
@Component
public class LoginInterceptor extends HandlerInterceptorAdapter {
    private static final Logger log = LoggerFactory.getLogger(LoginInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("----------------进入拦截器----------------");
        //这里的session将会直接从redis中获得
        HttpSession session = request.getSession();
        System.out.println(session.getId());
        String users = session.getAttribute("user").toString();
        if (users == null || "".equals(users)) {
            String requestType = request.getHeader("X-Requested-With");
            if (requestType != null && requestType.equals("XMLHttpRequest")) {
                response.setHeader("sessionstatus", "timeout");
                response.getWriter().print("LoginTimeout");
                return false;
            } else {
                log.info("尚未登录，跳转到登录界面");
                response.sendRedirect("/");
            }
            return false;
        }
        log.info("已登陆，不进行拦截");
        return true;
    }
}

新建SessionConfiguration

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

@Configuration
public class SessionConfiguration implements WebMvcConfigurer {

    @Resource
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration interceptorRegistration = registry.addInterceptor(loginInterceptor);
        // 这里添加拦截器例外，除了“/”之外的所有请求都会被拦截
        interceptorRegistration.excludePathPatterns("/");
    }

}

创建测试类

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * @author ：duc
 * @Description ：
 * @date ：Created in 2019/3/4 上午 11:15
 */
@RestController
public class Test {

    @RequestMapping("/")
    public void index(HttpServletRequest request){
        HttpSession s = request.getSession();
        // 这里随便往session中放入一个值，模拟用户登陆
        s.setAttribute("user", "user");
        System.out.println(s.getId());
    }
}

在浏览器中访问localhost:8080, 然后查看数据库，可以看到session已经保存至redis中了
redisSession
然后继续访问localhost:8080/test,可以从控制台看到两次sessionID与redis中保存的sessionID一致，说明我们用redis管理session成功。
在这里插入图片描述

至此，springboot2.x集成redis集群就结束了，感兴趣的同学可以使用多个工程来测试，这里就不再进行演示了。
源码地址
相关源码已上传至github，除了redis集群，源码中也有如mongodb，es等整合，相关博客会在后续发布。

du-hyper
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javaweb三层架构和ssm框架一样吗，就是这么简单
碧海朝天素
06-29 527
Spring面试高频问题 SpringMVC面试高频问题 MyBatis面试高频问题 SpringBoot面试高频题 SpringCloud面试高频问题 Redis高级面试题 Dubbo高频常问面试问题 Java虚拟机（JVM） MySQL数据库高频面试问题 Java高频面试专题合集解析： 当然在这还有更多整理总结的Java进阶学习笔记和面试题未展示，在这也是免费分享给那些有需要的朋友，其中囊括了Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高
springboot2.x-redis:springboot和redis整合的简单demo
05-10
10. **实战演练**: "springboot2.x-redis-master"这个压缩包中的代码应该包含了一个简单的Spring Boot应用，展示了如何配置和使用Redis。通过阅读和运行代码，可以加深对Spring Boot与Redis整合的理解。 以上就是...
解决springboot2.x遇到的一段时间内不使用，redis连接和HikariPool连接池超时的问题
architect_cloud的博客
03-10 6062
最近在使用springboot2.x 时遇到了一个很奇怪的问题
SpringBoot 整合 Redis
最新发布
m0_57801749的博客
05-23 198
5. 定制化 LettuceConnectionFactory。3. 定制化redisTemplate。4. 定制化缓存管理。
Spring Boot Redis Cache 序列化配置
小水牛的博客
11-23 2050
Spring Boot Cache
spring boot爬坑之旅途--redis-redis配置(10)
日进斗识
05-06 318
package com.zm.blog.config.redis; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.Red...
SpringBoot整合Redis缓存
凉茶铺的博客
07-15 4740
7）基于注解的Redis缓存更新测试。先通过浏览器访问“http//localhost8080/updateComment/1/shitou”更新id为1的评论作者名为shitou；接着，继续访问“http//localhost8080/findCommentById?id=1”查询id为1的用户评论信息可以看出，执行updateComment()方法更新id为1的数据时执行了一条更新SQL语句，后续调用findById()方法查询id为1的用户评论信息时没有执行查询SQL语句，且浏览器正确返回。.....
SpringBoot集成Redis集群
09-28
SpringBoot集成Redis集群 在本文档中，我们将指导您如何在SpringBoot 2.X中集成Redis集群。下面是相关的知识点： 集成Redis集群的必要性 在实际应用中，使用Redis集群可以提高系统的可扩展性和可靠性。Redis集群...
springboot集成redis集群,redis安装包配置
09-02
在本文中，我们将深入探讨如何在SpringBoot应用中集成Redis集群以及如何配置Redis服务器。首先，Redis是一个开源的、基于键值对的数据存储系统，常用于数据库、缓存和消息中间件。它以其高性能和易用性而备受青睐。...
springboot整合redis集群零配置
07-28
首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、...
springboot整合redis,springboot连接redis集群
04-08
在Spring Boot框架中整合Redis和连接Redis集群是一项常见的任务，特别是在构建高性能、高并发的Web应用时。Redis是一个开源的、基于内存的数据结构存储系统，常被用作数据库、缓存和消息中间件。Spring Boot提供了对...
springboot-keepalive设置测试
03-26
springboot keepalive 服务端，客户端测试
Springboot+Redis 配置和使用
程序猿踩坑集锦
04-18 1303
pom.xml 引入redis 开启缓存 &lt;!-- redis --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-da...
springboot连接redis出现 java.io.IOException: 远程主机强迫关闭了一个现有的连接
u013008898的博客
03-12 4301
org.springframework.data.redis.RedisSystemException: Redis exception; nested exception is io.lettuce.core.RedisException: java.io.IOException: 远程主机强迫关闭了一个现有的连接。 at org.springframework.data.redis.connection.lettuce.LettuceExceptionConverter.convert(Lettuc.
SpringBoot 配置redis集群
热门推荐
TechnicianWang的博客
04-28 3万+
applcation.yml # redis 配置 redis: server: pattern: cluster nodes: 127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003,127.0.0.1:3004,127.0.0.1:3005 password: maxIdle: 8 minIdle: 4 maxTotal: 8 maxWaitMillis: 6000
springboot2.0 + redis集群配置
project_sun的博客
08-30 1754
因为项目中使用到了redis，并且是集群部署，之前做过单机版的redis整合，下面说一下redis集群的整合过程。
Spring Cache Redis缓存key生成策略
star_apple的博客
03-22 4545
今天有人问我为什么我之前使用spring cache redis时，redis里面的key是cacheName::cacheKey格式，而现在cacheName的前缀没了？下面我们来分析一下key的生成逻辑。 源码分析 Spring Boot应用启动时，会自动加载redis相关的配置。我们主要关注一下RedisCacheConfiguration类。该类会创建一个RedisCacheManager...
SpringBoot 2.x 整合 redis 做缓存并对每个缓存空间设置过期时间
qq_32814555的博客
06-28 8103
点击打开链接
springboot集成 redis分布式锁
07-30
- *1* *2* [springboot集成redis 分布式锁(redistemplate,lua,redisson)](https://blog.csdn.net/jun2571/article/details/130382023)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值