SpringBoot集成Redis使用Lettuce

- 日理万妓 2024-03-26 13:27 211阅读 0赞

Redis是最常用的KV数据库，Spring 通过模板方式（RedisTemplate）提供了对Redis的数据查询和操作功能。本文主要介绍基于RedisTemplate + lettuce方式对Redis进行查询和操作的案例。

一、Redis基础数据类型

首先对redis来说，所有的key（键）都是字符串。我们在谈基础数据结构时，讨论的是存储值的数据类型，主要包括常见的5种数据类型，分别是：String、List、Set、Zset、Hash。


































结构类型

结构存储的值

结构的读写能力

String字符串

可以是字符串、整数或浮点数

对整个字符串或字符串的一部分进行操作；对整数或浮点数进行自增或自减操作；

List列表

一个链表，链表上的每个节点都包含一个字符串

对链表的两端进行push和pop操作，读取单个或多个元素；根据值查找或删除元素；

Set集合

包含字符串的无序集合

字符串的集合，包含基础的方法有看是否存在添加、获取、删除；还包含计算交集、并集、差集等

Hash散列

包含键值对的无序散列表

包含方法有添加、获取、删除单个元素

Zset有序集合

和散列一样，用于存储键值对

字符串成员与浮点数分数之间的有序映射；元素的排列顺序由分数的大小决定；包含方法有添加、获取、删除单个元素以及根据分值范围或成员来获取元素

二、 Redis常用连接池

Jedis：是Redis的Java实现客户端，提供了比较全面的Redis命令的支持。

Redisson：实现了分布式和可扩展的Java数据结构。

Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。

三、SpringBoot集成Redis案例

1、yml配置常量：

redis:
# 地址
host: 192.168.1.66
# 端口，默认为6379
port: 6379
# 数据库索引
database: 0
# 密码(如没有密码请注释掉)
password: 123456
# 连接超时时间
timeout: 3000
# 是否开启ssl
ssl: false
lettuce:
pool:
max-active: 1000 # 连接池最大连接数（使用负值表示没有限制）
max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
max-idle: 10 # 连接池中的最大空闲连接
min-idle: 5 # 连接池中的最小空闲连接

2、pom.xml引入依赖：


org.springframework.boot
spring-boot-starter-data-redis
2.4.0



org.apache.commons
commons-pool2
2.8.0

