Redis（五）整合：SpringBoot如何整合Redis？

比眉伴天荒 2023-01-09 03:57 264阅读 0赞

前言

SpringBoot应该不用过多介绍了吧！是Spring当前最火的一个框架，既然学习了Redis，我们肯定是要在实际项目中使用，那么肯定首选整合SpringBoot啦！

简单介绍下SpringBoot对Jedis的支持吧，在1.×版本的时候，SpringBoot的底层还是使用Jedis来连接Redis的，但是在2.×版本后，就换成了Lettuce。两者的区别如下：
Jedis: 采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用 jedis pool 连接池！ 更像 BIO 模式！
Lettuce: 采用netty，实例可以再多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据了，更像 NIO 模式！

  1. 添加POM依赖：

    1.     <!--集成redis-->
    2.     <dependency>
    3.         <groupId>org.springframework.boot</groupId>
    4.         <artifactId>spring-boot-starter-data-redis</artifactId>
    5.         <version>2.1.7.RELEASE</version>
    6.     </dependency>
    7.     <!--序列化-->
    8.     <dependency>
    9.         <groupId>com.alibaba</groupId>
    10.         <artifactId>fastjson</artifactId>
    11.         <version>1.2.54</version>
    12.         <scope>compile</scope>
    13.     </dependency>
    14.     <!--lombok,自动生成set、get等方法-->
    15.     <dependency>
    16.         <groupId>org.projectlombok</groupId>
    17.         <artifactId>lombok</artifactId>
    18.         <version>1.18.10</version>
    19.         <scope>compile</scope>
    20.     </dependency>

  2. 配置连接的application.yml文件：

    server:
    port: 10001

    spring:
    redis:

    1. host: 127.0.0.1
    2. port: 6379

  3. 测试连接：我们写个测试方法来进行最基本的连接测试！

    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.redis.core.RedisTemplate;

    @SpringBootTest
    public class testRedis { 

    1. @Autowired(required = false)
    2. private RedisTemplate redisTemplate;
    4. @Test
    5. void getName(){ 
    6.     redisTemplate.opsForValue().set("name","dadadingdada!");
    7.     System.out.println(redisTemplate.opsForValue().get("name"));
    8. }

    }

运行效果如下！证明Redis连接成功！并且加数据获取数据也成功了！
在这里插入图片描述

  1. 其他方法如下：

    // redisTemplate #操作不同的数据类型，api和我们的指令是一样的
    // opsForValue #操作字符串 类似String
    // opsForList #操作List 类似List
    // opsForSet #操作set
    // opsForHash #操作hash
    // opsForZSet #操作zset
    // opsForGeo #操作geo
    // opsForHyperLogLog #操作HyperLogLog
    // 除了进本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务，和基本的 CRUD
    // 获取redis的连接对象
    // RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
    // connection.flushDb();
    // connection.flushAll();

证明如果是用基本RedisTemplate类来操作Redis的话，是基本上可以达到所有的效果的，因为具体方法和命令大体一致！

  1. 对象的保存和读取
    新增一个User类：

    import lombok.Data;

    @Data
    public class User { 

    1. private String name;
    2. private Integer age;
    3. private Integer high;

    }

测试代码如下：

  1. @Test
  2.     void setObject(){ 
  3.         User user = new User();
  4.         user.setName("dingdada");
  5.         user.setAge(23);
  6.         user.setHigh(172);
  7.         redisTemplate.opsForValue().set("user",user);
  8.         System.out.println(redisTemplate.opsForValue().get("user"));
  9.     }

