springboot2.x整合redis模块

柔情只为你懂 2021-12-09 05:07 382阅读 0赞

本文是基于springboot2.x版本对于redis服务的模块整合。

pom.xml

  1. <!-- cache-->
  2. <dependency>
  3.    <groupId>org.springframework.boot</groupId>
  4.    <artifactId>spring-boot-starter-cache</artifactId>
  5. </dependency>
  6. <!--redis-->
  7. <dependency>
  8.    <groupId>org.springframework.boot</groupId>
  9.    <artifactId>spring-boot-starter-data-redis</artifactId>
  10. </dependency>
  11. <dependency>
  12.    <groupId>org.apache.commons</groupId>
  13.    <artifactId>commons-pool2</artifactId>
  14. </dependency>

application.yml

  1. #redis配置
  2. spring:
  3.   redis:
  4.     database: 0   #默认使用0号库
  5.     host: 47.105.83.58  #redis服务地址
  6.     port: 6379  #端口
  7.     password: zrsupply  #密码
  8.     lettuce:
  9.       pool:
  10.         max-active: 16  #最大连接数
  11.         max-wait: 30s #最长等待时间
  12.         max-idle: 8 #最大空闲连接
  13.         min-idle: 1 #最小空闲连接
  14.     timeout: 10s #连接超时时间
  15.   cache:
  16.     type: redis

定义redis的配置类

  1. @EnableCaching：启用缓存
  3. package com.ruoyi.common.config;
  5. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  6. import com.fasterxml.jackson.annotation.PropertyAccessor;
  7. import com.fasterxml.jackson.databind.ObjectMapper;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.cache.CacheManager;
  12. import org.springframework.cache.annotation.CachingConfigurerSupport;
  13. import org.springframework.cache.annotation.EnableCaching;
  14. import org.springframework.cache.interceptor.KeyGenerator;
  15. import org.springframework.context.annotation.Bean;
  16. import org.springframework.context.annotation.Configuration;
  17. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  18. import org.springframework.data.redis.cache.RedisCacheManager;
  19. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
  20. import org.springframework.data.redis.core.RedisTemplate;
  21. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  22. import org.springframework.data.redis.serializer.RedisSerializationContext;
  23. import org.springframework.data.redis.serializer.RedisSerializer;
  24. import org.springframework.data.redis.serializer.StringRedisSerializer;
  26. import java.lang.reflect.Method;
  27. import java.time.Duration;
  29. /**
  30.  * created by py on 2019/7/11
  31.  */
  32. @EnableCaching
  33. @Configuration
  34. public class RedisConfig extends CachingConfigurerSupport {
  35.     private static final Logger logger = LoggerFactory.getLogger(RedisConfig.class);
  36.     @Autowired
  37.     private LettuceConnectionFactory lettuceConnectionFactory;
  39.     @Bean
  40.     public KeyGenerator keyGenerator() {
  41.         return new KeyGenerator() {
  42.             @Override
  43.             public Object generate(Object target, Method method, Object... params) {
  44.                 StringBuffer sb = new StringBuffer();
  45.                 sb.append(target.getClass().getName());
  46.                 sb.append(method.getName());
  47.                 for (Object obj : params) {
  48.                     sb.append(obj.toString());
  49.                 }
  50.                 return sb.toString();
  51.             }
  52.         };
  53.     }
  56.     // key键序列化方式
  57.     private RedisSerializer<String> keySerializer() {
  58.         return new StringRedisSerializer();
  59.     }
  61.     /**
  62.      * json序列化
  63.      * @return
  64.      */
  65.     @Bean
  66.     public RedisSerializer<Object> jackson2JsonRedisSerializer() {
  67.         //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
  68.         Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
  70.         ObjectMapper mapper = new ObjectMapper();
  71.         mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  72.         mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  73.         serializer.setObjectMapper(mapper);
  74.         return serializer;
  75.     }
  77.     /**
  78.      * 配置缓存管理器
  79.      * @return
  80.      */
  81.     @Bean
  82.     public CacheManager cacheManager() {
  83.         // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
  84.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
  85.         // 设置缓存的默认过期时间，也是使用Duration设置
  86.         config = config.entryTtl(Duration.ofMinutes(60*12))
  87.          // 设置 key为string序列化
  88.          .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
  89.          // 设置value为json序列化
  90.          .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()))
  91.          // 不缓存空值
  92.          .disableCachingNullValues();
  93.         // 使用自定义的缓存配置初始化一个cacheManager
  94.         return RedisCacheManager
  95.          .builder(lettuceConnectionFactory)
  96.          .cacheDefaults(config)
  97.          .transactionAware()
  98.          .build();
  101.     }
  103.     /**
  104.      * RedisTemplate配置
  105.      */
  106.     @Bean
  107.     public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
  108.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  109.         //todo 设置连接工厂（lettuceConnectionFactory为springboot2.0之后添加的新工厂）
  110.         redisTemplate.setConnectionFactory(lettuceConnectionFactory);
  111.         //todo 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
  112.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  113.         ObjectMapper objectMapper = new ObjectMapper();
  114.         //todo 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
  115.         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  116.         //todo 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
  117.         objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  118.         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
  120.         //使用StringRedisSerializer来序列化和反序列化redis的key值
  121.         RedisSerializer redisSerializer = new StringRedisSerializer();
  122.         //key
  123.         redisTemplate.setKeySerializer(redisSerializer);
  124.         redisTemplate.setHashKeySerializer(redisSerializer);
  125.         //value 值采用json序列化
  126.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  127.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  129.         redisTemplate.afterPropertiesSet();
  130.         return redisTemplate;
  132.     }
  133. }