3、RedisConfig配置类：

  1. package com.cn.common.conf;
  3. import com.alibaba.fastjson.parser.ParserConfig;
  4. import com.alibaba.fastjson.support.config.FastJsonConfig;
  5. import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
  6. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.cache.annotation.EnableCaching;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
  13. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
  14. import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
  15. import org.springframework.data.redis.core.RedisTemplate;
  16. import org.springframework.data.redis.serializer.RedisSerializer;
  17. import org.springframework.data.redis.serializer.StringRedisSerializer;
  19. import java.nio.charset.StandardCharsets;
  20. import java.time.Duration;
  23. /**
  24.  * redis配置类
  25.  *
  26.  * @author zq
  27.  */
  29. @Configuration
  30. @EnableCaching
  31. public class RedisConfig {
  33.     // 倘若 spring.redis.host 不存在，则会默认为127.0.0.1.
  34.     @Value("${spring.redis.host:#{'127.0.0.1'}}")
  35.     private String hostName;
  37.     @Value("${spring.redis.port:#{6379}}")
  38.     private int port;
  40.     @Value("${spring.redis.password:#{123456}}")
  41.     private String password;
  43.     @Value("${spring.redis.timeout:#{3000}}")
  44.     private int timeout;
  46.     @Value("${spring.redis.lettuce.pool.max-idle:#{16}}")
  47.     private int maxIdle;
  49.     @Value("${spring.redis.lettuce.pool.min-idle:#{1}}")
  50.     private int minIdle;
  52.     @Value("${spring.redis.lettuce.pool.max-wait:#{16}}")
  53.     private long maxWaitMillis;
  55.     @Value("${spring.redis.lettuce.pool.max-active:#{16}}")
  56.     private int maxActive;
  58.     @Value("${spring.redis.database:#{0}}")
  59.     private int databaseId;
  61.     @Bean
  62.     public LettuceConnectionFactory lettuceConnectionFactory() {
  64.         RedisConfiguration redisConfiguration = new RedisStandaloneConfiguration(
  65.             hostName, port
  66.         );
  68.         // 设置选用的数据库号码
  69.         ((RedisStandaloneConfiguration) redisConfiguration).setDatabase(databaseId);
  71.         // 设置 redis 数据库密码
  72.         ((RedisStandaloneConfiguration) redisConfiguration).setPassword(password);
  74.         // 连接池配置
  75.         GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
  76.         poolConfig.setMaxIdle(maxIdle);
  77.         poolConfig.setMinIdle(minIdle);
  78.         poolConfig.setMaxTotal(maxActive);
  79.         poolConfig.setMaxWaitMillis(maxWaitMillis);
  81.         LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder
  82.             = LettucePoolingClientConfiguration.builder()
  83.             .commandTimeout(Duration.ofMillis(timeout));
  85.         LettucePoolingClientConfiguration lettucePoolingClientConfiguration = builder.build();
  87.         builder.poolConfig(poolConfig);
  89.         // 根据配置和客户端配置创建连接
  90.         LettuceConnectionFactory factory = new LettuceConnectionFactory(redisConfiguration, lettucePoolingClientConfiguration);
  91.         return factory;
  92.     }
  94.     /**
  95.      * springboot2.x 使用LettuceConnectionFactory 代替 RedisConnectionFactory
  96.      * application.yml配置基本信息后,springboot2.x  RedisAutoConfiguration能够自动装配
  97.      * LettuceConnectionFactory 和 RedisConnectionFactory 及其 RedisTemplate
  98.      *
  99.      * @param
  100.      * @return
  101.      */
  102.     @Bean(name = "redisTemplate")
  103.     public RedisTemplate<String, Object> redisTemplate(
  104.         LettuceConnectionFactory lettuceConnectionFactory
  105.     ) {
  107.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  108.         redisTemplate.setConnectionFactory(lettuceConnectionFactory);
  110.         // 使用 FastJsonRedisSerializer 来序列化和反序列化redis 的 value的值
  111.         FastJsonRedisSerializer<Object> serializer = new FastJsonRedisSerializer<>(Object.class);
  112.         ParserConfig.getGlobalInstance().addAccept("com.muzz");
  113.         FastJsonConfig fastJsonConfig = new FastJsonConfig();
  114.         fastJsonConfig.setCharset(StandardCharsets.UTF_8);
  115.         serializer.setFastJsonConfig(fastJsonConfig);
  117.         // key 的 String 序列化采用 StringRedisSerializer
  118.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  119.         redisTemplate.setKeySerializer(stringRedisSerializer);
  120.         redisTemplate.setHashKeySerializer(stringRedisSerializer);
  122.         // value 的值序列化采用 fastJsonRedisSerializer
  123.         redisTemplate.setValueSerializer(serializer);
  124.         redisTemplate.setHashValueSerializer(serializer);
  126.         redisTemplate.afterPropertiesSet();
  128.         System.out.println(redisTemplate.getDefaultSerializer());
  130.         return redisTemplate;
  131.     }
  133.     @Bean
  134.     public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
  136.         // 使用 FastJsonRedisSerializer 来序列化和反序列化redis 的 value的值
  137.         FastJsonRedisSerializer<Object> serializer = new FastJsonRedisSerializer<>(Object.class);
  138.         ParserConfig.getGlobalInstance().addAccept("com.muzz");
  139.         FastJsonConfig fastJsonConfig = new FastJsonConfig();
  140.         fastJsonConfig.setCharset(StandardCharsets.UTF_8);
  141.         serializer.setFastJsonConfig(fastJsonConfig);
  142.         return serializer;
  143.     }
  146. }