报错如下：
在这里插入图片描述
结论：所以在操作Redis中，关于对象的保存我们得序列化才可以正常操作！

  1. 自定义封装RedisTemplate类
    上面说了大体上可以实现，但是为了在工作中更容易操作Redis，我们一般重新封装RedisTemplate类，如下所示：

    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;

    @Configuration
    public class RedisConfig { 

    1.  // 这是我给大家写好的一个固定模板，大家在企业中，拿去就可以直接使用！
    2.  // 自己定义了一个RedisTemplate
    3.  @Bean
    4.  @SuppressWarnings("all")
    5.  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { 
    6.      // 我们为了自己开发方便，一般直接使用 <String, Object>
    7.      RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
    8.      template.setConnectionFactory(factory);
    9.      // Json序列化配置
    10.      Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    11.      ObjectMapper om = new ObjectMapper();
    12.      om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    13.      om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    14.      jackson2JsonRedisSerializer.setObjectMapper(om);
    15.      // String 的序列化
    16.      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    17.      // key采用String的序列化方式
    18.      template.setKeySerializer(stringRedisSerializer);
    19.      // hash的key也采用String的序列化方式
    20.      template.setHashKeySerializer(stringRedisSerializer);
    21.      // value序列化方式采用jackson
    22.      template.setValueSerializer(jackson2JsonRedisSerializer);
    23.      // hash的value序列化方式采用jackson
    24.      template.setHashValueSerializer(jackson2JsonRedisSerializer);
    25.      template.afterPropertiesSet();
    26.      return template;
    27.  }

    }

