devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot整合Redis_springboot redis

作者：我家小花儿 | 2024-02-27 10:22:08

赞

踩

springboot redis

SpringBoot中的Redis

在 SpringBoot2.x 之后，原来使用的jedis被替换为了lettuce?

jedis : 采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用 jedis pool 连接 池！ 更像 BIO 模式

lettuce : 采用netty，实例可以再多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据 了，更像 NIO 模式

环境搭建与测试

1.创建一个SpringBoot项目。选择要导入的依赖。最重要的是导入Redis依赖。

2.编写配置文件。使用WIndows本地的Redis（确保Redis运行）

3.在测试类中进行测试

五大数据类型

  • opsForValue() 操作字符串 类似String
  • opsForList() 操作List 类似List
  • opsForSet() 操作Set 类似Set
  • opsForZSet() 操作ZSet 类似ZSet
  • opsForHash() 操作Hash 类似Hash

特殊数据类型

  • opsForGeo()
  • opsForHyperLogLog()
  1. @Test
  2. void contextLoads() {
  3.  
  4.     //五大数据类型
  5.     //opsForValue() 操作字符串 类似String
  6.     //opsForList() 操作List 类似List
  7.     //opsForSet() 操作Set 类似Set
  8.     //opsForZSet() 操作ZSet 类似ZSet
  9.     //opsForHash() 操作Hash 类似Hash
  10.  
  11.     //特殊数据类型
  12.     //opsForGeo()
  13.     //opsForHyperLogLog()
  14.  
  15.     //除了基本的操作，我们常用的方法都可以通过redisTemplate操作。比如事务，和基本的CRUD
  16.     redisTemplate.opsForValue().set("mykey", "kylin");
  17.     System.out.println(redisTemplate.opsForValue().get("mykey"));
  18. }
  19. 复制代码

自定义RedisTemplate

  1. 	@Bean
  2. 	@ConditionalOnMissingBean(name = "redisTemplate")
  3. 	
  4. 	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
  5. 			throws UnknownHostException {
  6.          // 默认的 RedisTemplate 没有过多的设置，redis 对象都是需要序列化！
  7. 		// 两个泛型都是 Object, Object 的类型，我们后使用需要强制转换 <String, Object>
  8. 		RedisTemplate<Object, Object> template = new RedisTemplate<>();
  9. 		template.setConnectionFactory(redisConnectionFactory);
  10. 		return template;
  11. 	}
  12.  
  13. 	@Bean
  14. 	@ConditionalOnMissingBean
  15. 	// 由于 String 是redis中最常使用的类型，所以说单独提出来了一个bean！
  16. 	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
  17. 			throws UnknownHostException {
  18. 		StringRedisTemplate template = new StringRedisTemplate();
  19. 		template.setConnectionFactory(redisConnectionFactory);
  20. 		return template;
  21. 	}
  22. 复制代码

首先我们编写一个实体类User

  1. @Component
  2. @Data
  3. @AllArgsConstructor
  4. @NoArgsConstructor
  5. //所有的pojo都要序列化
  6. public class User implements Serializable {
  7.  
  8.     private String name;
  9.     private int age;
  10. }
  11. 复制代码

在测试类中测试像Redis存储一个User对象

  1. @Test
  2. void test2() {
  3.     //真实的开发一般都是用Json来传递对象
  4.     User user = new User("kylin", 18);
  5.     //String jsonUser = new ObjectMapper().writeValueAsString(user)
  6.     redisTemplate.opsForValue().set("user", user);
  7.     System.out.println(redisTemplate.opsForValue().get("user"));
  8. }
  9. 复制代码

成功存储并获取到~

但是我们在使用redis-cli连接redis。发现在redis中存储的数据变成了像乱码一样的字符串。

只是因为redis默认序列化时会使用jdk序列化器。要想解决这样的问题题我们就要自定义配置RedisTemplate

1.首先我们创建一个config包在包下编写一个RedisConfig配置类。以后使用直接复制就行。

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

2.此外由于RedisTemplate的提供的方法也和操作原生redis又较大的区别。所以编写一个工具类RedisUtil将其提供的API进行进一步的封装更像操作原生redis一样。同理以后使用复制即可

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

3.在测试类中进行测试。使用自定义的RedisTemplate和RedisUtil

在通过redis-cli查看。成功！

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

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

  

闽ICP备14008679号