4、 RedisUtil工具类：

  1. package com.cn.util;
  3. import lombok.RequiredArgsConstructor;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.RedisTemplate;
  6. import org.springframework.data.redis.core.StringRedisTemplate;
  7. import org.springframework.data.redis.serializer.RedisSerializer;
  8. import org.springframework.data.redis.serializer.StringRedisSerializer;
  9. import org.springframework.stereotype.Component;
  10. import org.springframework.util.CollectionUtils;
  12. import java.util.List;
  13. import java.util.Map;
  14. import java.util.Set;
  15. import java.util.concurrent.TimeUnit;
  17. /**
  18.  * @ Description： 基于spring和redis的redisTemplate工具类
  19.  * 针对所有的hash 都是以h开头的方法
  20.  * 针对所有的Set 都是以s开头的方法                    不含通用方法
  21.  * 针对所有的List 都是以l开头的方法
  22.  * @ Modified By：
  23.  */
  24. @Component
  25. @RequiredArgsConstructor
  26. public class RedisUtils {
  29.     private RedisTemplate redisTemplate;
  32.     private final StringRedisTemplate stringRedisTemplate;
  34.     @Autowired(required = false)
  35.     public void setRedisTemplate(RedisTemplate redisTemplate) {
  36.         RedisSerializer stringSerializer = new StringRedisSerializer();
  37.         redisTemplate.setKeySerializer(stringSerializer);
  38.         redisTemplate.setHashKeySerializer(stringSerializer);
  39.         this.redisTemplate = redisTemplate;
  40.     }
  42.     /**
  43.      * 获取key
  44.      * @param patten
  45.      * @return
  46.      */
  47.     public Set keys(String patten){
  48.         return stringRedisTemplate.keys(patten);
  49.     }
  51.     /**
  52.      * 指定缓存失效时间
  53.      *
  54.      * @param key  键
  55.      * @param time 时间(秒)
  56.      *
  57.      */
  58.     public boolean expire(String key, long time) {
  59.         try {
  60.             if (time > 0) {
  61.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  62.             }
  63.             return true;
  64.         } catch (Exception e) {
  65.             e.printStackTrace();
  66.             return false;
  67.         }
  68.     }
  70.     /**
  71.      * 根据key 获取过期时间
  72.      *
  73.      * @param key 键 不能为null
  74.      * @return 时间(秒) 返回0代表为永久有效
  75.      */
  76.     public long getExpire(String key) {
  77.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  78.     }
  80.     /**
  81.      * 判断key是否存在
  82.      *
  83.      * @param key 键
  84.      * @return true 存在 false不存在
  85.      */
  86.     public boolean hasKey(String key) {
  87.         try {
  88.             return redisTemplate.hasKey(key);
  89.         } catch (Exception e) {
  90.             e.printStackTrace();
  91.             return false;
  92.         }
  93.     }
  95.     /**
  96.      * 删除缓存
  97.      *
  98.      * @param key 可以传一个值 或多个
  99.      */
  100.     @SuppressWarnings("unchecked")
  101.     public void del(String... key) {
  102.         if (key != null && key.length > 0) {
  103.             if (key.length == 1) {
  104.                 redisTemplate.delete(key[0]);
  105.             } else {
  106.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  107.             }
  108.         }
  109.     }
  111.     //============================String=============================
  113.     /**
  114.      * 普通缓存获取
  115.      *
  116.      * @param key 键
  117.      * @return 值
  118.      */
  119.     public Object get(String key) {
  120.         return key == null ? null : redisTemplate.opsForValue().get(key);
  121.     }
  123.     /**
  124.      * 普通缓存放入
  125.      *
  126.      * @param key   键
  127.      * @param value 值
  128.      * @return true成功 false失败
  129.      */
  130.     public boolean set(String key, Object value) {
  131.         try {
  132.             redisTemplate.opsForValue().set(key, value);
  133.             return true;
  134.         } catch (Exception e) {
  135.             e.printStackTrace();
  136.             return false;
  137.         }
  139.     }
  141.     /**
  142.      * 普通缓存放入并设置时间
  143.      *
  144.      * @param key   键
  145.      * @param value 值
  146.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  147.      * @return true成功 false 失败
  148.      */
  149.     public boolean set(String key, Object value, long time) {
  150.         try {
  151.             if (time > 0) {
  152.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  153.             } else {
  154.                 set(key, value);
  155.             }
  156.             return true;
  157.         } catch (Exception e) {
  158.             e.printStackTrace();
  159.             return false;
  160.         }
  161.     }
  163.     /**
  164.      * 递增
  165.      *
  166.      * @param key   键
  167.      * @param delta 要增加几(大于0)
  168.      * @return
  169.      */
  170.     public long incr(String key, long delta) {
  171.         if (delta < 0) {
  172.             throw new RuntimeException("递增因子必须大于0");
  173.         }
  174.         return redisTemplate.opsForValue().increment(key, delta);
  175.     }
  177.     /**
  178.      * 递减
  179.      *
  180.      * @param key   键
  181.      * @param delta 要减少几(小于0)
  182.      * @return
  183.      */
  184.     public long decr(String key, long delta) {
  185.         if (delta < 0) {
  186.             throw new RuntimeException("递减因子必须大于0");
  187.         }
  188.         return redisTemplate.opsForValue().increment(key, -delta);
  189.     }
  191.     //================================Map=================================
  193.     /**
  194.      * HashGet
  195.      *
  196.      * @param key  键 不能为null
  197.      * @param item 项 不能为null
  198.      * @return 值
  199.      */
  200.     public Object hget(String key, String item) {
  201.         return redisTemplate.opsForHash().get(key, item);
  202.     }
  204.     /**
  205.      * 获取hashKey对应的所有键值
  206.      *
  207.      * @param key 键
  208.      * @return 对应的多个键值
  209.      */
  210.     public Map<Object, Object> hmget(String key) {
  211.         return redisTemplate.opsForHash().entries(key);
  212.     }
  214.     /**
  215.      * HashSet
  216.      *
  217.      * @param key 键
  218.      * @param map 对应多个键值
  219.      * @return true 成功 false 失败
  220.      */
  221.     public boolean hmset(String key, Map<String, Object> map) {
  222.         try {
  223.             redisTemplate.opsForHash().putAll(key, map);
  224.             return true;
  225.         } catch (Exception e) {
  226.             e.printStackTrace();
  227.             return false;
  228.         }
  229.     }
  231.     /**
  232.      * HashSet 并设置时间
  233.      *
  234.      * @param key  键
  235.      * @param map  对应多个键值
  236.      * @param time 时间(秒)
  237.      * @return true成功 false失败
  238.      */
  239.     public boolean hmset(String key, Map<String, Object> map, long time) {
  240.         try {
  241.             redisTemplate.opsForHash().putAll(key, map);
  242.             if (time > 0) {
  243.                 expire(key, time);
  244.             }
  245.             return true;
  246.         } catch (Exception e) {
  247.             e.printStackTrace();
  248.             return false;
  249.         }
  250.     }
  252.     /**
  253.      * 向一张hash表中放入数据,如果不存在将创建
  254.      *
  255.      * @param key   键
  256.      * @param item  项
  257.      * @param value 值
  258.      * @return true 成功 false失败
  259.      */
  260.     public boolean hset(String key, String item, Object value) {
  261.         try {
  262.             redisTemplate.opsForHash().put(key, item, value);
  263.             return true;
  264.         } catch (Exception e) {
  265.             e.printStackTrace();
  266.             return false;
  267.         }
  268.     }
  270.     /**
  271.      * 向一张hash表中放入数据,如果不存在将创建
  272.      *
  273.      * @param key   键
  274.      * @param item  项
  275.      * @param value 值
  276.      * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
  277.      * @return true 成功 false失败
  278.      */
  279.     public boolean hset(String key, String item, Object value, long time) {
  280.         try {
  281.             redisTemplate.opsForHash().put(key, item, value);
  282.             if (time > 0) {
  283.                 expire(key, time);
  284.             }
  285.             return true;
  286.         } catch (Exception e) {
  287.             e.printStackTrace();
  288.             return false;
  289.         }
  290.     }
  292.     /**
  293.      * 删除hash表中的值
  294.      *
  295.      * @param key  键 不能为null
  296.      * @param item 项 可以使多个 不能为null
  297.      */
  298.     public void hdel(String key, Object... item) {
  299.         redisTemplate.opsForHash().delete(key, item);
  300.     }
  302.     /**
  303.      * 判断hash表中是否有该项的值
  304.      *
  305.      * @param key  键 不能为null
  306.      * @param item 项 不能为null
  307.      * @return true 存在 false不存在
  308.      */
  309.     public boolean hHasKey(String key, String item) {
  310.         return redisTemplate.opsForHash().hasKey(key, item);
  311.     }
  313.     /**
  314.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  315.      *
  316.      * @param key  键
  317.      * @param item 项
  318.      * @param by   要增加几(大于0)
  319.      * @return
  320.      */
  321.     public double hincr(String key, String item, double by) {
  322.         return redisTemplate.opsForHash().increment(key, item, by);
  323.     }
  325.     /**
  326.      * hash递减
  327.      *
  328.      * @param key  键
  329.      * @param item 项
  330.      * @param by   要减少记(小于0)
  331.      * @return
  332.      */
  333.     public double hdecr(String key, String item, double by) {
  334.         return redisTemplate.opsForHash().increment(key, item, -by);
  335.     }
  337.     //============================set=============================
  339.     /**
  340.      * 根据key获取Set中的所有值
  341.      *
  342.      * @param key 键
  343.      * @return
  344.      */
  345.     public Set<Object> sGet(String key) {
  346.         try {
  347.             return redisTemplate.opsForSet().members(key);
  348.         } catch (Exception e) {
  349.             e.printStackTrace();
  350.             return null;
  351.         }
  352.     }
  354.     /**
  355.      * 根据value从一个set中查询,是否存在
  356.      *
  357.      * @param key   键
  358.      * @param value 值
  359.      * @return true 存在 false不存在
  360.      */
  361.     public boolean sHasKey(String key, Object value) {
  362.         try {
  363.             return redisTemplate.opsForSet().isMember(key, value);
  364.         } catch (Exception e) {
  365.             e.printStackTrace();
  366.             return false;
  367.         }
  368.     }
  370.     /**
  371.      * 将数据放入set缓存
  372.      *
  373.      * @param key    键
  374.      * @param values 值 可以是多个
  375.      * @return 成功个数
  376.      */
  377.     public long sSet(String key, Object... values) {
  378.         try {
  379.             return redisTemplate.opsForSet().add(key, values);
  380.         } catch (Exception e) {
  381.             e.printStackTrace();
  382.             return 0;
  383.         }
  384.     }
  386.     /**
  387.      * 将set数据放入缓存
  388.      *
  389.      * @param key    键
  390.      * @param time   时间(秒)
  391.      * @param values 值 可以是多个
  392.      * @return 成功个数
  393.      */
  394.     public long sSetAndTime(String key, long time, Object... values) {
  395.         try {
  396.             Long count = redisTemplate.opsForSet().add(key, values);
  397.             if (time > 0) expire(key, time);
  398.             return count;
  399.         } catch (Exception e) {
  400.             e.printStackTrace();
  401.             return 0;
  402.         }
  403.     }
  405.     /**
  406.      * 获取set缓存的长度
  407.      *
  408.      * @param key 键
  409.      * @return
  410.      */
  411.     public long sGetSetSize(String key) {
  412.         try {
  413.             return redisTemplate.opsForSet().size(key);
  414.         } catch (Exception e) {
  415.             e.printStackTrace();
  416.             return 0;
  417.         }
  418.     }
  420.     /**
  421.      * 移除值为value的
  422.      *
  423.      * @param key    键
  424.      * @param values 值 可以是多个
  425.      * @return 移除的个数
  426.      */
  427.     public long setRemove(String key, Object... values) {
  428.         try {
  429.             Long count = redisTemplate.opsForSet().remove(key, values);
  430.             return count;
  431.         } catch (Exception e) {
  432.             e.printStackTrace();
  433.             return 0;
  434.         }
  435.     }
  436.     //===============================list=================================
  438.     /**
  439.      * 获取list缓存的内容
  440.      *
  441.      * @param key   键
  442.      * @param start 开始
  443.      * @param end   结束  0 到 -1代表所有值
  444.      * @return
  445.      */
  446.     public List<Object> lGet(String key, long start, long end) {
  447.         try {
  448.             return redisTemplate.opsForList().range(key, start, end);
  449.         } catch (Exception e) {
  450.             e.printStackTrace();
  451.             return null;
  452.         }
  453.     }
  455.     /**
  456.      * 获取list缓存的长度
  457.      *
  458.      * @param key 键
  459.      * @return
  460.      */
  461.     public long lGetListSize(String key) {
  462.         try {
  463.             return redisTemplate.opsForList().size(key);
  464.         } catch (Exception e) {
  465.             e.printStackTrace();
  466.             return 0;
  467.         }
  468.     }
  470.     /**
  471.      * 通过索引 获取list中的值
  472.      *
  473.      * @param key   键
  474.      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  475.      * @return
  476.      */
  477.     public Object lGetIndex(String key, long index) {
  478.         try {
  479.             return redisTemplate.opsForList().index(key, index);
  480.         } catch (Exception e) {
  481.             e.printStackTrace();
  482.             return null;
  483.         }
  484.     }
  486.     /**
  487.      * 将list放入缓存
  488.      *
  489.      * @param key   键
  490.      * @param value 值
  491.      * @return
  492.      */
  493.     public boolean lSet(String key, Object value) {
  494.         try {
  495.             redisTemplate.opsForList().rightPush(key, value);
  496.             return true;
  497.         } catch (Exception e) {
  498.             e.printStackTrace();
  499.             return false;
  500.         }
  501.     }
  503.     /**
  504.      * 将list放入缓存
  505.      *
  506.      * @param key   键
  507.      * @param value 值
  508.      * @param time  时间(秒)
  509.      * @return
  510.      */
  511.     public boolean lSet(String key, Object value, long time) {
  512.         try {
  513.             redisTemplate.opsForList().rightPush(key, value);
  514.             if (time > 0) expire(key, time);
  515.             return true;
  516.         } catch (Exception e) {
  517.             e.printStackTrace();
  518.             return false;
  519.         }
  520.     }
  522.     /**
  523.      * 将list放入缓存
  524.      *
  525.      * @param key   键
  526.      * @param value 值
  527.      * @return
  528.      */
  529.     public boolean lSet(String key, List<Object> value) {
  530.         try {
  531.             redisTemplate.opsForList().rightPushAll(key, value);
  532.             return true;
  533.         } catch (Exception e) {
  534.             e.printStackTrace();
  535.             return false;
  536.         }
  537.     }
  539.     /**
  540.      * 将list放入缓存
  541.      *
  542.      * @param key   键
  543.      * @param value 值
  544.      * @param time  时间(秒)
  545.      * @return
  546.      */
  547.     public boolean lSet(String key, List<Object> value, long time) {
  548.         try {
  549.             redisTemplate.opsForList().rightPushAll(key, value);
  550.             if (time > 0) expire(key, time);
  551.             return true;
  552.         } catch (Exception e) {
  553.             e.printStackTrace();
  554.             return false;
  555.         }
  556.     }
  558.     /**
  559.      * 根据索引修改list中的某条数据
  560.      *
  561.      * @param key   键
  562.      * @param index 索引
  563.      * @param value 值
  564.      * @return
  565.      */
  566.     public boolean lUpdateIndex(String key, long index, Object value) {
  567.         try {
  568.             redisTemplate.opsForList().set(key, index, value);
  569.             return true;
  570.         } catch (Exception e) {
  571.             e.printStackTrace();
  572.             return false;
  573.         }
  574.     }
  576.     /**
  577.      * 移除N个值为value
  578.      *
  579.      * @param key   键
  580.      * @param count 移除多少个
  581.      * @param value 值
  582.      * @return 移除的个数
  583.      */
  584.     public long lRemove(String key, long count, Object value) {
  585.         try {
  586.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  587.             return remove;
  588.         } catch (Exception e) {
  589.             e.printStackTrace();
  590.             return 0;
  591.         }
  592.     }
  593. }

发表评论

表情：
评论列表 （有 0 条评论，211人围观）

还没有评论，来说两句吧...

相关阅读