client

Jedis：是老牌的Redis的Java实现客户端，提供了比较全面的Redis命令的支持， Redisson：实现了分布式和可扩展的Java数据结构。 Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。

优点：

Jedis：比较全面的提供了Redis的操作特性 Redisson：促使使用者对Redis的关注分离，提供很多分布式相关操作服务，例如，分布式锁，分布式集合，可通过 Redis支持延迟队列 Lettuce：基于Netty框架的事件驱动的通信层，其方法调用是异步的。Lettuce的API是线程安全的，所以可以操作 单个Lettuce连接来完成各种操作

可伸缩：

Jedis：使用阻塞的I/O，且其方法调用都是同步的，程序流需要等到sockets处理完I/O才能执行，不支持异步。 Jedis客户端实例不是线程安全的，所以需要通过连接池来使用Jedis。 Redisson：基于Netty框架的事件驱动的通信层，其方法调用是异步的。Redisson的API是线程安全的，所以可以操 作单个Redisson连接来完成各种操作 Lettuce：基于Netty框架的事件驱动的通信层，其方法调用是异步的。Lettuce的API是线程安全的，所以可以操作 单个Lettuce连接来完成各种操作 lettuce能够支持redis4，需要java8及以上。 lettuce是基于netty实现的与redis进行同步和异步的通信。

lettuce和jedis比较：

• jedis使直接连接redis server,如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个jedis实例增加物理连接 ；
• lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问，
  • StatefulRedisConnection是线程安全的，所以一个连接实例可以满足多线程环境下的并发访问，
  • 当然这也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。
• Redisson实现了分布式和可扩展的Java数据结构，和Jedis相比，功能较为简单，
  • 不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。
  • Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。

总结：

• 优先使用Lettuce，如果需要分布式锁，分布式集合等分布式的高级特性，添加Redisson结合使用，因为Redisson本身对字符串的操作支持很差。
• 在一些高并发的场景中，比如秒杀，抢票，抢购这些场景，都存在对核心资源，商品库存的争夺，控制不好，库存数量可能被减少到负数，出现超卖的情况，或者 产生唯一的一个递增ID，由于web应用部署在多个机器上，简单的同步加锁是无法实现的，给数据库加锁的话，对于高并发，1000/s的并发，数据可能由行锁变成表锁，性能下降会厉害。那相对而言，redis的分布式锁，相对而言，是个很好的选择，redis官方推荐使用的Redisson就提供了分布式锁和相关服务。

Lettuce 和 Jedis 的定位都是Redis的client，所以他们当然可以直接连接redis server。

• 实现方式差别：

• Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个Jedis实例增加物理连接。

• Lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问
• StatefulRedisConnection是线程安全的，所以一个连接实例（StatefulRedisConnection）就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

maven

        <!--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>

#端口，项目上下文
server:
  port: 8080
  servlet:
    context-path: /redis-demo

spring:
  redis:
#    host: 192.168.223.131
#    port: 7001
    password: admin@2021
    # Redis 默认数据库设置
    database: 0
    # Redis Cluster集群节点配置
    cluster:
      # Redis 集群地址信息
      nodes:
        - 192.168.223.131:7001
        - 192.168.223.131:7002
        - 192.168.223.131:7003
        - 192.168.223.131:7004
        - 192.168.223.131:7005
        - 192.168.223.131:7006
      # 获取失败 最大重定向次数
      max-redirects: 3
    #如果用以前的jedis，可以把下面的lettuce换成jedis即可
    lettuce:
      pool:
        # 连接池最大连接数默认值为8
        max-active: 1000
        # 连接池最大阻塞时间（使用负值表示没有限制）默认值为-1
        max-wait: -1
        # 连接池中最大空闲连接数默认值为8
        max-idle: 10
        # 连接池中的最小空闲连接数，默认值为0
        min-idle: 10

redisUtil

 package com.osvue.app.user.common;
 
 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============

 }