• 从0到1学SpringCloud——10 springboot集成redis缓存

    目录

    一、前言

    二、pom依赖

    三、redis配置

    四、代码测试

    五、序列化配置

    六、工具类改造

    七、注意事项

    一、前言

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

    二、pom依赖

    2. <dependency>
    3.     <groupId>org.springframework.bootgroupId>
    4.     <artifactId>spring-boot-starter-data-redisartifactId>
    5. dependency>
    7. <dependency>
    8.     <groupId>org.apache.commonsgroupId>
    9.     <artifactId>commons-pool2artifactId>
    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 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 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 redisTemplate(RedisConnectionFactory factory) {
    28.         RedisTemplate template = new RedisTemplate();
    29.         template.setConnectionFactory(factory);
    30.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(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. }
      47.  

      重新运行项目：
       

       

       
 
      变化：
       
 
      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 redisTemplate = (RedisTemplate)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 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 map){
      195.         try {
      196.             redisTemplate.opsForHash().putAll(key, map);
      197.             return true;
      198.         } catch (Exception e) {
      199.             log.error("RedisUtils hmset(String key, Map 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 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 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 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 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 value) {
      485.         try {
      486.             redisTemplate.opsForList().rightPushAll(key, value);
      487.             return true;
      488.         } catch (Exception e) {
      489.             log.error("RedisUtils lSet(String key, List 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 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 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 scan(String key){
      553.         Set execute = redisTemplate.execute(new RedisCallback>() {
      554.  
      555.             @Override
      556.             public Set doInRedis(RedisConnection connection) throws DataAccessException {
      557.  
      558.                 Set 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() {
      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.  
        594.  

        获取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 getBean(Class clazz) {
        39.         return getApplicationContext().getBean(clazz);
        40.     }
        41.  
        42.     //通过name,以及Clazz返回指定的Bean
        43.     public static  T getBean(String name, Class 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使用起来虽然非常方便，但是在高并发场景下需要做一些性能优化，一般项目使用时，没什么问题。
         

         

         
        
                
                    
                

                
      594. 

                    相关阅读:
        
                    
量化交易的相对强弱（RSI ）指标计算及策略                            
        
Shiro-集成验证码                            
        
JVM 重要知识梳理                            
        
Linux应用开发 - 多线程编程                            
        
[论文笔记] MapReduce: Simplified Data Processing on Large Clusters                            
        
OpenGL 摄像机视角详解                            
        
HDD-FAT32 ZIP-FAT32 HDD-FAT16 ZIP-FAT16 HDD-NTFS                            
        
MYSQL第一章节DDL数据定义语言的操作（DDL-数据库操作，DDL-操作表-查询，DDL-操作表-修改,数据库的基本类型）                            
        
HtmlUnit、Jsoup、webmagic基本介绍                            
        
八数码问题                            
        
                            
                
        595. 
                
      595. 
                    原文地址：https://blog.csdn.net/yueyezhufeng/article/details/126846694
                
        596.