devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

从0到1学SpringCloud——10 springboot集成redis缓存_spring cloud data redis

作者：Gausst松鼠会 | 2024-05-08 11:04:56

赞

踩

spring cloud data redis

目录

一、前言

二、pom依赖

三、redis配置

四、代码测试

五、序列化配置

六、工具类改造

七、注意事项

一、前言

本篇主要讲解springboot集成redis的使用方式，工具类的封装及使用。

二、pom依赖

  1. <!-- 加入redis的处理 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-data-redis</artifactId>
  5. </dependency>
  6. <!-- lettuce pool 缓存连接池 -->
  7. <dependency>
  8.     <groupId>org.apache.commons</groupId>
  9.     <artifactId>commons-pool2</artifactId>
  10. </dependency>

如果没有引用commons-pool2依赖

项目启动控制台报错：org.apache.commons.pool2.impl.GenericObjectPoolConfig

  1. Caused by: java.lang.ClassNotFoundException: org.apache.commons.pool2.impl.GenericObjectPoolConfig
  2. 	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641) ~[na:na]
  3. 	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188) ~[na:na]
  4. 	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521) ~[na:na]
  5. 	... 58 common frames omitted

三、redis配置

  1. # Redis服务器地址
  2. spring.redis.host=127.0.0.1
  3. # Redis服务器连接端口
  4. spring.redis.port=6379 
  5. # Redis服务器连接密码（默认为空）
  6. #spring.redis.password=redis
  7. # Redis数据库索引（默认为0）
  8. spring.redis.database=0
  9. # 连接超时时间（毫秒）
  10. spring.redis.timeout=10000
  11. # Redis默认情况下有16个分片，这里配置具体使用的分片，默认是0
  12. spring.redis.database=0
  13. # 连接池最大连接数（使用负值表示没有限制） 默认 8
  14. spring.redis.lettuce.pool.max-active=8
  15. # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
  16. spring.redis.lettuce.pool.max-wait=-1
  17. # 连接池中的最大空闲连接 默认 8
  18. spring.redis.lettuce.pool.max-idle=8
  19. # 连接池中的最小空闲连接 默认 0
  20. spring.redis.lettuce.pool.min-idle=0

配置项中指定了数据库索引：

# Redis数据库索引（默认为0）
spring.redis.database=0

redis有十六个库，相当于一个数据库的中的十六张表，可以用来数据分类，或者不同测试环境数据区分。

四、代码测试

  1. import org.springframework.data.redis.core.RedisTemplate;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  4.  
  5. import javax.annotation.Resource;
  6.  
  7. /**
  8.  * @ClassName: DataController
  9.  * @Description redis链接测试
  10.  * @author 月夜烛峰
  11.  * @date 2022/9/5 19:40
  12.  */
  13. @RestController
  14. @RequestMapping("data")
  15. public class DataController {
  16.  
  17.     @Resource
  18.     RedisTemplate<String, Object> redisTemplate;
  19.  
  20.     @RequestMapping("redis")
  21.     public Object showRedis(){
  22.         redisTemplate.opsForValue().set("zhufeng-test", "测试");
  23.         return redisTemplate.opsForValue().get("zhufeng-test");
  24.     }
  25. }

@Resource
RedisTemplate<String, Object> redisTemplate;

完成配置后，在项目启动时，会完成redis的自动装配，springboot可以获取到redisTemplate。

springboot自动装配的原理可参考：

《深入理解springboot的自动配置「源码分析/图文详解」》

启动项目，访问http://127.0.0.1:8080/data/redis

通过redis客户端进入查看：

代码中添加的key是 zhufeng-test，好像有些出入。

RedisTemplate设置redis的key时出现\xac\xed\x00\x05t\x00\x0f前缀 
出现这种乱码前缀的原因是没有进行序列化，因此导致在传输过程出现乱码问题。
RedisTemplate类中默认是没有设置序列化的。

