精华内容
下载资源
问答
  • Redis服务器连接端口 password: # Redis服务器连接密码(默认为空) timeout: 5000 # 连接超时时间(毫秒) jedis: pool: max-active: 300 max-idle: 100 min-idle: 0 max-wait: -1ms 总的来说是放弃了Lettuce ,...

    原先配置是使用默认Lettuce。后来在生产环境发现会经常的超时,导致缓存不可用,而且一超时就不恢复。

    后来查了些资料,网上都有这个问题,无解,都建议使用jedis。

     

    先看下原来的配置,maven配置(项目其他配置已省略)

    <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>2.0.0.RELEASE</version>
    </parent>
    
    <dependency>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-starter-redis</artifactId>
    				<version>2.0.0.RELEASE</version>
    			</dependency>
    <dependency>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-starter-data-redis</artifactId>
    				<version>2.0.0.RELEASE</version>
    				<exclusions>
    					<exclusion>
    						<groupId>redis.clients</groupId>
    						<artifactId>jedis</artifactId>
    					</exclusion>
    				</exclusions>
    			</dependency>

    application.yml配置:

    spring:
       redis:
          database: 15 # Redis数据库索引(默认为0)
          host: 10.10.10.43 # Redis服务器地址
          port: 6379 # Redis服务器连接端口
          password: # Redis服务器连接密码(默认为空)
          timeout: 5000 # 连接超时时间(毫秒)
          pool:
           max-active: 8 # 连接池最大连接数(使用负值表示没有限制)
           max-wait: -1 # 连接池最大阻塞等待时间(使用负值表示没有限制)
           max-idle: 8 # 连接池中的最大空闲连接
           min-idle: 0 # 连接池中的最小空闲连接
    

    会一直报错org.springframework.dao.QueryTimeoutException: Redis command timed out; nested exception is io.lettuce.core.RedisCommandTimeoutException: Command timed out after 500 millisecond(s)。

    后来改配置,maven如下:

    <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>2.0.0.RELEASE</version>
    </parent>
    
    <dependency>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-starter-redis</artifactId>
    				<version>2.0.0.RELEASE</version>
    			</dependency>
    <dependency>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-starter-data-redis</artifactId>
    				<version>2.0.0.RELEASE</version>
    				<exclusions>
    					<!-- <exclusion> 
                                <groupId>redis.clients</groupId> 
                                <artifactId>jedis</artifactId> 
    						</exclusion> -->
    					<exclusion>
    						<groupId>io.lettuce</groupId>
    						<artifactId>lettuce-core</artifactId>
    					</exclusion>
    				</exclusions>
    			</dependency>
    <dependency>
    				<groupId>redis.clients</groupId>
    				<artifactId>jedis</artifactId>
    				<version>2.9.0</version>
    			</dependency>

    application.yml配置:

    spring:
       redis:
          database: 15 # Redis数据库索引(默认为0)
          host: 10.10.10.43 # Redis服务器地址
          port: 6379 # Redis服务器连接端口
          password: # Redis服务器连接密码(默认为空)
          timeout: 5000 # 连接超时时间(毫秒)
          jedis:
                pool:
                    max-active: 300
                    max-idle: 100
                    min-idle: 0
                    max-wait: -1ms
    

     

    总的来说是放弃了Lettuce ,使用jedis,问题能够得到解决。

    相关问题链接:https://stackoverflow.com/questions/55629324/spring-boot-stringredistemplate-error-redis-command-timed-out-using-lettuce

    展开全文
  • 使用到Lettuce连接redis,一段时间后不操作,再去操作redis,会报连接超时错误,在其重连后又可使用。 原因是:Lettuce 自适应拓扑刷新(Adaptive updates)与定时拓扑刷新(Periodic updates) 是默认关闭的导致...

    1. 问题

    使用到Lettuce连接redis,一段时间后不操作,再去操作redis,会报连接超时错误,在其重连后又可使用。

    原因是:Lettuce 自适应拓扑刷新(Adaptive updates)与定时拓扑刷新(Periodic updates) 是默认关闭的导致问题的出现

    2. 解决的方案

    2.1 推荐

    1、定时任务

    @Component
    @Slf4j
    public class LettuceConnectionValidTask   {
        @Autowired
        private RedisConnectionFactory redisConnectionFactory;
    
        @Scheduled(cron="0/2 * * * * ?")
        public void task() {
            if(redisConnectionFactory instanceof LettuceConnectionFactory){
                LettuceConnectionFactory c=(LettuceConnectionFactory)redisConnectionFactory;
                c.validateConnection();
            }
        }
    }
    

    2、lettuce提供了校验连接的方法,lettuce提供了校验连接的方法  只是默认没开启  开启的话是每次获取连接都会校验。开启获取连接的校验

    @Component
    @Slf4j
    public class LettuceConnectionValidConfig implements InitializingBean {
        @Autowired
        private RedisConnectionFactory redisConnectionFactory;
    
        @Override
        public void afterPropertiesSet() throws Exception {
            if(redisConnectionFactory instanceof LettuceConnectionFactory){
                LettuceConnectionFactory c=(LettuceConnectionFactory)redisConnectionFactory;
                c.setValidateConnection(true);
            }
        }
    }
    

    2.2 不推荐

    1、重写连接工厂实例,更改其LettuceClientConfiguration 为开启拓扑更新

    @Configuration
    public class RedisConfig {
    
    
        @Autowired
        private RedisProperties redisProperties;
    
        //这是固定的模板
        //自己定义了一个RedisTemplate
        @Bean
        @SuppressWarnings("all")
        public RedisTemplate<String, Object> redisTemplate(@Qualifier("lettuceConnectionFactoryUvPv") RedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(factory);
    
            //Json序列化配置
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.activateDefaultTyping(om.getPolymorphicTypeValidator());
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            //解决序列化问题
            om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            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;
        }
    
        /**
         * 为RedisTemplate配置Redis连接工厂实现
         * LettuceConnectionFactory实现了RedisConnectionFactory接口
         * UVPV用Redis
         *
         * @return 返回LettuceConnectionFactory
         */
        @Bean(destroyMethod = "destroy")
        //这里要注意的是,在构建LettuceConnectionFactory 时,如果不使用内置的destroyMethod,可能会导致Redis连接早于其它Bean被销毁
        public LettuceConnectionFactory lettuceConnectionFactoryUvPv() throws Exception {
    
            List<String> clusterNodes = redisProperties.getCluster().getNodes();
            Set<RedisNode> nodes = new HashSet<>();
            clusterNodes.forEach(address -> nodes.add(new RedisNode(address.split(":")[0].trim(), Integer.parseInt(address.split(":")[1]))));
            RedisClusterConfiguration clusterConfiguration = new RedisClusterConfiguration();
            clusterConfiguration.setClusterNodes(nodes);
            clusterConfiguration.setPassword(RedisPassword.of(redisProperties.getPassword()));
            clusterConfiguration.setMaxRedirects(redisProperties.getCluster().getMaxRedirects());
    
    
            RedisStandaloneConfiguration  redisStandaloneConfiguration=new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setHostName(redisProperties.getHost());
            redisStandaloneConfiguration.setPassword(redisProperties.getPassword());
            redisStandaloneConfiguration.setDatabase(redisProperties.getDatabase());
            redisStandaloneConfiguration.setPort(redisProperties.getPort());
    
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
            poolConfig.setMaxIdle(redisProperties.getLettuce().getPool().getMaxIdle());
            poolConfig.setMinIdle(redisProperties.getLettuce().getPool().getMinIdle());
            poolConfig.setMaxTotal(redisProperties.getLettuce().getPool().getMaxActive());
    
            return new LettuceConnectionFactory(redisStandaloneConfiguration, getLettuceClientConfiguration(poolConfig));
        }
    
        /**
         * 配置LettuceClientConfiguration 包括线程池配置和安全项配置
         *
         * @param genericObjectPoolConfig common-pool2线程池
         * @return lettuceClientConfiguration
         */
        private LettuceClientConfiguration getLettuceClientConfiguration(GenericObjectPoolConfig genericObjectPoolConfig) {
            /*
            ClusterTopologyRefreshOptions配置用于开启自适应刷新和定时刷新。如自适应刷新不开启,Redis集群变更时将会导致连接异常!
             */
            ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                    //开启自适应刷新
                    //.enableAdaptiveRefreshTrigger(ClusterTopologyRefreshOptions.RefreshTrigger.MOVED_REDIRECT, ClusterTopologyRefreshOptions.RefreshTrigger.PERSISTENT_RECONNECTS)
                    //开启所有自适应刷新,MOVED,ASK,PERSISTENT都会触发
                    .enableAllAdaptiveRefreshTriggers()
                    // 自适应刷新超时时间(默认30秒)
                    .adaptiveRefreshTriggersTimeout(Duration.ofSeconds(25)) //默认关闭开启后时间为30秒
                    // 开周期刷新
                    .enablePeriodicRefresh(Duration.ofSeconds(20))  // 默认关闭开启后时间为60秒 ClusterTopologyRefreshOptions.DEFAULT_REFRESH_PERIOD 60  .enablePeriodicRefresh(Duration.ofSeconds(2)) = .enablePeriodicRefresh().refreshPeriod(Duration.ofSeconds(2))
                    .build();
            return LettucePoolingClientConfiguration.builder()
                    .poolConfig(genericObjectPoolConfig)
                    .clientOptions(ClusterClientOptions.builder().topologyRefreshOptions(topologyRefreshOptions).build())
                    //将appID传入连接,方便Redis监控中查看
                    //.clientName(appName + "_lettuce")
                    .build();
        }
    
    }

    2、SpringBoot2.3.x后,可使用配置文件中开启lettuce的拓扑刷新

        lettuce:
          pool:
            max-active: 20
            max-wait: -1ms
            max-idle: 10
            min-idle: 2
          cluster:
            refresh:
              adaptive: true
              #20秒自动刷新一次
              period: 20

    3、更改连接redis的连接方式,使用jedis连接

            <dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    			<exclusions>
    				<exclusion>
    					<groupId>io.lettuce</groupId>
    					<artifactId>lettuce-core</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    		
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    		</dependency>
    spring:
      redis:
        jedis:
          pool:
            max-active: ${redis.config.maxTotal:1024}
            max-idle: ${redis.config.maxIdle:50}
            min-idle: ${redis.config.minIdle:1}
            max-wait: ${redis.config.maxWaitMillis:5000}
        #lettuce:
          #pool:
            #max-active: ${redis.config.maxTotal:1024}
            #max-idle: ${redis.config.maxIdle:50}
            #min-idle: ${redis.config.minIdle:1}
            #max-wait: ${redis.config.maxWaitMillis:5000}
    
    展开全文
  • 频繁FullGC导致Lettuce客户端访问redis时出现命令超时

    频繁FullGC导致Lettuce客户端访问redis时出现命令超时

    Caused by: io.lettuce.core.RedisCommandTimeoutException: Command timed out after 10 second(s) 
    at io.lettuce.core.ExceptionFactory.createTimeoutException(ExceptionFactory.java:51) 
    at io.lettuce.core.LettuceFutures.awaitOrCancel(LettuceFutures.java:119) 
    at io.lettuce.core.cluster.ClusterFutureSyncInvocationHandler.handleInvocation(ClusterFutureSyncInvocationHandler.java:131) 
    at io.lettuce.core.internal.AbstractInvocationHandler.invoke(AbstractInvocationHandler.java:79) 
    at com.sun.proxy.$Proxy292.exists(Unknown Source) 
    at org.springframework.data.redis.connection.lettuce.LettuceKeyCommands.exists(LettuceKeyCommands.java:78) 
    ... 27 more 
    

    在这里插入图片描述

    展开全文
  • import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer....

    依赖的jar包:

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

    RedisTemplate默认提供的序列化器

    RedisSerializer redis序列化的接口类

    OxmSerializer xml到object的序列化/反序列化

    StringRedisSerializer string字符串的序列化/反序列化

    JacksonJsonRedisSerializer json到object的序列化/反序列化

    Jackson2JsonRedisSerializer json到object的序列化/反序列化

    JdkSerializationRedisSerializer java对象的序列化/反序列化

    JAVA code:
    配置文件:存放位置properties/redis.properties

    # Redis settings
    spring.redis.database=0
    spring.redis.host=127.0.0.1
    spring.redis.port=6379
    spring.redis.password=
    spring.redis.ssl=false
    #客户端超时时间单位是毫秒 默认是2000
    spring.redis.connTimeout=10000
    spring.redis.CachingTime=900
    #spring.redis.url=spring.redis://spring.redis_6379@111.231.203.94:6379/2
    
    #最大空闲数
    spring.redis.maxIdle=300
    #最小空闲数
    spring.redis.minIdle=1
    #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用spring.redis.maxTotal
    spring.redis.maxActive=600
    spring.redis.maxWait=2
    #控制一个pool可分配多少个jedis实例,用来替换上面的spring.redis.maxActive,如果是jedis 2.4以后用该属性
    spring.redis.maxTotal=1000
    #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
    spring.redis.maxWaitMillis=3000
    #连接的最小空闲时间 默认1800000毫秒(30分钟)
    spring.redis.minEvictableIdleTimeMillis=300000
    #每次释放连接的最大数目,默认3
    spring.redis.numTestsPerEvictionRun=1024
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
    spring.redis.timeBetweenEvictionRunsMillis=30000
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    spring.redis.testOnBorrow=true
    #返回性校验
    spring.redis.testOnReturn=true
    #在空闲时检查有效性, 默认false
    spring.redis.testWhileIdle=true
    

    RedisProperties配置类:

    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    
    @Component
    @Data
    @PropertySource(value= {"classpath:properties/redis.properties"})
    @ConfigurationProperties(prefix = "spring.redis")
    public class RedisProperties {
    
        private static final String PROPERTIES_FILE = "application.properties";
    
        /**
         * spring.redis.database=0
         * spring.redis.host=192.168.33.200
         * spring.redis.port=6379
         * spring.redis.ssl=false
         * spring.redis.password=123456
         * spring.redis.connTimeout=5000ms
         * spring.redis.maxActive=500
         * spring.redis.maxIdle=10
         * spring.redis.minIdle=0
         * spring.redis.maxWait=5000ms
         * */
        private Integer database;
        private String host;
        private Integer port;
        private Boolean ssl;
        private String password;
        private Long connTimeout;
        private Integer maxActive;
        private Integer maxIdle;
        private Integer minIdle;
        private Integer maxWait;
    }
    

    RedisConfig配置类:

    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.myself.platform.properties.RedisProperties;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.EnableCaching;
    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.RedisPassword;
    import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
    import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
    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;
    
    import java.time.Duration;
    
    /**
     * Created by qxr4383 on 2018/12/27.
     */
    @Configuration
    @EnableCaching
    public class RedisConfig {
    
        @Autowired
        private RedisProperties redisProperties;
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
            //设置序列化
            //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值(默认使用JDK的序列化方式)
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            //指定要序列化的域,field,get和set,以及修饰符范围,ANY是都有包括private和public
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            //配置redisTemplate
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            // 配置连接工厂
            redisTemplate.setConnectionFactory(lettuceConnectionFactory);
            RedisSerializer stringSerializer = new StringRedisSerializer();
            redisTemplate.setKeySerializer(stringSerializer);//key序列化
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);//value序列化
            redisTemplate.setHashKeySerializer(stringSerializer);//Hash key序列化
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);//Hash value序列化
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
        @Bean
        public LettuceConnectionFactory lettuceConnectionFactory(GenericObjectPoolConfig genericObjectPoolConfig) {
            // 单机版配置
            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setDatabase(redisProperties.getDatabase()==null ? 0 : redisProperties.getDatabase());
            redisStandaloneConfiguration.setHostName(redisProperties.getHost());
            redisStandaloneConfiguration.setPort(redisProperties.getPort());
            redisStandaloneConfiguration.setPassword(RedisPassword.of(redisProperties.getPassword()));
           // 集群版配置
    //        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
    //        String[] serverArray = clusterNodes.split(",");
    //        Set<RedisNode> nodes = new HashSet<RedisNode>();
    //        for (String ipPort : serverArray) {
    //            String[] ipAndPort = ipPort.split(":");
    //            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
    //        }
    //        redisClusterConfiguration.setPassword(RedisPassword.of(password));
    //        redisClusterConfiguration.setClusterNodes(nodes);
    //        redisClusterConfiguration.setMaxRedirects(maxRedirects);
            LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                    .commandTimeout(Duration.ofMillis(redisProperties.getConnTimeout()))
                    .poolConfig(genericObjectPoolConfig)
                    .build();
            if (redisProperties.getSsl()){
                clientConfig.isUseSsl();
            }
            LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration,clientConfig);
            return factory;
        }
    
        /**
         * GenericObjectPoolConfig 连接池配置
         *
         * @return
         */
        @Bean
        public GenericObjectPoolConfig genericObjectPoolConfig() {
            GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
            genericObjectPoolConfig.setMaxIdle(redisProperties.getMaxIdle());
            genericObjectPoolConfig.setMinIdle(redisProperties.getMinIdle());
            genericObjectPoolConfig.setMaxTotal(redisProperties.getMaxActive());
            genericObjectPoolConfig.setMaxWaitMillis(redisProperties.getMaxWait());
            return genericObjectPoolConfig;
        }
    
        @Bean
        public CacheManager cacheManager(LettuceConnectionFactory lettuceConnectionFactory) {
            RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
                    .RedisCacheManagerBuilder
                    .fromConnectionFactory(lettuceConnectionFactory);
            return builder.build();
        }
    }
    

    redis工具接口类:

    import java.util.List;
    import java.util.Set;
    
    public interface RedisService {
    
        boolean set(String key, Object value);
    
        boolean set(String key, Object value, Long expireTime);
    
        void remove(String... keys);
    
        /**
         * 批量删除key
         * @param pattern
         */
        void removePattern(String pattern);
    
        /**
         * 删除对应的value
         * @param key
         */
        void remove(String key);
        /**
         * 判断缓存中是否有对应的value
         * @param key
         * @return
         */
        boolean exists(String key);
    
        /**
         * 读取缓存
         * @param key
         * @return
         */
        Object get(String key);
        /**
         * 哈希 添加
         * @param key
         * @param hashKey
         * @param value
         */
        void hmSet(String key, Object hashKey, Object value);
    
        /**
         * 哈希获取数据
         * @param key
         * @param hashKey
         * @return
         */
        Object hmGet(String key, Object hashKey);
    
        /**
         * 列表添加
         * @param k
         * @param v
         */
        void lPush(String k, Object v);
    
        /**
         * 列表获取
         * @param k
         * @param l
         * @param l1
         * @return
         */
        List<Object> lRange(String k, long l, long l1);
    
        /**
         * 集合添加
         * @param key
         * @param value
         */
        void setArray(String key, Object value);
    
        /**
         * 集合获取
         * @param key
         * @return
         */
        Set<Object> getArray(String key);
    
        /**
         * 有序集合添加
         * @param key
         * @param value
         * @param scoure
         */
        void zAdd(String key, Object value, double scoure);
    
        /**
         * 有序集合获取
         * @param key
         * @param scoure
         * @param scoure1
         * @return
         */
        Set<Object> rangeByScore(String key, double scoure, double scoure1);
    
    }
    

    redis接口实现类:

    import com.myself.platform.service.RedisService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.*;
    import org.springframework.stereotype.Service;
    
    import java.io.Serializable;
    import java.util.List;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    @Service
    public class RedisServiceImpl implements RedisService {
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        /**
         * 写入缓存
         * @param key
         * @param value
         * @return boolean
         */
        @Override
        public boolean set(String key, Object value) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 写入缓存设置时效时间
         * @param key
         * @param value
         * @return boolean
         */
        @Override
        public boolean set(String key, Object value, Long expireTime) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 批量删除对应的value
         * @param keys
         */
        @Override
        public void remove(String... keys) {
            for (String key : keys) {
                remove(key);
            }
        }
    
        /**
         * 批量删除key
         * @param pattern
         */
        @Override
        public void removePattern(String pattern) {
            Set<Serializable> keys = redisTemplate.keys(pattern);
            if (keys.size() > 0)
                redisTemplate.delete(keys);
        }
    
        /**
         * 删除对应的value
         * @param key
         */
        @Override
        public void remove(String key) {
            if (exists(key)) {
                redisTemplate.delete(key);
            }
        }
    
        /**
         * 判断缓存中是否有对应的value
         * @param key
         * @return
         */
        @Override
        public boolean exists(String key) {
            return redisTemplate.hasKey(key);
        }
    
        /**
         * 读取缓存
         * @param key
         * @return
         */
        @Override
        public Object get(String key) {
            Object result = null;
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.get(key);
            return result;
        }
        /**
         * 哈希 添加
         * @param key
         * @param hashKey
         * @param value
         */
        @Override
        public void hmSet(String key, Object hashKey, Object value){
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            hash.put(key,hashKey,value);
        }
    
        /**
         * 哈希获取数据
         * @param key
         * @param hashKey
         * @return
         */
        @Override
        public Object hmGet(String key, Object hashKey){
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            return hash.get(key,hashKey);
        }
    
        /**
         * 列表添加
         * @param k
         * @param v
         */
        @Override
        public void lPush(String k,Object v){
            ListOperations<String, Object> list = redisTemplate.opsForList();
            list.rightPush(k,v);
        }
    
        /**
         * 列表获取
         * @param k
         * @param l
         * @param l1
         * @return
         */
        @Override
        public List<Object> lRange(String k, long l, long l1){
            ListOperations<String, Object> list = redisTemplate.opsForList();
            return list.range(k,l,l1);
        }
    
        /**
         * 集合添加
         * @param key
         * @param value
         */
        @Override
        public void setArray(String key,Object value){
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            set.add(key,value);
        }
    
        /**
         * 集合获取
         * @param key
         * @return
         */
        @Override
        public Set<Object> getArray(String key){
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            return set.members(key);
        }
    
        /**
         * 有序集合添加
         * @param key
         * @param value
         * @param scoure
         */
        @Override
        public void zAdd(String key,Object value,double scoure){
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            zset.add(key,value,scoure);
        }
    
        /**
         * 有序集合获取
         * @param key
         * @param scoure
         * @param scoure1
         * @return
         */
        @Override
        public Set<Object> rangeByScore(String key,double scoure,double scoure1){
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            return zset.rangeByScore(key, scoure, scoure1);
        }
    
    }
    

    测试类:

        @Autowired
        private RedisService redisService;
        
        public String getProperties(){
            redisService.set("3213", 1213,900l);
        }
    
    展开全文
  • 问题描述 最近线上的程序经常报错,redis command timed out 报错信息如下 org.springframework.dao.QueryTimeoutException: ...nested exception is io.lettuce.core.RedisCommandTimeoutException: Command ti...
  • SpringBoot整合Lettuce Redis

    千次阅读 2019-05-30 14:46:13
    Redis介绍 Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。相比Memcached它支持存储的类型相对更多(字符、哈希、集合、有序集合、列表、...
  • 整合Lettuce Redis

    2019-12-16 10:56:40
    导入依赖 在pom.xml中spring-boot-starter-data-redis的依赖,Spring Boot2.x后底层不在是Jedis如果做版本升级的朋友需要注意下 <dependency> <groupId>org.springframe...
  • SpringBoot 2.x 整合Lettuce Redis

    千次阅读 2019-05-16 10:39:37
    SpringBoot 2.x 整合Lettuce Redis Spring Boot2.x的到来,支持的组件越来越丰富,也越来越成熟,其中对Redis的支持不仅仅是丰富了它的API,更是替换掉底层Jedis的依赖,取而代之换成了Lettuce Lettuce 和 Jedis的...
  • Springboot连接Redis超时问题解决

    千次阅读 2021-02-22 17:01:12
    在使用Springcloud整合Redis作为缓存时,一段时间不去操作,再次刷新会出现连接超时的问题,具体如下: io.lettuce.core.RedisCommandTimeoutException: Command timed out after 5 second(s) 二、原因 springboot 2...
  • redis lettuce 调优

    2021-07-23 18:23:03
    合理的参数设置可以为你的redis客户端保驾护航,下面将对lettuce使用的一些重要参数进行说明和建议 序号 参数名 含义 默认值 使用建议 序号 ...
  • Slave + Sentinel+ Lettuce 二主从复制(Master& Slave)作用同步过程/ 复制原理具体过程如下:Redis配置基本参数RDB持久化相关参数REPLICATION(复制/主从同步)相关参数SECURITY(安全)相关参数AOF(Append Only ...
  • redis lettuce 经过13个月的开发阶段和208张已解决的故障单,我很高兴宣布Lettuce 5.0全面上市。 这是一个主要发行版,带有一些重大更改,新的有趣功能以及Java 9兼容性。 从Maven Central获取发行版 <...
  • 通过 Lettuce 来操作 Redis

    千次阅读 2019-12-22 21:38:07
    Java 操作 Redis 的库有两个,Jedis 和 Lettuce,目前 SpringBoot 2.x 中已经将 Jedis 换成了 Lettuce,让我们一起来看看这个东西。 Redis介绍 Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可...
  • 经过几天各种方案的对比及实验,终于完成了Springboot集成Lettuce完成Redis cluster集群的key过期监控的代码,主要参考了如下的文章及代码: https://my.oschina.net/u/4134799/blog/3116221/print ...
  • 背景:最近在对一新开发Springboot系统做压测,发现刚开始压测时,可以正常对redis集群进行数据存取,但是暂停几分钟后,接着继续用jmeter进行压测时,发现redis就开始突然疯狂爆出异常提示:Command timed out ...
  • SpringBoot 使用 Redis(lettuce) 分布式锁

    千次阅读 2020-09-01 15:25:39
    在分布式的集群环境下,如何保证某个代码片段只能一个节点来执行,以下的Redis的分布式锁就是其中一个实现方式。
  • 在springboot中使用lettuce来连接redis

    千次阅读 2020-03-01 17:39:28
    一.搭建一个项目 选中spring initializr 设置好项目名和包名后next 设置要用的jar包,然后next,finish ...--默认使用的是lettuce--> <dependency> <groupId>org.springframe...
  • Redis高级客户端Lettuce详解

    千次阅读 多人点赞 2020-12-12 09:55:01
    Lettuce是一个Redis的Java驱动包,初识她的时候是使用RedisTemplate的时候遇到点问题Debug到底层的一些源码,发现spring-data-redis的驱动包在某个版本以后替换为LettuceLettuce翻译为生菜,没错,就是吃的那种...
  • springboot lettuce 超时

    2019-07-26 17:37:47
    nested exception is io.lettuce.core.RedisCommandTimeoutException: io.lettuce.core.RedisCommandTimeoutException: Command timed out after 6 second(s) 2、配置 ``` <groupId>org.springframework....
  • 解决方案:lettuce提供了校验连接的方法,lettuce提供了校验连接的方法 只是默认没开启 开启的话是每次获取连接都会校验。可以定时校验来解决 或者开启获取连接的校验 1.定时校验来解决 /** * 每隔2秒校验异常...
  • Spring Boot中使用Lettuce连接Redis

    千次阅读 2019-05-20 17:10:37
    一、Redis的使用 关于Redis的使用和介绍,可以查看Redis中文网。 1、使用Docker安装 在Docker Hub中搜索Redis,获得镜像的安装方式 docker pull redis docker默认安装最新版本(latest),如果需要选择版本,为:...
  • 利用redis这两种场景的消息队列都能够实现。 定义: 生产者消费者模式:生产者生产消息放到队列里,多个消费者同时监听队列,谁先抢到消息谁就会从队列中取走消息;即对于每个消息只能被最多一个消费者拥有。 ​ ...
  • 记一次项目部署redis错误,仅供参考 背景:linux上部署Java项目,使用redis 问题:访问Java接口,redis报错 "exception": "org.springframework.dao.... nested exception is io.lettuce.core.RedisCo
  • Spring Boot Redis配置(默认Lettuce

    千次阅读 2020-09-21 17:47:41
    参考 https://lettuce.io/core/release/reference/index.html#redis-cluster.refreshing-the-cluster-topology-view 5.3.4. Refreshing the cluster topology view
  • springboot项目中redis连接超时问题

    千次阅读 2020-03-30 10:03:34
    将项目在本地运行,测试同样的接口,想着控制台可能会提示不同的错误,发现控制台报了redis的IO异常,以及其他相关错误,确认不是HikariPool连接池相关问题,从而转入到redis 的问题排查。 第一阶段参考:...
  • 解决阿里云服务器redis连接超时

    千次阅读 2021-10-23 11:13:53
    SpringBoot项目部署到linux,需要使用服务器本机的redis(自己写的一个小网站),阿里云开放redis 6379端口、redis配置也没问题,但是连接不上 问题描述 io.lettuce.core.RedisCommandTimeoutException: Command ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,559
精华内容 1,423
关键字:

lettuceredis超时

redis 订阅