精华内容
下载资源
问答
  • SpringBoot 配置 Redis 连接池

    千次阅读 2021-12-13 09:49:38
    SpringBoot2.0默认采用 Lettuce 客户端来连接 Redis 服务 默认是不使用连接池的,只有配置 redis.lettuce.pool下的属性的时候才可以使用到redis连接池

    前言

    SpringBoot2.0默认采用 Lettuce 客户端来连接 Redis 服务
    默认是不使用连接池的,只有配置 redis.lettuce.pool下的属性的时候才可以使用到redis连接池

    版本说明

    • spring-boot-starter-data-redis:2.5.4
    • redis6.2.5
    • commons-pool2:2.8.1
      采用 Lettuce 使用连接池,要依赖commons-pool2

    pom 文件相关依赖

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

    配置文件

    • 单机
    spring:
      redis:
        host: 192.168.1.201
        port: 6379
        password: 123456
        timeout: 5000ms # 连接超时时间(毫秒)
        lettuce:
          pool:
            max-active: 20 # 连接池最大连接数(使用负值表示没有限制)
            max-idle: 10 # 连接池中的最大空闲连接
            min-idle: 5 # 连接池中的最小空闲连接
            max-wait: 5000ms # 连接池最大阻塞等待时间(使用负值表示没有限制)
    
    • 集群
    spring:
      redis:
        host: 192.168.1.26
        port: 7001
        password: 123456
        timeout: 5000ms # 连接超时时间(毫秒)
        cluster:
          nodes: 192.168.1.26:7001,192.168.1.26:7002,192.168.1.26:7003,192.168.1.26:7004,192.168.1.26:7005,192.168.1.26:7006
        lettuce:
          pool:
            max-active: 20 # 连接池最大连接数(使用负值表示没有限制)
            max-idle: 10 # 连接池中的最大空闲连接
            min-idle: 5 # 连接池中的最小空闲连接
            max-wait: 5000ms # 连接池最大阻塞等待时间(使用负值表示没有限制)
    

    配置过程中产生的疑惑

    问题1: 连接池是否生效?

    这里我用两种方式分别验证了一下

    • 分析 RedisTempalte 源码
    • 向 redis 中存个十万条数据 如果连接池生效,那存入的速度应该会更快

    分析 RedisTempalte 源码

    从 redisTemplate.opsForValue().set(key, value); 直接开始
    在这里插入图片描述
    看 execute() 方法
    在这里插入图片描述
    看 RedisConnectionFactory
    在这里插入图片描述
    没有配置连接池时
    在这里插入图片描述
    配置连接池后
    可以看到 clientConfiguration 多了 poolConfig 对象里面正是配置文件配置的相关参数
    在这里插入图片描述

    存数据测试速度

    插入 1 W 条数据
    配置了连接池 :
    在这里插入图片描述
    没配连接池 :
    在这里插入图片描述
    配置了连接池执行速度快了很多,连接池确实生效了

    没有配置连接池并且 timeout 太小 还很容易发生连接超时异常,会在执行中报错
    Unable to connect to Redis; nested exception is io.lettuce.core.RedisConnectionException

    2 W 条数据没全部插入
    在这里插入图片描述

    问题2: 连接池生效的前提下, 最小空闲连接是 5 ,redis 客户端的连接数为什么还是 1 呢?

    通过统计 redis 客户端的连接数发现项目启动后 redis 的连接数 + 1,如果说连接池配置生效的话,redis 的连接数 应该加连接池中的最小空闲连接数才对.

    统计客户端连接数

    lsof -i:6379 | awk -F '->' '{print $2}' | awk -F ':' '{print $1}' | awk '{sum[$1]+=1} END {for(k in sum) print k ":" sum[k]}' | sort -n -r -k 2 -t ':'
    

    Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server,多线程环境下非线程安全(即多个线程对一个连接实例操作,是线程不安全的),除非使用连接池,为每个Jedis实例增加物理连接。Lettuce基于Netty的连接实例(StatefulRedisConnection),可以在多个线程间并发访问,且线程安全,满足多线程环境下的并发访问(即多个线程公用一个连接实例,线程安全),同时它是可伸缩的设计,一个连接实例不够的情况也可以按需增加连接实例。

    在这里插入图片描述

    经测试发现,基于 Lettuce 连接 redis, 开始会先创建一个连接实例,当一个实例不够用了才会去创建新的连接实例直到数量达到 max-active,请求高峰过去后,会先维持最大空闲连接一段时间,之后逐渐减少至最小空闲连接

    展开全文
  • SpringBoot配置Redis哨兵模式        所谓哨兵模式,其实是一个伪集群,即便是在多个哨兵的情况下,哨兵监控的都是同一个主节点,也就是一主多从的模式。    &...

    SpringBoot配置Redis哨兵模式
           所谓哨兵模式,其实是一个伪集群,即便是在多个哨兵的情况下,哨兵监控的都是同一个主节点,也就是一主多从的模式。
           SpringBoot配置哨兵模式,只需要配置哨兵的IP和端口,不需要配置主从节点的信息,当主节点挂掉后,哨兵会自动完成主从切换,直接上代码

    @Configuration
    public class JedisPoolConfiguration {
        /**
         * jedis连接池配置
         * @return
         * @Bean  加载后,方法返回的对象作为bean,被放在IOC容器里
         */
        @Bean
        /*@ConfigurationProperties(prefix = "jedisPool")*/
        public JedisPoolConfig jedisPoolConfig(){
            System.out.println("配置类执行了");
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            return jedisPoolConfig;
        }
    
        @Bean
        public RedisSentinelConfiguration sentinelConfiguration(){
            RedisSentinelConfiguration sentinelConfiguration = new RedisSentinelConfiguration();
            Set<RedisNode> redisNodes = new HashSet<>();
            //ip和端口信息可以写在配置文件里
            RedisNode redisNode = new RedisNode("192.168.1.128",26379);
            RedisNode redisNode2 = new RedisNode("192.168.1.128",26380);
            RedisNode redisNode3 = new RedisNode("192.168.1.128",26381);
            redisNodes.add(redisNode);
            redisNodes.add(redisNode2);
            redisNodes.add(redisNode3);
            //setSentinels的参数类型是Iterable<RedisNode>,所以放有RedisNode的集合可以是实现Iterable接口的任意集合,使用list、set都可以
            sentinelConfiguration.setSentinels(redisNodes);
            //监控主节点的名称
            sentinelConfiguration.setMaster("mymaster");
            return sentinelConfiguration;
        }
    
        /**
         * 连接工厂配置信息,需要注入连接池配置信息
         * @param jedisPoolConfig
         * @return
         */
        @Bean
        public JedisConnectionFactory jedisConnectionFactory(RedisSentinelConfiguration redisSentinelConfiguration,JedisPoolConfig jedisPoolConfig){
            JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisSentinelConfiguration,jedisPoolConfig);
            return jedisConnectionFactory;
        }
    
        /**
         * 操作redis方法的对象,需要注入连接工厂,封装了操作redis的方法
         * @param jedisConnectionFactory
         * @return
         */
        @Bean
        public RedisTemplate<String,Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory){
            RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(jedisConnectionFactory);
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            //使用的时候再具体转换序列化方式,存取都需要
            redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
            return  redisTemplate;
        }
    
    }
    

    在其他业务代码中,注入redisTemplate,使用就可以了
    配置的过程中遇到几个问题,希望大家引以为戒:
    1.在这里插入图片描述
    连接不到哨兵,All sentinels down
    查了很多资料,有说是防火墙的问题,我把Linux服务器、window的服务器防火墙都关了,在windows上使用telnet也是通的,把 sentinel.conf文件中的bind也设置为了0.0.0.0,保护模式也关闭了protected-mode no,还是不行,最后检查了下代码,原来是装有哨兵节点信息的集合没有放到sentinelConfiguration中,也就是没写sentinelConfiguration.setSentinels(redisNodes);这段代码,真是气自己呀,重启后,项目正常运行,redis也可以正常使用。
    2.手动关闭主节点后,通过info replication查看其它节点信息,其中一个从节点成功切换为主节点,说明哨兵配置的是没有问题的,但是项目报错如下:

    Could not get a resource from the pool
    

    没有拿到redis连接,也就是redis不可用,很奇怪,从节点都成功切换为主节点了,哨兵怎么还是找不到主节点,查看了下哨兵的配置文件,发现监控的主节点IP地址变成了127.0.0.1,之前配置的是服务器的ip 192.168.1.128,重启哨兵,项目正常运行了,不知道这种问题是不是由于虚拟机的问题造成的

    3.建议每次重启哨兵的时候,将 sentinel.conf配置文件中

    Generated by CONFIG REWRITE
    

    被重写的这部分内容删除再重启。

    展开全文
  • 查找了一些后总结。 1.导包 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis<...2.配置...

    查找了一些后总结,个人食用。

    1.导包

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

    2.配置类RedisConfig

    @Configuration
    public class RedisConfig {
    
    
        @Autowired
        private RedisConnectionFactory connectionFactory;
    
        @Bean
        RedisMessageListenerContainer redisMessageListenerContainer() {
            RedisMessageListenerContainer container = new RedisMessageListenerContainer();
            container.setConnectionFactory(connectionFactory);
            //container.addMessageListener(new RedisExpiredListener(), new PatternTopic("__keyevent@0__:expired"));
            return container;
        }
    
        // 创建基本的key监听器
        /*  */
        @Bean
        public RedisKeyChangeListener redisKeyChangeListener() throws Exception {
            RedisKeyChangeListener listener = new RedisKeyChangeListener(redisMessageListenerContainer(),"");
            return listener;
        }
    }
    

    3.配置监听器

    /**
     * @description 期望是可以监听某个key的变化,而不是失效
     */
    public class RedisKeyChangeListener implements MessageListener/* extends KeyspaceEventMessageListener */ {
        private final String listenerKeyName; // 监听的key的名称
        private static final Topic TOPIC_ALL_KEYEVENTS = new PatternTopic("__keyevent@*"); //表示只监听所有的key
        private static final Topic TOPIC_KEYEVENTS_SET = new PatternTopic("__keyevent@0__:set"); //表示只监听所有的key
        private static final Topic TOPIC_KEYNAMESPACE_NAME = new PatternTopic("__keyspace@0__:myKey"); // 不生效
        // 监控
        //private static final Topic TOPIC_KEYEVENTS_NAME_SET_USELESS = new PatternTopic("__keyevent@0__:set myKey");
        private String keyspaceNotificationsConfigParameter = "KEA";
    
        public RedisKeyChangeListener(RedisMessageListenerContainer listenerContainer, String listenerKeyName) {
            this.listenerKeyName = listenerKeyName;
            initAndSetRedisConfig(listenerContainer);
        }
    
        public void initAndSetRedisConfig(RedisMessageListenerContainer listenerContainer) {
    
            if (StringUtils.hasText(keyspaceNotificationsConfigParameter)) {
    
                RedisConnection connection = listenerContainer.getConnectionFactory().getConnection();
    
                try {
    
                    Properties config = connection.getConfig("notify-keyspace-events");
    
                    if (!StringUtils.hasText(config.getProperty("notify-keyspace-events"))) {
                        connection.setConfig("notify-keyspace-events", keyspaceNotificationsConfigParameter);
                    }
    
                } finally {
                    connection.close();
                }
            }
            // 注册消息监听
            listenerContainer.addMessageListener(this, TOPIC_ALL_KEYEVENTS);
        }
    
        @Reference
        private UserInfoApi userInfoApi;
    
        @Reference
        private FreezeApi freezeApi;
    
        @Override
    
        public void onMessage(Message message, byte[] pattern) {
          
            String key = new String(message.getBody());
            String method = new String(message.getChannel());
            
                System.out.println(key + "----" + method);
    
        }
    }

    展开全文
  • redis哨兵集群配置 Sentinel(哨兵)是Redis 的高可用性解决方案:由一个或多个Sentinel 实例 组成的...springboot配置Redis主从服务 接下来学了一下springboot配置redis的主从服务器。根据一主二从三哨兵的原则来搭建

    redis哨兵集群配置

    Sentinel(哨兵)是Redis 的高可用性解决方案:由一个或多个Sentinel 实例 组成的Sentinel 系统可以监视任意多个主服务器,以及这些主服务器属下的所有从服务器,并在被监视的主服务器进入下线状态时,自动将下线主服务器属下的某个从服务器升级为新的主服务器。具体原理和配置参考《【带你重拾Redis】Redis 哨兵集群实现高可用》

    springboot配置Redis主从服务

    接下来学了一下springboot配置redis的主从服务器。根据一主二从三哨兵的原则来搭建一个分布式的缓存服务。

    application.properties文件

    新增node配置

    // 主从配置
    // name of Redis server  哨兵监听的Redis server的名称
    spring.redis.sentinel.master=mymaster
    // comma-separated list of host:port pairs  哨兵的配置列表
    spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:26378,127.0.0.1:26377
    

    RedisCacheConfig配置

    新增RedisSentinelConfiguration代码

    @Configuration
    @EnableAutoConfiguration
    @EnableCaching //加上这个注解是的支持缓存注解
    public class RedisCacheConfig extends CachingConfigurerSupport {
    
        @Value("${spring.redis.host}")
        private String host;
    
        @Value("${spring.redis.port}")
        private int port;
    
        @Value("${spring.redis.timeout}")
        private int timeout;
    
        @Value("${spring.redis.database}")
        private int database;
    
        @Value("${spring.redis.password}")
        private String password;
    
        @Value("${spring.redis.sentinel.nodes}")
        private String redisNodes;
    
        @Value("${spring.redis.sentinel.master}")
        private String master;
    
    
        /**
         * redis哨兵配置
         * @return
         */
        @Bean
        public RedisSentinelConfiguration redisSentinelConfiguration(){
            RedisSentinelConfiguration configuration = new RedisSentinelConfiguration();
            String[] host = redisNodes.split(",");
            for(String redisHost : host){
                String[] item = redisHost.split(":");
                String ip = item[0];
                String port = item[1];
                configuration.addSentinel(new RedisNode(ip, Integer.parseInt(port)));
            }
            configuration.setMaster(master);
            return configuration;
        }
    
        /**
         * 连接redis的工厂类
         *
         * @return
         */
        @Bean
        public JedisConnectionFactory jedisConnectionFactory() {
            JedisConnectionFactory factory = new JedisConnectionFactory(redisSentinelConfiguration());
            factory.setHostName(host);
            factory.setPort(port);
            factory.setTimeout(timeout);
            factory.setPassword(password);
            factory.setDatabase(database);
            return factory;
        }
    
        /**
         * 配置RedisTemplate
         * 设置添加序列化器
         * key 使用string序列化器
         * value 使用Json序列化器
         * 还有一种简答的设置方式,改变defaultSerializer对象的实现。
         *
         * @return
         */
        @Bean
        public RedisTemplate<Object, Object> redisTemplate() {
            //StringRedisTemplate的构造方法中默认设置了stringSerializer
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            //设置开启事务
            template.setEnableTransactionSupport(true);
            //set key serializer
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            template.setKeySerializer(stringRedisSerializer);
            template.setHashKeySerializer(stringRedisSerializer);
    
            template.setConnectionFactory(jedisConnectionFactory());
            template.afterPropertiesSet();
            return template;
        }
    
        /**
         * 设置RedisCacheManager
         * 使用cache注解管理redis缓存
         *
         * @return
         */
        @Override
        @Bean
        public RedisCacheManager cacheManager() {
            RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate());
            return redisCacheManager;
        }
    
        /**
         * 自定义生成redis-key
         *
         * @return
         */
        @Override
        public KeyGenerator keyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object o, Method method, Object... objects) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(o.getClass().getName()).append(".");
                    sb.append(method.getName()).append(".");
                    for (Object obj : objects) {
                        sb.append(obj.toString());
                    }
                    System.out.println("keyGenerator=" + sb.toString());
                    return sb.toString();
                }
            };
        }
    }
    
    展开全文
  • Redis 三大客户端 简介 Jedis:是Redis 老牌的Java实现客户端,提供了比较全面的Redis命令的支持, Redisson:实现了分布式和可扩展的Java数据结构。 Lettuce:高级Redis客户端,用于线程安全同步,异步和响应...
  • Springboot连接redis配置

    2021-09-25 17:23:30
    Springboot连接redis配置 application.properties #Redis服务器地址 spring.redis.host=192.168.233.128 #Redis服务器连接端口 spring.redis.port=6379 #Redis数据库索引(默认为0) spring.redis.database= 0 #设置...
  • pom.xml <dependency> <groupId>org.springframework.boot</groupId>...spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <.
  • redis集群版配置
  • Springboot整合redis配置详解 1.导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency&...
  • 戳这里免费下载 Java架构进阶面试及知识点文档笔记 这份文档共498页,其中包括Java集合,并发编程,JVM,Dubbo,Redis,Spring全家桶,MySQL,Kafka等面试解析及知识点整理 Java分布式高级面试问题解析文档 其中都是...
  • SpringBoot整合Redis

    2021-12-07 14:32:44
    SpringBoot整合Redis 实现步骤 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>...
  • spring boot中整合Redis非常简单,在pom.xml中添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &...
  • springboot整合redis

    千次阅读 2021-01-04 12:23:25
    这几天跟着王军伟老师在学习架构之路-...Redis技术栈目前广泛使用于开发领域,掌握Redis技术栈与Springboot的集成至关重要。Redis是目前业界使用最广泛的内存数据存储。相比memcached,Redis支持更丰富的数据结构,
  • springboot整合redis超级详解

    千次阅读 2020-12-30 02:27:29
    接下来正式实现整合,在springboot中使用redis 1,创建springboot项目 2,需要的依赖 jedis,同时需要使用下面的fastjson <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> <depen
  • java在springboot中连接redis需要以下操作。 1.测试类上需要加以下两个注解(随版本变动,很多视频教程都不加,也可以运行。) @RunWith(SpringRunner.class) @SpringBootTest(classes = MyMain.class) 不加Run...
  • springboot集成 redis配置 redis的优点就不多说了,大家都懂。下面直接进入实战。 1、集成的时候首先先导入jar包 <!-- spring boot redis缓存引入 --> <dependency> <groupId>org.spring...
  • Redis 是目前业界使用最广泛的内存数据存储。相比 Memcached,Redis 支持更丰富的数据结构,例如 hash, list, set等,同时支持数据持久化。除此之外,Redis 还提供一些类数据库的特性,比如事务,HA,主从库。可以说...
  • Springboot2.x默认导入了lettuce和jedis两种驱动:@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class}) LettuceConnectionConfiguration JedisConnectionConfiguration 我们从...
  • 1、springboot集成redis 2、修改配置文件,实现哨兵模式 #redis配置 redis: # Redis服务器连接密码 password: alone: # Redis服务器连接地址 host: 127.0.0.1 # Redis服务器连接端口 port: 6379 pool: max...
  • springBoot yml redis参考配置文件
  • 而且默认配置redis 的客户端只对 Master 读写,另外2个Slave闲置,在网上找了很久都是自己去获取Slave然后code写到slave的redisTemplate上。 下面就通过一个简单的配置,把写在Master,读在Slave。 当然你也可以...
  • 前面研究了SpringBoot整合Redis集群(Lettuce客户端),然后尝试玩玩读写分离,客户端使用Lettuce(SpringBoot2.x已经默认支持Lettuce了,就不再研究Jedis客户端了)。虽然最新版的Redis Cluster集群架构不推荐读写...
  • SpringBoot中整合Redis, 编写Redis配置类 import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import ...
  • springboot整合redis,推荐整合和使用案例(2021版)

    千次阅读 多人点赞 2021-01-05 20:09:34
    背景:手下新人在初次使用springboot整合redis,大部分人习惯从网上检索到一份配置,然后不知其所以然的复制粘贴到项目中,网上搜索到的配置良莠不齐但又万变不离其宗。由于springboot最大化地简化了整合redis需要的...
  • 一、JedisCluster方式(推荐) ...1、yml配置 spring: redis: password: clusterNodes: xxx.xx.xx:8001, xxx.xx.xx:8002 expireSeconds: 120 commandTimeout: 10000 #redis操作的超时时间 pool: maxAc...
  • 一、引入依赖 <!--fastjson 依赖--> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson<...--Spring boot Redis 依赖--> <dependency>
  • springboot 整合redis

    2021-11-04 20:50:05
    配置redis相关属性。 注入RedisTemplate模板。 编写测试方法。 搭建SpringBoot工程 起步依赖 pom文件中默认就添加了 <dependency> <groupId>org.springframework.boot</groupId> <...
  • springboot项目中使用redis是很常见的业务场景,今天我们分享一下boot项目中,redis的连接配置、序列化等。 1、引入jar <parent> <groupId>org.springframework.boot</groupId> <...
  • Spring Boot中除了对常用的关系型数据库提供了优秀的自动化支持之外,对于很多NoSQL数据库一样提供了自动化配置的支持,包括:Redis, MongoDB, Elasticsearch, Solr和Cassandra。 Redis是一个开源的使用ANSI C语言...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 67,087
精华内容 26,834
关键字:

springboot配置redis

redis 订阅
spring 订阅