五、序列化配置

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.springframework.cache.annotation.CachingConfigurerSupport;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.data.redis.connection.RedisConnectionFactory;
  8. import org.springframework.data.redis.core.RedisTemplate;
  9. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  10. import org.springframework.data.redis.serializer.StringRedisSerializer;
  11.  
  12. /**
  13.  * @ClassName: RedisConfig
  14.  * @Description redis序列化配置
  15.  * @author 月夜烛峰
  16.  * @date 2022/9/13 18:47
  17.  */
  18. @Configuration
  19. public class RedisConfig extends CachingConfigurerSupport {
  20.  
  21.     /**
  22.      * 重新定义redisTemplate序列化方式
  23.      * @param factory
  24.      * @return
  25.      */
  26.     @Bean
  27.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
  28.         RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
  29.         template.setConnectionFactory(factory);
  30.         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
  31.         ObjectMapper om = new ObjectMapper();
  32.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  33.         jackson2JsonRedisSerializer.setObjectMapper(om);
  34.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  35.         // key采用String的序列化方式
  36.         template.setKeySerializer(stringRedisSerializer);
  37.         // hash的key也采用String的序列化方式
  38.         template.setHashKeySerializer(stringRedisSerializer);
  39.         // value序列化方式采用jackson
  40.         template.setValueSerializer(jackson2JsonRedisSerializer);
  41.         // hash的value序列化方式采用jackson
  42.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  43.         template.afterPropertiesSet();
  44.         return template;
  45.     }
  46. }

重新运行项目：

变化：

key和value都没有了前缀

key通过String格式进行序列化，显示正常。

value通过jackson方式序列化，显示序列化后结果。

value也可以不做序列化处理，但容易出现安全隐患，例如：信息泄露。 

六、工具类改造

在使用过程中，有时候使用RedisTemplate不是很方便，尤其是一些静态方法，所以可以把RedisTemplate进行改造，封装到静态工具类中。

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

获取spring上下文代码：

  1. package com.zhufeng.base.redis;
  2.  
  3. import org.springframework.beans.BeansException;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.ApplicationContextAware;
  6. import org.springframework.stereotype.Component;
  7.  
  8. /**
  9.  * @ClassName: SpringContextUtil
  10.  * @Description 获取spring上下文信息
  11.  * @author 月夜烛峰
  12.  * @date 2022/9/13 18:18
  13.  */
  14. @Component
  15. public class SpringContextUtil implements ApplicationContextAware {
  16.  
  17.     private static ApplicationContext applicationContext = null;
  18.  
  19.     @Override
  20.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  21.         if (SpringContextUtil.applicationContext == null) {
  22.             SpringContextUtil.applicationContext = applicationContext;
  23.         }
  24.     }
  25.  
  26.  
  27.     //获取applicationContext
  28.     public static ApplicationContext getApplicationContext() {
  29.         return applicationContext;
  30.     }
  31.  
  32.     //通过name获取 Bean.
  33.     public static Object getBean(String name) {
  34.         return getApplicationContext().getBean(name);
  35.     }
  36.  
  37.     //通过class获取Bean.
  38.     public static <T> T getBean(Class<T> clazz) {
  39.         return getApplicationContext().getBean(clazz);
  40.     }
  41.  
  42.     //通过name,以及Clazz返回指定的Bean
  43.     public static <T> T getBean(String name, Class<T> clazz) {
  44.         return getApplicationContext().getBean(name, clazz);
  45.  
  46.     }
  47. }

测试：

  1. @RequestMapping("redis")
  2. public Object showRedis(){
  3.     redisTemplate.opsForValue().set("zhufeng-test", "测试");
  4.     //return redisTemplate.opsForValue().get("zhufeng-test");
  5.     return ZFRedisUtil.get("zhufeng-test");
  6. }

可以正常获取value。

七、注意事项

RedisTemplate使用起来虽然非常方便，但是在高并发场景下需要做一些性能优化，一般项目使用时，没什么问题。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/554226
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号