使用缓存注解的话此时只需要在你的方法上添加对应的注释即可（更多缓存注解请自行研究）

PS：将对象放置缓存中时对象需要实现序列化**（实现 Serializable 接口）**

@Cacheable：设置缓存（调用方法时判断是否存在缓存，存在直接取缓存，否则查询后将数据存放至缓存中供下次使用）

@CachePut：修改缓存的数据

@CacheEvict：删除缓存数据

PS：缓存使用的时候在service中调用方法A调用方法B时无法触发缓存的调用

缓存调用失败参考文章：

原因

Aop的原理图如下：

70

也就是说我们首先调用的是AOP代理对象而不是目标对象。但是我们使用this.getInstalledApk(imeiSnCodes.get(i))时，this表示的是当前的对象，而不是代理对象，因此注解失效。

class:serviceimpl

method:A

method:B(注解缓存)

public Json A(){

Json o = this.B();//此时缓存失效

}

PS:【在使用注解的时候无法在注解上指定key的失效时间，需要实现自定义注解来了设置key的失效时间】

参考文章1：

参考文章2：

参考文章3：

RedisTemplate模板

  1. package com.redis.common.utils;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.stereotype.Component;
  7. import java.util.*;
  8. import java.util.concurrent.TimeUnit;
  9. import java.util.stream.Collectors;
  10. import java.util.stream.Stream;
  12. /**
  13.  * created by py on 2019/7/11
  14.  */
  15. @Component
  16. public class RedisUtils {
  17.     @Autowired
  18.     private RedisTemplate redisTemplate;
  19.     /**
  20.      * 默认过期时长，单位：秒
  21.      */
  22.     public static final long DEFAULT_EXPIRE = 60 * 60 * 24;
  23.     /**
  24.      * 不设置过期时长
  25.      */
  26.     public static final long NOT_EXPIRE = -1;
  28.     /**
  29.      * 判断key是否存在
  30.      * @param key
  31.      * @return
  32.      */
  33.     public boolean existsKey(String key) {
  34.         try {
  35.             return redisTemplate.hasKey(key);
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.             return false;
  39.         }
  41.     }
  43.     /**
  44.      * 重名名key，如果newKey已经存在，则newKey的原值被覆盖
  45.      *
  46.      * @param oldKey
  47.      * @param newKey
  48.      */
  49.     public void renameKey(String oldKey, String newKey) {
  50.         redisTemplate.rename(oldKey, newKey);
  51.     }
  53.     /**
  54.      * newKey不存在时才重命名
  55.      *
  56.      * @param oldKey
  57.      * @param newKey
  58.      * @return 修改成功返回true
  59.      */
  60.     public boolean renameKeyNotExist(String oldKey, String newKey) {
  61.         return redisTemplate.renameIfAbsent(oldKey, newKey);
  62.     }
  64.     /**
  65.      * 删除key
  66.      *
  67.      * @param key
  68.      */
  69.     public void deleteKey(String key) {
  70.         redisTemplate.delete(key);
  71.     }
  73.     /**
  74.      * 删除多个key
  75.      *
  76.      * @param keys
  77.      */
  78.     public void deleteKey(String... keys) {
  79.         Set<String> kSet = Stream.of(keys).map(k -> k).collect(Collectors.toSet());
  80.         redisTemplate.delete(kSet);
  81.     }
  83.     /**
  84.      * 删除Key的集合
  85.      *
  86.      * @param keys
  87.      */
  88.     public void deleteKey(Collection<String> keys) {
  89.         Set<String> kSet = keys.stream().map(k -> k).collect(Collectors.toSet());
  90.         redisTemplate.delete(kSet);
  91.     }
  94.     /**
  95.      * 设置key的生命周期
  96.      *
  97.      * @param key 键
  98.      * @param time 时间
  99.      * @param timeUnit 时间维度（时、分、秒、） TimeUnit.SECONDS
  100.      */
  101.     public boolean expire(String key, long time, TimeUnit timeUnit){
  102.         try {
  103.             if(time>0){
  104.                 redisTemplate.expire(key, time, timeUnit);
  105.             }
  106.             return true;
  107.         } catch (Exception e) {
  108.             e.printStackTrace();
  109.             return false;
  110.         }
  111.     }
  113.     /**
  114.      * 指定key在指定的日期过期
  115.      *
  116.      * @param key
  117.      * @param date
  118.      */
  119.     public void expireKeyAt(String key, Date date) {
  120.         redisTemplate.expireAt(key, date);
  121.     }
  122.     /**
  123.      * 查询key的生命周期
  124.      *
  125.      * @param key
  126.      * @param timeUnit 时间维度（时、分、秒、） TimeUnit.SECONDS
  127.      * @return
  128.      */
  129.     public long getKeyExpire(String key, TimeUnit timeUnit) {
  130.         return redisTemplate.getExpire(key, timeUnit);
  131.     }
  132.     /**
  133.      * 将key设置为永久有效
  134.      *
  135.      * @param key
  136.      */
  137.     public void persistKey(String key) {
  138.         redisTemplate.persist(key);
  139.     }
  140.     //todo  ====================String==============================
  141.     /**
  142.      * 普通缓存获取
  143.      * @param key 键
  144.      * @return 值
  145.      */
  146.     public Object get(String key){
  147.         return key==null?null:redisTemplate.opsForValue().get(key);
  148.     }
  150.     /**
  151.      * 普通缓存放入
  152.      * @param key 键
  153.      * @param value 值
  154.      * @return true成功 false失败
  155.      */
  156.     public boolean set(String key,Object value) {
  157.         try {
  158.             redisTemplate.opsForValue().set(key, value);
  159.             return true;
  160.         } catch (Exception e) {
  161.             e.printStackTrace();
  162.             return false;
  163.         }
  165.     }
  167.     /**
  168.      * 普通缓存放入并设置时间
  169.      * @param key 键
  170.      * @param value 值
  171.      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
  172.      * @return true成功 false 失败
  173.      */
  174.     public boolean set(String key,Object value,long time){
  175.         try {
  176.             if(time>0){
  177.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  178.             }else{
  179.                 set(key, value);
  180.             }
  181.             return true;
  182.         } catch (Exception e) {
  183.             e.printStackTrace();
  184.             return false;
  185.         }
  186.     }
  188.     /**
  189.      * 递增
  190.      * @param key 键
  191.      * @param delta 要增加几(大于0)
  192.      * @return
  193.      */
  194.     public long incr(String key, long delta){
  195.         if(delta<0){
  196.             throw new RuntimeException("递增因子必须大于0");
  197.         }
  198.         return redisTemplate.opsForValue().increment(key, delta);
  199.     }
  201.     /**
  202.      * 递减
  203.      * @param key 键
  204.      * @param delta 要减少几(小于0)
  205.      * @return
  206.      */
  207.     public long decr(String key, long delta){
  208.         if(delta<0){
  209.             throw new RuntimeException("递减因子必须大于0");
  210.         }
  211.         return redisTemplate.opsForValue().increment(key, -delta);
  212.     }
  213.     //todo  ====================hash==============================
  214.     /**
  215.      * HashGet
  216.      * @param key 键 不能为null
  217.      * @param item 项 不能为null
  218.      * @return 值
  219.      */
  220.     public Object hget(String key,String item){
  221.         return redisTemplate.opsForHash().get(key, item);
  222.     }
  223.     /**
  224.      * 获取hashKey对应的所有键值
  225.      * @param key 键
  226.      * @return 对应的多个键值
  227.      */
  228.     public Map<Object,Object> hmget(String key){
  229.         return redisTemplate.opsForHash().entries(key);
  230.     }
  231.     /**
  232.      * HashSet
  233.      * @param key 键
  234.      * @param map 对应多个键值
  235.      * @return true 成功 false 失败
  236.      */
  237.     public boolean hmset(String key, Map<String,Object> map){
  238.         try {
  239.             redisTemplate.opsForHash().putAll(key, map);
  240.             return true;
  241.         } catch (Exception e) {
  242.             e.printStackTrace();
  243.             return false;
  244.         }
  245.     }
  246.     /**
  247.      * HashSet 并设置时间
  248.      * @param key 键
  249.      * @param map 对应多个键值
  250.      * @param time 时间(秒)
  251.      * @return true成功 false失败
  252.      */
  253.     public boolean hmset(String key, Map<String,Object> map, long time){
  254.         try {
  255.             redisTemplate.opsForHash().putAll(key, map);
  256.             if(time>0){
  257.                 expire(key, time,TimeUnit.SECONDS);
  258.             }
  259.             return true;
  260.         } catch (Exception e) {
  261.             e.printStackTrace();
  262.             return false;
  263.         }
  264.     }
  266.     /**
  267.      * 向一张hash表中放入数据,如果不存在将创建
  268.      * @param key 键
  269.      * @param item 项
  270.      * @param value 值
  271.      * @return true 成功 false失败
  272.      */
  273.     public boolean hset(String key,String item,Object value) {
  274.         try {
  275.             redisTemplate.opsForHash().put(key, item, value);
  276.             return true;
  277.         } catch (Exception e) {
  278.             e.printStackTrace();
  279.             return false;
  280.         }
  281.     }
  282.     /**
  283.      * 向一张hash表中放入数据,如果不存在将创建
  284.      * @param key 键
  285.      * @param item 项
  286.      * @param value 值
  287.      * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
  288.      * @return true 成功 false失败
  289.      */
  290.     public boolean hset(String key,String item,Object value,long time) {
  291.         try {
  292.             redisTemplate.opsForHash().put(key, item, value);
  293.             if(time>0){
  294.                 expire(key, time,TimeUnit.SECONDS);
  295.             }
  296.             return true;
  297.         } catch (Exception e) {
  298.             e.printStackTrace();
  299.             return false;
  300.         }
  301.     }
  302.     /**
  303.      * 删除hash表中的值
  304.      * @param key 键 不能为null
  305.      * @param item 项 可以使多个 不能为null
  306.      */
  307.     public void hdel(String key, Object... item){
  308.         redisTemplate.opsForHash().delete(key,item);
  309.     }
  310.     /**
  311.      * 判断hash表中是否有该项的值
  312.      * @param key 键 不能为null
  313.      * @param item 项 不能为null
  314.      * @return true 存在 false不存在
  315.      */
  316.     public boolean hHasKey(String key, String item){
  317.         return redisTemplate.opsForHash().hasKey(key, item);
  318.     }
  319.     /**
  320.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  321.      * @param key 键
  322.      * @param item 项
  323.      * @param by 要增加几(大于0)
  324.      * @return
  325.      */
  326.     public double hincr(String key, String item,double by){
  327.         return redisTemplate.opsForHash().increment(key, item, by);
  328.     }
  330.     /**
  331.      * hash递减
  332.      * @param key 键
  333.      * @param item 项
  334.      * @param by 要减少记(小于0)
  335.      * @return
  336.      */
  337.     public double hdecr(String key, String item,double by){
  338.         return redisTemplate.opsForHash().increment(key, item,-by);
  339.     }
  340.     //todo  ====================Set==============================
  341.     /**
  342.      * 根据key获取Set中的所有值
  343.      * @param key 键
  344.      * @return
  345.      */
  346.     public Set<Object> sGet(String key){
  347.         try {
  348.             return redisTemplate.opsForSet().members(key);
  349.         } catch (Exception e) {
  350.             e.printStackTrace();
  351.             return null;
  352.         }
  353.     }
  355.     /**
  356.      * 根据value从一个set中查询,是否存在
  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.      * @param key 键
  373.      * @param values 值 可以是多个
  374.      * @return 成功个数
  375.      */
  376.     public long sSet(String key, Object...values) {
  377.         try {
  378.             return redisTemplate.opsForSet().add(key, values);
  379.         } catch (Exception e) {
  380.             e.printStackTrace();
  381.             return 0;
  382.         }
  383.     }
  385.     /**
  386.      * 将set数据放入缓存
  387.      * @param key 键
  388.      * @param time 时间(秒)
  389.      * @param values 值 可以是多个
  390.      * @return 成功个数
  391.      */
  392.     public long sSetAndTime(String key,long time,Object...values) {
  393.         try {
  394.             Long count = redisTemplate.opsForSet().add(key, values);
  395.             if(time>0) expire(key, time,TimeUnit.SECONDS);
  396.             return count;
  397.         } catch (Exception e) {
  398.             e.printStackTrace();
  399.             return 0;
  400.         }
  401.     }
  403.     /**
  404.      * 获取set缓存的长度
  405.      * @param key 键
  406.      * @return
  407.      */
  408.     public long sGetSetSize(String key){
  409.         try {
  410.             return redisTemplate.opsForSet().size(key);
  411.         } catch (Exception e) {
  412.             e.printStackTrace();
  413.             return 0;
  414.         }
  415.     }
  417.     /**
  418.      * 移除值为value的
  419.      * @param key 键
  420.      * @param values 值 可以是多个
  421.      * @return 移除的个数
  422.      */
  423.     public long setRemove(String key, Object ...values) {
  424.         try {
  425.             Long count = redisTemplate.opsForSet().remove(key, values);
  426.             return count;
  427.         } catch (Exception e) {
  428.             e.printStackTrace();
  429.             return 0;
  430.         }
  431.     }
  434. //todo ===============================list=================================
  436.     /**
  437.      * 获取list缓存的内容
  438.      * @param key 键
  439.      * @param start 开始
  440.      * @param end 结束  0 到 -1代表所有值
  441.      * @return
  442.      */
  443.     public List<Object> lGet(String key, long start, long end){
  444.         try {
  445.             return redisTemplate.opsForList().range(key, start, end);
  446.         } catch (Exception e) {
  447.             e.printStackTrace();
  448.             return null;
  449.         }
  450.     }
  452.     /**
  453.      * 获取list缓存的长度
  454.      * @param key 键
  455.      * @return
  456.      */
  457.     public long lGetListSize(String key){
  458.         try {
  459.             return redisTemplate.opsForList().size(key);
  460.         } catch (Exception e) {
  461.             e.printStackTrace();
  462.             return 0;
  463.         }
  464.     }
  466.     /**
  467.      * 通过索引 获取list中的值
  468.      * @param key 键
  469.      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  470.      * @return
  471.      */
  472.     public Object lGetIndex(String key,long index){
  473.         try {
  474.             return redisTemplate.opsForList().index(key, index);
  475.         } catch (Exception e) {
  476.             e.printStackTrace();
  477.             return null;
  478.         }
  479.     }
  481.     /**
  482.      * 将list放入缓存
  483.      * @param key 键
  484.      * @param value 值
  485.      * @param time 时间(秒)
  486.      * @return
  487.      */
  488.     public boolean lSet(String key, Object value) {
  489.         try {
  490.             redisTemplate.opsForList().rightPush(key, value);
  491.             return true;
  492.         } catch (Exception e) {
  493.             e.printStackTrace();
  494.             return false;
  495.         }
  496.     }
  498.     /**
  499.      * 将list放入缓存
  500.      * @param key 键
  501.      * @param value 值
  502.      * @param time 时间(秒)
  503.      * @return
  504.      */
  505.     public boolean lSet(String key, Object value, long time) {
  506.         try {
  507.             redisTemplate.opsForList().rightPush(key, value);
  508.             if (time > 0) expire(key, time,TimeUnit.SECONDS);
  509.             return true;
  510.         } catch (Exception e) {
  511.             e.printStackTrace();
  512.             return false;
  513.         }
  514.     }
  516.     /**
  517.      * 将list放入缓存
  518.      * @param key 键
  519.      * @param value 值
  520.      * @param time 时间(秒)
  521.      * @return
  522.      */
  523.     public boolean lSet(String key, List<Object> value) {
  524.         try {
  525.             redisTemplate.opsForList().rightPushAll(key, value);
  526.             return true;
  527.         } catch (Exception e) {
  528.             e.printStackTrace();
  529.             return false;
  530.         }
  531.     }
  533.     /**
  534.      * 将list放入缓存
  535.      * @param key 键
  536.      * @param value 值
  537.      * @param time 时间(秒)
  538.      * @return
  539.      */
  540.     public boolean lSet(String key, List<Object> value, long time) {
  541.         try {
  542.             redisTemplate.opsForList().rightPushAll(key, value);
  543.             if (time > 0) expire(key, time,TimeUnit.SECONDS);
  544.             return true;
  545.         } catch (Exception e) {
  546.             e.printStackTrace();
  547.             return false;
  548.         }
  549.     }
  551.     /**
  552.      * 根据索引修改list中的某条数据
  553.      * @param key 键
  554.      * @param index 索引
  555.      * @param value 值
  556.      * @return
  557.      */
  558.     public boolean lUpdateIndex(String key, long index,Object value) {
  559.         try {
  560.             redisTemplate.opsForList().set(key, index, value);
  561.             return true;
  562.         } catch (Exception e) {
  563.             e.printStackTrace();
  564.             return false;
  565.         }
  566.     }
  568.     /**
  569.      * 移除N个值为value
  570.      * @param key 键
  571.      * @param count 移除多少个
  572.      * @param value 值
  573.      * @return 移除的个数
  574.      */
  575.     public long lRemove(String key,long count,Object value) {
  576.         try {
  577.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  578.             return remove;
  579.         } catch (Exception e) {
  580.             e.printStackTrace();
  581.             return 0;
  582.         }
  583.     }
  585. }

发表评论

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

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

相关阅读

    相关 springboot2.X整合redis

    趁着今天休息就学习了一下redis，刚开始配置的时候遇到一些坑，现在写下来记一下，首先springboot使用的版本是2.X（我使用的是2.1.6）我的是在本地配置的，环境是w

    Myth丶恋晨Myth丶恋晨/ 0 赞/ 464 阅读