精华内容
下载资源
问答
  • lettuce

    2020-02-28 15:05:50
    java代码操作Redis,需要使用...现在使用RedisTemplate对redis的命令进行了进一步封装 (lettuce),提供了模板类 1. 基本配置 添加依赖 <!--默认是lettuce客户端--> <dependency> <groupId>org....

    java代码操作Redis,需要使用Jedis,也就是redis支持java的第三方类库
    注意:Jedis2.7以上的版本才支持集群操作

    Spring data 提供了RedisTemplate模版
    它封装了redis连接池管理的逻辑,业务代码无须关心获取,释放连接逻辑;spring redis同时支持了Jedis,Jredis,rjc 客户端操作;
    在RedisTemplate中提供了几个常用的接口方法的使用,分别是
    在这里插入图片描述
    在这里插入图片描述

    1. 基本配置

    添加依赖

    <!--默认是lettuce客户端-->
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- redis依赖commons-pool 这个依赖一定要添加 不添加可能会丢失资源 --> 
    <dependency>
    	<groupId>org.apache.commons</groupId>
    	<artifactId>commons-pool2</artifactId>
    </dependency>
    

    application.yml

    spring:
      redis:
        port: 6379
        host: localhost
        lettuce:
          pool:
            max-active: 10 #连接池的最大连接数
            max-idle: 6 # 连接池的最大空闲连接数
            min-idle: 2 # 连接池的最小空闲连接数
    

    配置类

    通过配置类配置RedisTemplate并自定义其序列化机制,把配置好的RedisTemplate注入到spring进行使用

    @Configuration
    public class RedisConfig extends CachingConfigurerSupport {
        /**    
         * 自定义缓存key的生成策略。默认的生成策略是看不懂的(乱码内容) 通过Spring 的依赖注入特性进行自定义的 配置注入并且此类是一个配置类可以更多程度的自定义配置    
         * @return    
         */
    
        @Bean
        @Override
        public KeyGenerator keyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) {
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    
        /**
         * 缓存配置管理器    
         */
        @Bean
        public CacheManager cacheManager(LettuceConnectionFactory factory) {
            //以锁写入的方式创建RedisCacheWriter对象      
            RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
            //创建默认缓存配置对象        
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
            RedisCacheManager cacheManager = new RedisCacheManager(writer, config);
            return cacheManager;
        }
    
    	//拿到redisTemplate
        @Bean
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            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();
            // 在使用注解@Bean返回RedisTemplate的时候,同时配置hashKey与hashValue的序列化方式
            // key采用String的序列化方式         
            template.setKeySerializer(stringRedisSerializer);
            //value序列化方式采用jackson  
            template.setValueSerializer(jackson2JsonRedisSerializer);
            // hash的key也采用String的序列化方式        
            template.setHashKeySerializer(stringRedisSerializer);
            // hash的value序列化方式采用jackson      
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
            return template;
        }
    }
    

    大家可以看到在redisTemplate()这个方法中用JacksonJsonRedisSerializer更换掉了Redis默认的序列化方 式:JdkSerializationRedisSerializer

    spring-data-redis中序列化类有以下几个:

    **GenericToStringSerializer:**可以将任何对象泛化为字符串并序列化

    **Jackson2JsonRedisSerializer:**序列化 Object对象为json字符创(与JacksonJsonRedisSerializer相同)

    JacksonJsonRedisSerializer序列化,被序列化对象不需要实现Serializable接口,被序列化的结果清晰,容易阅 读,而且存储字节少,速度快
    存储内容如下:
    “{“userName”:“guoweixin”,“age”:20}”

    **JdkSerializationRedisSerializer:**序列化java 对象

    JdkSerializationRedisSerializer序列化被序列化对象必须实现Serializable接口,被序列化除属性内容还有其他 内容,长度长且不易阅读,默认就是采用这种序列化方式
    存储内容如下:
    “\xac\xed\x00\x05sr\x00!com.oreilly.springdata.redis.User\xb1\x1c \n\xcd\xed%\xd8\x02\x00\x02I\x00\x03ageL\x00\buserNamet\x00\x12Ljava/lang/String;xp\x00\x00\x00\ x14t\x00\x05user1”

    **StringRedisSerializer:**简单的字符串序列化

    一般如果key、value都是string字符串的话,就是用这个就可以了

    2. 基本使用

     /**
         *
         * @param id
         * @return
         *
         * 根据ID查询用户对象的信息
         * 先查询redis中是否存在
         * 不存在再去数据库查 存入redis
         */
        public com.minifull.po.User selectById(String id){
            User user = new User();
            if (redisTemplate.opsForHash().hasKey("user",id)) {
                //注意我们对于hash存储在redis时的键的命名规范
                //表名:主键
                //所以对照这个的取法是
                user =(User) redisTemplate.opsForHash().get("user", id);
            }else {
                //查询数据库
                //模拟查询出来了
                user.setId(id);
                user.setName("minifull");
                user.setAge(21);
                /**
                 * @param h 用户实体名表名 user
                 * @param hk 用户主键 id
                 * @param hv 整个对象
                 */
                redisTemplate.opsForHash().put("user",id,user);
            }
            return user;
        }
    
    展开全文
  • Lettuce support

    2020-11-23 10:28:41
    ve added support for lettuce tests by adding a "lettuce" management command and a "lettuce_tests" task.</p><p>该提问来源于开源项目:kmmbvnr/django-jenkins</p></div>
  • springboot(spring也一样的)整个redis 的时候报如下错误:org.springframework.dao.QueryTimeoutException: ... nested exception is io.lettuce.core.RedisCommandTimeoutException: Command timed out at o...

    springboot(spring也一样的)整个redis 的时候报如下错误:

    org.springframework.dao.QueryTimeoutException: Redis command timed out; nested exception is io.lettuce.core.RedisCommandTimeoutException: Command timed out
    	at org.springframework.data.redis.connection.lettuce.LettuceExceptionConverter.convert(LettuceExceptionConverter.java:70) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.connection.lettuce.LettuceExceptionConverter.convert(LettuceExceptionConverter.java:41) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.PassThroughExceptionTranslationStrategy.translate(PassThroughExceptionTranslationStrategy.java:44) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.FallbackExceptionTranslationStrategy.translate(FallbackExceptionTranslationStrategy.java:42) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.connection.lettuce.LettuceConnection.convertLettuceAccessException(LettuceConnection.java:257) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.connection.lettuce.LettuceConnection.pSubscribe(LettuceConnection.java:747) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.listener.RedisMessageListenerContainer$SubscriptionTask.eventuallyPerformSubscription(RedisMessageListenerContainer.java:783) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.listener.RedisMessageListenerContainer$SubscriptionTask.run(RedisMessageListenerContainer.java:750) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_151]
    
    Caused by: io.lettuce.core.RedisCommandTimeoutException: Command timed out
    	at io.lettuce.core.LettuceFutures.awaitOrCancel(LettuceFutures.java:114) ~[lettuce-core-5.0.2.RELEASE.jar:na]
    	at io.lettuce.core.FutureSyncInvocationHandler.handleInvocation(FutureSyncInvocationHandler.java:62) ~[lettuce-core-5.0.2.RELEASE.jar:na]
    	at io.lettuce.core.internal.AbstractInvocationHandler.invoke(AbstractInvocationHandler.java:80) ~[lettuce-core-5.0.2.RELEASE.jar:na]
    	at com.sun.proxy.$Proxy70.psubscribe(Unknown Source) ~[na:na]
    	at org.springframework.data.redis.connection.lettuce.LettuceSubscription.doPsubscribe(LettuceSubscription.java:54) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.connection.util.AbstractSubscription.pSubscribe(AbstractSubscription.java:130) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	at org.springframework.data.redis.connection.lettuce.LettuceConnection.pSubscribe(LettuceConnection.java:745) ~[spring-data-redis-2.0.5.RELEASE.jar:2.0.5.RELEASE]
    	... 3 common frames omitted

     

     

    错误原因:连接超时时间设置的过于短暂(我这边设置成了0),修改为5000左右即可

     

     

     

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

     

     

     

     

     

    展开全文
  • Lettuce-开源

    2021-04-13 04:38:00
    Lettuce允许Java程序员用Java代码编写直接SQL查询。 它在Java类中定义了SQL关键字,并且还引入了一种轻松组合这些关键字以在Java中创建通用查询的方法。
  • Lettuce Reference Guide

    2018-10-13 23:41:04
    Lettuce Reference Guide (.md)
  • Lettuce Reference Guide.zip

    2020-01-15 11:59:55
    Lettuce Reference Guide.zip Lettuce Reference Guide.zip Lettuce Reference Guide.zip Lettuce Reference Guide.zip
  • springboot集成redis (Lettuce)

    万次阅读 多人点赞 2020-04-03 15:40:21
    目前java操作redis的客户端有jedis跟Lettuce。在springboot1.x系列中,其中使用的是jedis,但是到了springboot2.x其中使用的是Lettuce。 因为我们的版本是springboot2.x系列,所以今天使用的是Lettuce。 关于jedis跟...

    目前java操作redis的客户端有jedisLettuce。在springboot1.x系列中,其中使用的是jedis,但是到了springboot2.x其中使用的是Lettuce。 因为我们的版本是springboot2.x系列,所以今天使用的是Lettuce
    关于jedislettuce的区别:

    • Lettuce 和 Jedis 的定位都是Redis的client,所以他们当然可以直接连接redis server。
    • Jedis在实现上是直接连接的redis server,如果在多线程环境下是非线程安全的,这个时候只有使用连接池,为每个Jedis实例增加物理连接
    • Lettuce的连接是基于Netty的,连接实例(StatefulRedisConnection)可以在多个线程间并发访问,应为StatefulRedisConnection是线程安全的,所以一个连接实例(StatefulRedisConnection)就可以满足多线程环境下的并发访问,当然这个也是可伸缩的设计,一个连接实例不够的情况也可以按需增加连接实例。

    实现集成代码:

    首先添加依赖

    <!--springboot中的redis依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <!-- lettuce pool 缓存连接池-->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>

    注意点:使用pool,那么必须在pom.xml添加上commons-pool2的依赖。没配置pool的话,可以不引用。

    然后配置application.properties:

    spring.redis.host=127.0.0.1
    spring.redis.port=6379
    #连接池最大链接数默认值为8
    spring.redis.lettuce.pool.max-active=8
    #连接池最大阻塞时间(使用负值表示没有限制)默认为-1
    spring.redis.lettuce.pool.max-wait=-1
    #连接池中的最大空闲连接数 默认为8
    spring.redis.lettuce.pool.max-idle=8
    #连接池中的最小空闲连接数 默认为8
    spring.redis.lettuce.pool.min-idle=0

    reids配置类

    接下来我们需要配置redis的key跟value的序列化方式,默认使用的JdkSerializationRedisSerializer 这样的会导致我们通过redis desktop manager显示的我们key跟value的时候显示不是正常字符。 所以我们需要手动配置一下序列化方式 新建一个config包,在其下新建一个RedisConfig.java 具体代码如下

    package com.liu.studyredis.studyredis.config;
    
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    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;
    
    
    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport{
        /**
         * 配置自定义redisTemplate
         * @return
         */
        @Bean
        RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            // 设置值(value)的序列化采用Jackson2JsonRedisSerializer。
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            // 设置键(key)的序列化采用StringRedisSerializer。
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    }
    

    自己封装的工具类

    package com.liu.studyredis.studyredis.util;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.BoundListOperations;
    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;
    
    
    @Component
    public class RedisUtil {
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
            this.redisTemplate = redisTemplate;
        }
    
        /**
         * 指定缓存失效时间
         * @param key 键
         * @param time 时间(秒)
         * @return
         */
        public boolean expire(String key,long time){
            try {
                if(time>0){
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key 获取过期时间
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(String key){
            return redisTemplate.getExpire(key,TimeUnit.SECONDS);
        }
    
        /**
         * 判断key是否存在
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key){
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除缓存
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String ... key){
            if(key!=null&&key.length>0){
                if(key.length==1){
                    redisTemplate.delete(key[0]);
                }else{
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
        //============================String=============================
        /**
         * 普通缓存获取
         * @param key 键
         * @return 值
         */
        public Object get(String key){
            return key==null?null:redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         * @param key 键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean set(String key,Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 普通缓存放入并设置时间
         * @param key 键
         * @param value 值
         * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public boolean set(String key,Object value,long time){
            try {
                if(time>0){
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                }else{
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 递增
         * @param key 键
         * @param 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);
        }
    
        //================================Map=================================
        /**
         * HashGet
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object hget(String key,String item){
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object,Object> hmget(String key){
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public boolean hmset(String key, Map<String,Object> map){
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * HashSet 并设置时间
         * @param key 键
         * @param map 对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public boolean hmset(String key, Map<String,Object> map, long time){
            try {
                redisTemplate.opsForHash().putAll(key, map);
                if(time>0){
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key,String item,Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key,String item,Object value,long time) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                if(time>0){
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除hash表中的值
         * @param key 键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item){
            redisTemplate.opsForHash().delete(key,item);
        }
    
        /**
         * 判断hash表中是否有该项的值
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item){
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         * @param key 键
         * @param item 项
         * @param by 要增加几(大于0)
         * @return
         */
        public double hincr(String key, String item,double by){
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /**
         * hash递减
         * @param key 键
         * @param item 项
         * @param by 要减少记(小于0)
         * @return
         */
        public double hdecr(String key, String item,double by){
            return redisTemplate.opsForHash().increment(key, item,-by);
        }
    
        //============================set=============================
        /**
         * 根据key获取Set中的所有值
         * @param key 键
         * @return
         */
        public Set<Object> sGet(String key){
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 根据value从一个set中查询,是否存在
         * @param key 键
         * @param value 值
         * @return true 存在 false不存在
         */
        public boolean sHasKey(String key,Object value){
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将数据放入set缓存
         * @param key 键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object...values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 将set数据放入缓存
         * @param key 键
         * @param time 时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(String key,long time,Object...values) {
            try {
                Long count = redisTemplate.opsForSet().add(key, values);
                if(time>0) {
                    expire(key, time);
                }
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 获取set缓存的长度
         * @param key 键
         * @return
         */
        public long sGetSetSize(String key){
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 移除值为value的
         * @param key 键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public long setRemove(String key, Object ...values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        //===============================list=================================
    
        /**
         * 获取list缓存的内容
         * @param key 键
         * @param start 开始
         * @param end 结束  0 到 -1代表所有值
         * @return
         */
        public List<Object> lGet(String key, long start, long end){
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 获取list缓存的长度
         * @param key 键
         * @return
         */
        public long lGetListSize(String key){
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 通过索引 获取list中的值
         * @param key 键
         * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @return
         */
        public Object lGetIndex(String key,long index){
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        public boolean lSet(String key, Object value, long time) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        public boolean lSet(String key, List<Object> value, long time) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据索引修改list中的某条数据
         * @param key 键
         * @param index 索引
         * @param value 值
         * @return
         */
        public boolean lUpdateIndex(String key, long index,Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 移除N个值为value
         * @param key 键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        public long lRemove(String key,long count,Object value) {
            try {
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 模糊查询获取key值
         * @param pattern
         * @return
         */
        public Set keys(String pattern){
            return redisTemplate.keys(pattern);
        }
    
        /**
         * 使用Redis的消息队列
         * @param channel
         * @param message 消息内容
         */
        public void convertAndSend(String channel, Object message){
            redisTemplate.convertAndSend(channel,message);
        }
    
    
    
        /**
         * 根据起始结束序号遍历Redis中的list
         * @param listKey
         * @param start  起始序号
         * @param end  结束序号
         * @return
         */
        public List<Object> rangeList(String listKey, long start, long end) {
            //绑定操作
            BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
            //查询数据
            return boundValueOperations.range(start, end);
        }
        /**
         * 弹出右边的值 --- 并且移除这个值
         * @param listKey
         */
        public Object rifhtPop(String listKey){
            //绑定操作
            BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
            return boundValueOperations.rightPop();
        }
    
        //=========BoundListOperations 用法 End============
    
    }
    


    测试类

    package com.liu.studyredis.studyredis;
    
    import com.liu.studyredis.studyredis.entity.User;
    import com.liu.studyredis.studyredis.util.RedisUtil;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.redis.core.RedisTemplate;
    
    @SpringBootTest
    class StudyredisApplicationTests {
    
        @Autowired
        RedisTemplate redisTemplate;
        @Autowired
        RedisUtil redisUtil;
    
    
        @Test
        public void testInsert(){
            User user = new User("LiYi",28);
            redisUtil.set("LiYi",user);
        }
    
    }
    

    运行后结果

     

    展开全文
  • Jedis和Lettuce

    万次阅读 2019-06-26 17:34:57
    Lettuce 和 Jedis 都是Redis的client,所以他们都可以连接 Redis Server。 Jedis在实现上是直接连接的Redis Server,如果在多线程环境下是非线程安全的。 每个线程都去拿自己的 Jedis 实例,当连接数量增多时,资源...

    Lettuce 和 Jedis 都是Redis的client,所以他们都可以连接 Redis Server。
    Jedis在实现上是直接连接的Redis Server,如果在多线程环境下是非线程安全的。
    每个线程都去拿自己的 Jedis 实例,当连接数量增多时,资源消耗阶梯式增大,连接成本就较高了。

    Lettuce的连接是基于Netty的,Netty 是一个多线程、事件驱动的 I/O 框架。连接实例可以在多个线程间共享,当多线程使用同一连接实例时,是线程安全的。
    所以,一个多线程的应用可以使用同一个连接实例,而不用担心并发线程的数量。
    当然这个也是可伸缩的设计,一个连接实例不够的情况也可以按需增加连接实例。

    通过异步的方式可以让我们更好的利用系统资源,而不用浪费线程等待网络或磁盘I/O。
    所以 Lettuce 可以帮助我们充分利用异步的优势。

    使用连接池,为每个Jedis实例增加物理连接Lettuce的连接是基于Netty的,连接实例(StatefulRedisConnection)可以在多个线程间并发访问,应为StatefulRedisConnection是线程安全的,所以一个连接实例(StatefulRedisConnection)就可以满足多线程环境下的并发访问,当然这个也是可伸缩的设计,一个连接实例不够的情况也可以按需增加连接实例。

    展开全文
  • Introduce lettuce tests

    2020-12-09 11:24:40
    - Introduced Lettuce for Cucumber-style BDD tests - Implemented testing for config file parsing - Wired up to Drone <p>While Lettuce seems to be a fairly mature library, I'm worried that it isn&#...
  • 背景从 SpringBoot 2.X 版本开始,Lettuce 作为 Redis Java 客户端程序集成到 Spring Data,在 Jedis 横行的年代,Lettuce 能够进入 Spring Boot 的阵营,这引起了庖丁的好奇,在对 Lettuce 认真了解后,发现这个 ...
  • Support Lettuce Framework

    2020-12-09 02:40:48
    <div><p>Lettuce is a BDD framework for python and it would be really good to have allure support that</p><p>该提问来源于开源项目:allure-framework/allure-pytest</p></div>
  • lettuce单连接

    2021-01-10 02:25:38
    <div><p>pika是多线程的,当lettuce单连接使用的时候会不会有并发安全问题呢?</p><p>该提问来源于开源项目:Qihoo360/pika</p></div>
  • Redis使用lettuce和jedis

    2019-07-02 17:15:11
    Redis使用lettuce和jedis
  • redis lettuce 经过13个月的开发阶段和208张已解决的故障单,我很高兴宣布Lettuce 5.0全面上市。 这是一个主要发行版,带有一些重大更改,新的有趣功能以及Java 9兼容性。 从Maven Central获取发行版 <...
  • 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....
  • WordPress主题-Lettuce

    2020-06-09 00:00:00
    Lettuce是一种丰富多彩,现代且反应灵敏的有机食品WordPress主题。它非常适合与天然食品相关的网站,例如当代农业商业公司,健康食品博客,美食旅游社或健康食品商店。这对于乳品公司和奶酪农场,酿酒厂和葡萄农场,...
  • Lettuce is too big

    2021-01-12 01:53:02
    <p>Lettuce is too big. It comes in stacks of 10, and each leaf is a full .25L. (pictured: 4 farmed tiles of lettuce) Each leaf also has almost no nutritional value in contrast and you only need one ...
  • 文章目录基本实现对比性能对比Jedis的基本用法Jedis配合Springboot RedisTemplate使用Lettuce的基本用法Lettuce配合Springboot RedisTemplate使用结论 基本实现对比 Jedis Lettuce 支持JDK版本 JDK6+ JDK8+...
  • Lettuce资料整理

    2021-05-08 16:42:13
    仓库地址:https://github.com/lettuce-io
  • <div><p>I have two hook in lettuce terrain.py file: <p>.harvest and .harvest - when running lettuce from django-jenkins they are ignored. The documentation does not explain this: do I need to create ...
  • lettuce-scala-test-源码

    2021-03-06 20:54:33
    lettuce-scala-test
  • lettuce客户端Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server,多线程环境下非线程安全(即多个线程对一个连接实例操作,是线程不安全的),除非使用连接池,为每个Jedis...
  • Android代码-lettuce-core

    2019-08-06 03:08:19
    lettuce - Advanced Java Redis client Lettuce is a scalable thread-safe Redis client for synchronous, asynchronous and reactive usage. Multiple threads may share one connection if they avoid ...
  • Lettuce Reference Guide.pdf

    2020-01-14 21:23:07
    最新版Lettuce文档,最牛逼的Redis客户端,支持异步及自定义Command,已裁剪成适合在Kindle上阅读的尺寸。
  • Redis客户端Lettuce.zip

    2019-07-19 14:10:10
    Lettuce是一个可伸缩线程安全的Redis客户端。多个线程可以共享同一个RedisConnection。它利用优秀netty NIO框架来高效地管理多个连接。 示例代码: RedisClient client = new RedisClient("localhost") ...
  • Lettuce线程池问题

    千次阅读 2020-04-28 12:32:12
    Lettuce是一个高性能基于Java编写的Redis驱动框架,底层集成了Project Reactor提供天然的反应式编程,通信框架集成了Netty使用了非阻塞IO,5.x版本之后融合了JDK1.8的异步编程特性。 因为项目中用到了多redis数据源...
  • Using Lettuce and Coverage

    2020-12-08 19:15:25
    m trying to get code coverage information when testing my lettuce features. <p>I'm running: coverage run -p $(which lettuce) <p>Here is what I get before it exits: Traceback (most recent call last...
  • Lettuce and django email

    2020-12-02 03:33:40
    <p>Since <a href="http://cilliano.com/blog/2011/02/07/django-bdd-with-lettuce-and-splinter/">this</a> is one of Google's top post on using lettuce with Django, I think there should be some more ...
  • Lettuce - Advanced Java Redis client Lettuce is a scalable thread-safe Redis client for synchronous, asynchronous and reactive usage. Multiple threads may share one connection if they avoid ...
  • jedis与Lettuce

    千次阅读 2019-01-15 13:24:32
    最近开发的项目需要接入redis,在网上查了一下redis的客户端分别有jedis和Lettuce 网上说jedis和Lettuce的主要区别是,jedis在多线程环境下,线程是不安全的。而 Lettuce在多线程环境下线程是安全的。 那为什么jedis...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,674
精华内容 1,069
热门标签
关键字:

lettuce