序列化完成后我们再试试对象的添加获取：
在这里插入图片描述
NICE！一切正常！

  1. 封装RedisUtils类：
    在实际工作中，我们不可能用RedisTemplate 来操作Redis的，因为实在太繁琐，所以我们一般自定义一个RedisUtils工具类来操作Redis！

    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;

    import javax.annotation.Resource;
    import java.util.Collection;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;

    @Component
    public final class RedisUtil { 

    1. @Resource
    2. private RedisTemplate<String, Object> redisTemplate;
  1.     public Set<String> keys(String keys){ 
  2.         try { 
  3.             return redisTemplate.keys(keys);
  4.         }catch (Exception e){ 
  5.             e.printStackTrace();
  6.             return null;
  7.         }
  8.     }
  10.     /** * 指定缓存失效时间 * @param key 键 * @param time 时间(秒) * @return */
  11.     public boolean expire(String key, long time) { 
  12.         try { 
  13.             if (time > 0) { 
  14.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  15.             }
  16.             return true;
  17.         } catch (Exception e) { 
  18.             e.printStackTrace();
  19.             return false;
  20.         }
  21.     }
  22.     /** * 根据key 获取过期时间 * @param key 键 不能为null * @return 时间(秒) 返回0代表为永久有效 */
  23.     public long getExpire(String key) { 
  24.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  25.     }
  26.     /** * 判断key是否存在 * @param key 键 * @return true 存在 false不存在 */
  27.     public boolean hasKey(String key) { 
  28.         try { 
  29.             return redisTemplate.hasKey(key);
  30.         } catch (Exception e) { 
  31.             e.printStackTrace();
  32.             return false;
  33.         }
  34.     }
  35.     /** * 删除缓存 * @param key 可以传一个值 或多个 */
  36.     @SuppressWarnings("unchecked")
  37.     public void del(String... key) { 
  38.         if (key != null && key.length > 0) { 
  39.             if (key.length == 1) { 
  40.                 redisTemplate.delete(key[0]);
  41.             } else { 
  42.                 redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
  43.             }
  44.         }
  45.     }
  46.     /** * 普通缓存获取 * @param key 键 * @return 值 */
  47.     public Object get(String key) { 
  48.         return key == null ? null : redisTemplate.opsForValue().get(key);
  49.     }
  50.     /** * 普通缓存放入 * @param key 键 * @param value 值 * @return true成功 false失败 */
  51.     public boolean set(String key, Object value) { 
  52.         try { 
  53.             redisTemplate.opsForValue().set(key, value);
  54.             return true;
  55.         } catch (Exception e) { 
  56.             e.printStackTrace();
  57.             return false;
  58.         }
  59.     }
  60.      /** * 普通缓存放入, 不存在放入，存在返回 * @param key 键 * @param value 值 * @return true成功 false失败 */
  61.     public boolean setnx(String key, Object value) { 
  62.         try { 
  63.             redisTemplate.opsForValue().setIfAbsent(key,value);
  64.             return true;
  65.         } catch (Exception e) { 
  66.             e.printStackTrace();
  67.             return false;
  68.         }
  69.     }
  70.     /** * 普通缓存放入并设置时间 * @param key 键 * @param value 值 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 * @return true成功 false 失败 */
  71.     public boolean set(String key, Object value, long time) { 
  72.         try { 
  73.             if (time > 0) { 
  74.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  75.             } else { 
  76.                 set(key, value);
  77.             }
  78.             return true;
  79.         } catch (Exception e) { 
  80.             e.printStackTrace();
  81.             return false;
  82.         }
  83.     }
  85.   /** * 普通缓存放入并设置时间,不存在放入，存在返回 * @param key 键 * @param value 值 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 * @return true成功 false 失败 */
  86.     public boolean setnx(String key, Object value, long time) { 
  87.         try { 
  88.             if (time > 0) { 
  89.                 redisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
  90.             } else { 
  91.                 set(key, value);
  92.             }
  93.             return true;
  94.         } catch (Exception e) { 
  95.             e.printStackTrace();
  96.             return false;
  97.         }
  98.     }
  100.     /** * 递增 * @param key 键 * @param delta 要增加几(大于0) * @return */
  101.     public long incr(String key, long delta) { 
  102.         if (delta < 0) { 
  103.             throw new RuntimeException("递增因子必须大于0");
  104.         }
  105.         return redisTemplate.opsForValue().increment(key, delta);
  106.     }
  107.     /** * 递减 * @param key 键 * @param delta 要减少几(小于0) * @return */
  108.     public long decr(String key, long delta) { 
  109.         if (delta < 0) { 
  110.             throw new RuntimeException("递减因子必须大于0");
  111.         }
  112.         return redisTemplate.opsForValue().increment(key, -delta);
  113.     }
  114.     /** * HashGet * @param key 键 不能为null * @param item 项 不能为null * @return 值 */
  115.     public Object hget(String key, String item) { 
  116.         return redisTemplate.opsForHash().get(key, item);
  117.     }
  118.     /** * 获取hashKey对应的所有键值 * @param key 键 * @return 对应的多个键值 */
  119.     public Map<Object, Object> hmget(String key) { 
  120.         return redisTemplate.opsForHash().entries(key);
  121.     }
  122.     /** * HashSet * @param key 键 * @param map 对应多个键值 * @return true 成功 false 失败 */
  123.     public boolean hmset(String key, Map<String, Object> map) { 
  124.         try { 
  125.             redisTemplate.opsForHash().putAll(key, map);
  126.             return true;
  127.         } catch (Exception e) { 
  128.             e.printStackTrace();
  129.             return false;
  130.         }
  131.     }
  132.     /** * HashSet 并设置时间 * @param key 键 * @param map 对应多个键值 * @param time 时间(秒) * @return true成功 false失败 */
  133.     public boolean hmset(String key, Map<String, Object> map, long time) { 
  134.         try { 
  135.             redisTemplate.opsForHash().putAll(key, map);
  136.             if (time > 0) { 
  137.                 expire(key, time);
  138.             }
  139.             return true;
  140.         } catch (Exception e) { 
  141.             e.printStackTrace();
  142.             return false;
  143.         }
  144.     }
  145.     /** * 向一张hash表中放入数据,如果不存在将创建 * @param key 键 * @param item 项 * @param value 值 * @return true 成功 false失败 */
  146.     public boolean hset(String key, String item, Object value) { 
  147.         try { 
  148.             redisTemplate.opsForHash().put(key, item, value);
  149.             return true;
  150.         } catch (Exception e) { 
  151.             e.printStackTrace();
  152.             return false;
  153.         }
  154.     }
  155.     /** * 向一张hash表中放入数据,如果不存在将创建 * @param key 键 * @param item 项 * @param value 值 * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 * @return true 成功 false失败 */
  156.     public boolean hset(String key, String item, Object value, long time) { 
  157.         try { 
  158.             redisTemplate.opsForHash().put(key, item, value);
  159.             if (time > 0) { 
  160.                 expire(key, time);
  161.             }
  162.             return true;
  163.         } catch (Exception e) { 
  164.             e.printStackTrace();
  165.             return false;
  166.         }
  167.     }
  168.     /** * 删除hash表中的值 * @param key 键 不能为null * @param item 项 可以使多个 不能为null */
  169.     public void hdel(String key, Object... item) { 
  170.         redisTemplate.opsForHash().delete(key, item);
  171.     }
  172.     /** * 判断hash表中是否有该项的值 * @param key 键 不能为null * @param item 项 不能为null * @return true 存在 false不存在 */
  173.     public boolean hHasKey(String key, String item) { 
  174.         return redisTemplate.opsForHash().hasKey(key, item);
  175.     }
  176.     /** * hash递增 如果不存在,就会创建一个 并把新增后的值返回 * @param key 键 * @param item 项 * @param by 要增加几(大于0) * @return */
  177.     public double hincr(String key, String item, double by) { 
  178.         return redisTemplate.opsForHash().increment(key, item, by);
  179.     }
  180.     /** * hash递减 * @param key 键 * @param item 项 * @param by 要减少记(小于0) * @return */
  181.     public double hdecr(String key, String item, double by) { 
  182.         return redisTemplate.opsForHash().increment(key, item, -by);
  183.     }
  184.     /** * 根据key获取Set中的所有值 * @param key 键 * @return */
  185.     public Set<Object> sGet(String key) { 
  186.         try { 
  187.             return redisTemplate.opsForSet().members(key);
  188.         } catch (Exception e) { 
  189.             e.printStackTrace();
  190.             return null;
  191.         }
  192.     }
  193.     /** * 根据value从一个set中查询,是否存在 * @param key 键 * @param value 值 * @return true 存在 false不存在 */
  194.     public boolean sHasKey(String key, Object value) { 
  195.         try { 
  196.             return redisTemplate.opsForSet().isMember(key, value);
  197.         } catch (Exception e) { 
  198.             e.printStackTrace();
  199.             return false;
  200.         }
  201.     }
  202.     /** * 将数据放入set缓存 * @param key 键 * @param values 值 可以是多个 * @return 成功个数 */
  203.     public long sSet(String key, Object... values) { 
  204.         try { 
  205.             return redisTemplate.opsForSet().add(key, values);
  206.         } catch (Exception e) { 
  207.             e.printStackTrace();
  208.             return 0;
  209.         }
  210.     }
  211.     /** * 将set数据放入缓存 * @param key 键 * @param time 时间(秒) * @param values 值 可以是多个 * @return 成功个数 */
  212.     public long sSetAndTime(String key, long time, Object... values) { 
  213.         try { 
  214.             Long count = redisTemplate.opsForSet().add(key, values);
  215.             if (time > 0){ 
  216.                 expire(key, time);
  217.             }
  218.             return count;
  219.         } catch (Exception e) { 
  220.             e.printStackTrace();
  221.             return 0;
  222.         }
  223.     }
  224.     /** * 获取set缓存的长度 * @param key 键 * @return */
  225.     public long sGetSetSize(String key) { 
  226.         try { 
  227.             return redisTemplate.opsForSet().size(key);
  228.         } catch (Exception e) { 
  229.             e.printStackTrace();
  230.             return 0;
  231.         }
  232.     }
  233.     /** * 移除值为value的 * @param key 键 * @param values 值 可以是多个 * @return 移除的个数 */
  234.     public long setRemove(String key, Object... values) { 
  235.         try { 
  236.             Long count = redisTemplate.opsForSet().remove(key, values);
  237.             return count;
  238.         } catch (Exception e) { 
  239.             e.printStackTrace();
  240.             return 0;
  241.         }
  242.     }
  243.     // ===============================list=================================
  244.     /** * 获取list缓存的内容 * @param key 键 * @param start 开始 * @param end 结束 0 到 -1代表所有值 * @return */
  245.     public List<Object> lGet(String key, long start, long end) { 
  246.         try { 
  247.             return redisTemplate.opsForList().range(key, start, end);
  248.         } catch (Exception e) { 
  249.             e.printStackTrace();
  250.             return null;
  251.         }
  252.     }
  253.     /** * 获取list缓存的长度 * @param key 键 * @return */
  254.     public long lGetListSize(String key) { 
  255.         try { 
  256.             return redisTemplate.opsForList().size(key);
  257.         } catch (Exception e) { 
  258.             e.printStackTrace();
  259.             return 0;
  260.         }
  261.     }
  262.     /** * 通过索引 获取list中的值 * @param key 键 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 * @return */
  263.     public Object lGetIndex(String key, long index) { 
  264.         try { 
  265.             return redisTemplate.opsForList().index(key, index);
  266.         } catch (Exception e) { 
  267.             e.printStackTrace();
  268.             return null;
  269.         }
  270.     }
  271.     /** * 将list放入缓存 * @param key 键 * @param value 值 * @return */
  272.     public boolean lSet(String key, Object value) { 
  273.         try { 
  274.             redisTemplate.opsForList().rightPush(key, value);
  275.             return true;
  276.         } catch (Exception e) { 
  277.             e.printStackTrace();
  278.             return false;
  279.         }
  280.     }
  281.     /** * 将list放入缓存 * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
  282.     public boolean lSet(String key, Object value, long time) { 
  283.         try { 
  284.             redisTemplate.opsForList().rightPush(key, value);
  285.             if (time > 0){ 
  286.                 expire(key, time);
  287.             }
  288.             return true;
  289.         } catch (Exception e) { 
  290.             e.printStackTrace();
  291.             return false;
  292.         }
  293.     }
  294.     /** * 将list放入缓存 * @param key 键 * @param value 值 * @return */
  295.     public boolean lSet(String key, List<Object> value) { 
  296.         try { 
  297.             redisTemplate.opsForList().rightPushAll(key, value);
  298.             return true;
  299.         } catch (Exception e) { 
  300.             e.printStackTrace();
  301.             return false;
  302.         }
  303.     }
  304.     /** * 将list放入缓存 * * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
  305.     public boolean lSet(String key, List<Object> value, long time) { 
  306.         try { 
  307.             redisTemplate.opsForList().rightPushAll(key, value);
  308.             if (time > 0){ 
  309.                 expire(key, time);
  310.             }
  311.             return true;
  312.         } catch (Exception e) { 
  313.             e.printStackTrace();
  314.             return false;
  315.         }
  316.     }
  317.     /** * 根据索引修改list中的某条数据 * @param key 键 * @param index 索引 * @param value 值 * @return */
  318.     public boolean lUpdateIndex(String key, long index, Object value) { 
  319.         try { 
  320.             redisTemplate.opsForList().set(key, index, value);
  321.             return true;
  322.         } catch (Exception e) { 
  323.             e.printStackTrace();
  324.             return false;
  325.         }
  326.     }
  327.     /** * 移除N个值为value * @param key 键 * @param count 移除多少个 * @param value 值 * @return 移除的个数 */
  328.     public long lRemove(String key, long count, Object value) { 
  329.         try { 
  330.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  331.             return remove;
  332.         } catch (Exception e) { 
  333.             e.printStackTrace();
  334.             return 0;
  335.         }
  336.     }
  337. }

基本上常用的Redis操作都写在这里了，我们在工作中需要用什么，直接通过RedisUtils来使用即可！

  1. 使用RedisUtils
    ①首先将springboot项目启动起来：
    在这里插入图片描述
    ②添加Contoller在web上测试添加和获取！
    在这里插入图片描述

③测试工具类的基本使用：
在谷歌浏览器输入：返回成功
在这里插入图片描述
测试获取：获取成功！
在这里插入图片描述

9.总结：其实这篇讲了这么多，大家可以发现，SpringBoot真的是极度方便，整合Redis之后我们只需要简单的操作即可完美使用Redis！
但是，前面的内容还都是Redis相关的基础，接下来我将继续整理关于Redis的进阶知识！

Redis扩展：Redis学习汇总

路漫漫其修远兮，吾必将上下求索~
到此关于SpringBoot如何整合Redis的讲解就算告一段落了，如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧**转载请注明出处哦**

发表评论

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

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

相关阅读