• 21 Spring Boot整合Redis

       目录

    一、Redis简介

    二、创建springboot整合redis工程

    三、添加依赖

    四、配置Yml

    五、创建Redis配置类 

    六、创建Redis工具类，封装Redis的api

    七、操作Redis 

    八、验证

         

    一、Redis简介


    简单来说 Redis 就是一个使用 C 语言开发的数据库，不过与传统数据库不同的是 Redis 的数据是存在内存中的 ，也就是它是内存数据库，所以读写速度非常快，因此 Redis 被广泛应用于缓存方向。

    另外，Redis 除了做缓存之外，Redis 也经常用来做分布式锁，甚至是消息队列。

    Redis 提供了多种数据类型来支持不同的业务场景。Redis 还支持事务 、持久化、Lua 脚本、多种集群方案。

    接口幂等性：防止重复提交

    （在互联网API接口中，由于网络超时、手动刷新等经常导致客户端重复提交数据到服务端）比如说添加一次和添加多次结果是一样的，只会执行一次

    如何防止重复提交：用注解 + AOP。通过在自定义注解里定义一些相关的字段，比如过期时间即该时间内同一用户不能重复提交请求。然后把注解按需加在接口上，最后在拦截器里判断接口上是否有该接口，如果存在则拦截。
     

    目前主流的 Java 项目都在使用 Spring Boot，那么我们就来在 Spring Boot 中整合 Redis。

             Spring Boot 使用“约定大于配置”的方式逐步的取代了早起通过 XML 进行配置的方式，使得在 Spring Boot 中整合各种库或者依赖都非常的方便。

    二、创建springboot整合redis工程

       在我们创建 Spring Boot 项目时，选择相关的 Starter 时，在 “NoSQL” 中把 “Spring Data Redis” 项勾选即可。

    三、添加依赖

           org.springframework.boot

           spring-boot-starter-data-redis

    四、配置Yml

    spring:
      redis:
        # Redis服务器地址
        host: 127.0.0.1
        # Redis服务器端口号
        port: 6379
        # 使用的数据库索引，默认是0
        database: 0
        # 连接超时时间
        timeout: 1800000
        # 设置密码
        password: "123456"
        lettuce:
          pool:
            # 最大阻塞等待时间，负数表示没有限制
            max-wait: -1
            # 连接池中的最大空闲连接
            max-idle: 5
            # 连接池中的最小空闲连接
            min-idle: 0
            # 连接池中最大连接数，负数表示没有限制
            max-active: 20

    五、创建Redis配置类 

    1. package com.crazyk.redisboot.config;
    2.  
    3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
    4. import com.fasterxml.jackson.annotation.PropertyAccessor;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.springframework.cache.annotation.CachingConfigurerSupport;
    7. import org.springframework.cache.annotation.EnableCaching;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10. import org.springframework.data.redis.connection.RedisConnectionFactory;
    11. import org.springframework.data.redis.core.*;
    12. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    13. import org.springframework.data.redis.serializer.StringRedisSerializer;
    14.  
    15.  
    16. /**
    17.  * @program: RedisBoot
    18.  * @description: redis配置类
    19.  * @author: CrazyK
    20.  * @create: 2023-06-28 15:29
    21.  **/
    22. @Configuration
    23. @EnableCaching //开启注解
    24. public class RedisConfig extends CachingConfigurerSupport {
    25.  
    26.     /**
    27.      * retemplate相关配置
    28.      */
    29.     @Bean
    30.     public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
    31.  
    32.         RedisTemplate template = new RedisTemplate<>();
    33.         // 配置连接工厂
    34.         template.setConnectionFactory(factory);
    35.  
    36.         //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
    37.         Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
    38.  
    39.         ObjectMapper om = new ObjectMapper();
    40.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
    41.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    42.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
    43.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    44.         jacksonSeial.setObjectMapper(om);
    45.  
    46.         // 值采用json序列化
    47.         template.setValueSerializer(jacksonSeial);
    48.         //使用StringRedisSerializer来序列化和反序列化redis的key值
    49.         template.setKeySerializer(new StringRedisSerializer());
    50.  
    51.         // 设置hash key 和value序列化模式
    52.         template.setHashKeySerializer(new StringRedisSerializer());
    53.         template.setHashValueSerializer(jacksonSeial);
    54.         template.afterPropertiesSet();
    55.  
    56.         return template;
    57.     }
    58.  
    59.     /**
    60.      * 对hash类型的数据操作
    61.      */
    62.     @Bean
    63.     public HashOperations hashOperations(RedisTemplate redisTemplate) {
    64.         return redisTemplate.opsForHash();
    65.     }
    66.  
    67.     /**
    68.      * 对redis字符串类型数据操作
    69.      */
    70.     @Bean
    71.     public ValueOperations valueOperations(RedisTemplate redisTemplate) {
    72.         return redisTemplate.opsForValue();
    73.     }
    74.  
    75.     /**
    76.      * 对链表类型的数据操作
    77.      */
    78.     @Bean
    79.     public ListOperations listOperations(RedisTemplate redisTemplate) {
    80.         return redisTemplate.opsForList();
    81.     }
    82.  
    83.     /**
    84.      * 对无序集合类型的数据操作
    85.      */
    86.     @Bean
    87.     public SetOperations setOperations(RedisTemplate redisTemplate) {
    88.         return redisTemplate.opsForSet();
    89.     }
    90.  
    91.     /**
    92.      * 对有序集合类型的数据操作
    93.      */
    94.     @Bean
    95.     public ZSetOperations zSetOperations(RedisTemplate redisTemplate) {
    96.         return redisTemplate.opsForZSet();
    97.     }
    98.  
    99. }

    六、创建Redis工具类，封装Redis的api

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

      七、操作Redis 
       

             使用redis工具类，本质上是使用 redis api操作。
       

       
 
      1. package com.crazyk.redisboot.controller;
      2.  
      3. import com.crazyk.redisboot.util.RedisUtil;
      4. import lombok.extern.slf4j.Slf4j;
      5. import org.springframework.web.bind.annotation.RequestMapping;
      6. import org.springframework.web.bind.annotation.RestController;
      7.  
      8. import javax.annotation.Resource;
      9.  
      10.  
      11. @Slf4j
      12. @RequestMapping("/redis")
      13. @RestController
      14. public class RedisController {
      15.  
      16.  
      17.     @Resource
      18.     private RedisUtil redisUtil;
      19.  
      20.     @RequestMapping("set")
      21.     public boolean redisset(String key, String value){
      22.         System.out.println(key+"--"+value);
      23.         return redisUtil.set(key,value);
      24.     }
      25.  
      26.     @RequestMapping("get")
      27.     public Object redisget(String key){
      28.         System.out.println(redisUtil.get(key));
      29.         return redisUtil.get(key);
      30.     }
      31.  
      32.     @RequestMapping("expire")
      33.     public boolean expire(String key,long ExpireTime){
      34.         return redisUtil.expire(key,ExpireTime);
      35.     }
      36. }
       

       

      八、验证
       

      使用浏览器发送一个请求
       

       

      去redis中自己验证
       

       

       

      
                
                    
                

                
    536. 

                    相关阅读:
      
                    
2023年，想要靠做软件测试获得高薪，还有机会吗？                            
      
数据结构之队列                            
      
全面了解三极管——三极管用作开关管2                            
      
统信UOS技术开放日：四大领域全面接入AI大模型能力                            
      
【QT】Hello World!                            
      
备战数学建模1——MATLAB矩阵相关                            
      
圆角矩形不是圆：圆角的画法和二阶连续性                            
      
electron初学                            
      
ICE常见编译和运行(异常)错误                            
      
dubbo 接口的测试方法汇总                            
      
                          
                
      537. 
                
    537. 
                    原文地址：https://blog.csdn.net/qq_41946216/article/details/132765059
                
      538.