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

SpringBoot中如何正确使用Redis(详细介绍，原理讲解，企业版)

作者：黑客灵魂 | 2024-08-03 22:41:24

赞

踩

SpringBoot中如何正确使用Redis(详细介绍，原理讲解，企业版)

1.引入Redis依赖

  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-redis</artifactId>
  4.         </dependency>

2.配置Redis的连接信息(application.yml)

实际开发中有两个一个是开发环境application-dev，一个是生产环境application-prod。

  1. spring:
  2.   redis:
  3.     database: 0           # Redis服务器数据库
  4.     host: 127.0.0.1       # Redis服务器地址
  5.     port: 6379            # Redis服务器连接端口
  6.     password: 123456      # Redis服务器连接密码（默认为空）
  7.     timeout: 6000         # Redis连接超时时间（毫秒）

3.创建RedisConfig主要是通过@Bean注入RedisTemplate。

一般我们配置RedisTemplate的时候，配置类一大堆东西，接下来我从最简单的配置到最终的配置依次测试和演示为什么需要这么配置的原因。

(1)最简单的配置，直接new RedisTemplate通过@Bean注入,写个简单的controller测试。

  1. @Configuration
  2. public class RedisConfig {
  3.     @Bean
  4.     public RedisTemplate redisTemplate(){
  5.         return new RedisTemplate();
  6.     }
  7. }
  1. @RestController
  2. @RequestMapping("/test")
  3. public class RedisController {
  4.  
  5.     @Autowired
  6.     private RedisTemplate redisTemplate;
  7.  
  8.     @RequestMapping("/aaa")
  9.     public String testA(){
  10.         redisTemplate.opsForValue().set("test","123456");
  11.         return "success";
  12.     }
  13. }

接下来我么直接启动项目来看。

很明显直接报错，说我们需要一个Redis的连接工厂，所以接下来我们去配置Redis的连接工厂。

(2) 配置Reids的连接工厂。如何去配置。
稍微分析一下源码，这个工厂是什么，我们应该如何如给他赋值。

上面这个是RedisTemplate的set赋值方法，可见需要一个RedisConnectionFactory，这个又是什么呢？继续点进去。

很明显这是个接口，那我们要找他的实现类，

可见一共有两个实现类 JedisConnectionFactory 和 LettuceConnectionFactory 。

好的，有耐心分析到这说明你已经有分析源码的动力了！！！！！！！！！太深了咱也没必要挖。

接下来看我们如何去配置

  1. @Configuration
  2. public class RedisConfig {
  3.     @Bean
  4.     public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
  5.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  6.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  7.         return redisTemplate;
  8.     }
  9. }

这里不知道大家有没有疑问，为什么RedisConnectionFactory作为形参传过来，我们直接set就行，我们并没有给它创建对象，按理说它不应该是null吗？实际上这个方法是Spring自动调用的，参数呢也是Spring自动去到Spring的容器中寻找然后自动装配上去的，所以此处不为空，那我们怎么证明呢？直接打个断点去看。

此处我们可以直接看出它不是null，而且可以看出它默认使用的工厂LettuceConnectionFactory,
所以我们不用担心直接使用即可。

(3)我们配置完我们工厂后又会有新问题：乱码问题怎么解决。

首先我们去随便存储一个key-value到我们的Redis数据库中。代码：

  1. @RestController
  2. @RequestMapping("/test")
  3. public class RedisController {
  4.     @Autowired
  5.     private RedisTemplate<String,Object> redisTemplate;
  6.     @RequestMapping("/aaa")
  7.     public String testA(){
  8.         redisTemplate.opsForValue().set("test","123456");
  9.         return "success";
  10.     }
  11. }

结果

很明显，出现了奇怪的东？首先它并不是乱码，他只是存储的时候前面保存了序列化的元数据部分，跟它存储key-value的序列化方式有关，我们没有设置的情况下，它默认使用JdkserializationRedisSerializer，这个就会保留元数据，要想不保存元数据就需要改变它默认的序列化方式，其常用的有两种StringRedisSerializer和Jackson2RedisSerializer，这两种都不会保留序列的元数据，他们两个有什么区别的，咱直接试一下就知道。
假设先使用第一种StringRedisSerialzer，设置key和value都用这个。代码如下：

  1. @Configuration
  2. public class RedisConfig {
  3.     @Bean
  4.     public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
  5.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  6.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  7.         redisTemplate.setKeySerializer(new StringRedisSerializer());//设置key存储的序列化方式
  8.         redisTemplate.setValueSerializer(new StringRedisSerializer());//设置value存储的序列化方式
  9.         return redisTemplate;
  10.     }
  11. }

我给它存储一个User对象。

  1. @RestController
  2. @RequestMapping("/test")
  3. public class RedisController {
  4.     @Autowired
  5.     private RedisTemplate<String,Object> redisTemplate;
  6.     @RequestMapping("/aaa")
  7.     public String testA(){
  8.         User user = new User();
  9.         user.setName("张三");
  10.         user.setAge(22);
  11.         redisTemplate.opsForValue().set("user",user);
  12.         return "success";
  13.     }
  14. }

结果：

很显然，直接报错，说我们User不能被转换为String，因为我们设置value序列化方式为String。
接下来我们给它转换成JSON字符串进行存储试试看。引入阿里巴巴提供的FastJSON。

  1.         <dependency>
  2.             <groupId>com.alibaba</groupId>
  3.             <artifactId>fastjson</artifactId>
  4.             <version>1.2.71</version>
  5.         </dependency>
  1. @RestController
  2. @RequestMapping("/test")
  3. public class RedisController {
  4.     @Autowired
  5.     private RedisTemplate<String,Object> redisTemplate;
  6.     @RequestMapping("/aaa")
  7.     public String testA(){
  8.         User user = new User();
  9.         user.setName("张三");
  10.         user.setAge(22);
  11.         redisTemplate.opsForValue().set("user", JSON.toJSONString(user));
  12.         return "success";
  13.     }
  14. }

再来看结果：
这会就直接可以，但是它存进去的数据是JSON数据，并不是JSON字符串。

那么Jackson2RedisSerializer这个序列化方式的直接存储user对象，是可以直接存的不会报错，结果跟上面这个一样，但是如果你存JSON字符串进去，结果就是JSON字符串。结果：

一般来说JSON字符串都是带'\'这玩意的，当然上面也不是我们想要的，所以总结一下。

如果是StringRedisSerializer，传JSON字符串，如果是Jackson2JsonRedisSerializer，直接传对象。
 

虽然讲了上面两种的区别，但是往往这也是最烦人的，我喜欢唯一，所以二者必须要选一种，哪怕是公司的话也是选择一种，我们就选择StringRedisSerializer。
最终代码：

  1. @Configuration
  2. public class RedisConfig {
  3.     @Bean
  4.     public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
  5.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  6.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  7.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  8.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  9.         redisTemplate.setHashValueSerializer(new StringRedisSerializer());
  10.         redisTemplate.setValueSerializer(new StringRedisSerializer());
  11.         return redisTemplate;
  12.     }
  13. }

4.真的需要RedisConfig吗？

虽然上面讲了那么多，但是，只是让大家了解一下原理，或者公司的写法可能就是这样的，但是为什么可以不用写这个呢？首先SpringBoot集成了Redis以后，会有一个RedisAutoConfiguration的自动配置类。

可以很明显的看出，它已经为我们提供了两个现成的RedisTemplate和StringRedisTemplate。

其中前者我们不可能用，因为之前讲过了，它没有设置序列化方式，会出现“乱码”问题。

那就需要自己配置也就是我们上面的3讲的。那为什么可用不用自己配置呢，这就是讲的StringRedisTemplate，它要求我们设置的key和value都必须是String类型，那为什么它不会出现乱码呢？我们直接点进去看一看。

可以从源码看出来它实际上是继承RedisTemplate的基础上在创建对象的时候又进行了序列化的设置，设置为RedisSerialiizer.string()。这个点进去实际上就是StringRedisSerializer.

所以我们上面的3实际上就是StringRedisTemplate。那公司开发时为什么还要自己配置呢？我觉得可能是沿用n多年前公司的写法，但是当时具体的含义又不是很清楚，所以到现在还保持着。

5.实际公司开发怎么选择？

如果是老项目，我们就没必要去纠结这个问题，我们知道它为什么这么写就行了，你不可能说给它改了，人家那种写法也不错，其实只要统一要求开发规范就行，大家都遵守这个进行开发。

如果是新项目，当然我们可以和leader去沟通这个问题，其实问题不大，只要你讲清楚就行。

第一种的话，它不会进行编译检查，如果你直接value是个对象而没有转换成JSON字符串，那么运行的时候直接会报错，这种就很不好。
第二种的话，我们就强制要求了，你传对象过来，我编译器就报错，你就必须给我转成JSON字符串进行存储，就不会出现上面的问题，这个规范就很强制。

我们知道上面的区别和好处啊，具体使用看情况，你别头铁不顾一切你就要用你自己的方式，到最后领导找你再让你改。但是我们一定要知道，分清楚。

其次就是我们一般还会封装一个Redis的工具类，虽然set存储其实也就一句话，还是封装一下更统一开发规范和要求。更高的提升效率。

6.封装Redis的工具类RedisUtil

  1. @Component
  2. public class RedisUtil {
  3.  
  4.     @Autowired
  5.     private RedisTemplate<String, Object> redisTemplate;
  6.  
  7.     /**
  8.      * 指定缓存失效时间
  9.      *
  10.      * @param key  键
  11.      * @param time 时间(秒)
  12.      * @return 陈工失败
  13.      */
  14.     public boolean expire(String key, long time) {
  15.         try {
  16.             if (time > 0) {
  17.                 Boolean boo = redisTemplate.expire(key, time, TimeUnit.SECONDS);
  18.                 return boo != null && boo;
  19.             }
  20.             return true;
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.             return false;
  24.         }
  25.     }
  26.  
  27.  
  28.     /**
  29.      * 判断key是否存在
  30.      *
  31.      * @param key 键
  32.      * @return true 存在 false不存在
  33.      */
  34.     public boolean hasKey(String key) {
  35.         try {
  36.             Boolean boo = redisTemplate.hasKey(key);
  37.             return boo != null && boo;
  38.         } catch (Exception e) {
  39.             e.printStackTrace();
  40.             return false;
  41.         }
  42.     }
  43.  
  44.     /**
  45.      * 删除缓存
  46.      *
  47.      * @param key 可以传一个值 或多个
  48.      */
  49.     public boolean del(String... key) {
  50.         try {
  51.             if (key != null && key.length > 0) {
  52.                 if (key.length == 1) {
  53.                     redisTemplate.delete(key[0]);
  54.                 } else {
  55.                    redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
  56.  
  57.                 }
  58.             }
  59.             return true;
  60.         }catch (Exception e){
  61.             e.printStackTrace();
  62.             return false;
  63.         }
  64.     }
  65.  
  66.     /**
  67.      * 根据前缀删除key
  68.      * @param prex
  69.      */
  70.     public boolean deleteByPrex(String prex) {
  71.         try {
  72.             prex = prex+"**";
  73.             Set<String> keys = redisTemplate.keys(prex);
  74.             redisTemplate.delete(keys);
  75.             return true;
  76.         }catch (Exception e){
  77.             e.printStackTrace();
  78.             return false;
  79.         }
  80.     }
  81.  
  82.     //============================String=============================
  83.  
  84.     /**
  85.      * 普通缓存获取
  86.      *
  87.      * @param key 键
  88.      * @return 值
  89.      */
  90.     public Object get(String key) {
  91.         try{
  92.             return redisTemplate.opsForValue().get(key);
  93.         }catch (Exception e){
  94.             e.printStackTrace();
  95.         }
  96.         return null;
  97.     }
  98.  
  99.     /**
  100.      * 普通缓存放入
  101.      *
  102.      * @param key   键
  103.      * @param value 值
  104.      * @return true成功 false失败
  105.      */
  106.     public boolean set(String key, Object value) {
  107.         try {
  108.             redisTemplate.opsForValue().set(key, value);
  109.             return true;
  110.         } catch (Exception e) {
  111.             e.printStackTrace();
  112.             return false;
  113.         }
  114.  
  115.     }
  116.  
  117.     /**
  118.      * 普通缓存放入并设置时间
  119.      *
  120.      * @param key   键
  121.      * @param value 值
  122.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  123.      * @return true成功 false 失败
  124.      */
  125.     public boolean set(String key, Object value, long time) {
  126.         try {
  127.             if (time > 0) {
  128.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  129.             } else {
  130.                 set(key, value);
  131.             }
  132.             return true;
  133.         } catch (Exception e) {
  134.             e.printStackTrace();
  135.             return false;
  136.         }
  137.     }
  138.  
  139.     /**
  140.      * 加锁
  141.      *
  142.      * @param key         键
  143.      * @param value         值
  144.      * @param releaseTime 锁过期时间 秒
  145.      * @return 结果
  146.      */
  147.     public boolean lock(String key, Object value, long releaseTime) {
  148.         try {
  149.             Boolean boo = redisTemplate.opsForValue().setIfAbsent(key, value, releaseTime, TimeUnit.SECONDS);
  150.             return boo != null && boo;
  151.         } catch (Exception e) {
  152.             e.printStackTrace();
  153.             return false;
  154.         }
  155.     }
  156.  
  157.     /**
  158.      * 解锁
  159.      *
  160.      * @param key key
  161.      */
  162.     public boolean unLock(String key) {
  163.         try {
  164.             Boolean boo = redisTemplate.delete(key);
  165.             return boo != null && boo;
  166.         } catch (Exception e) {
  167.             e.printStackTrace();
  168.             return false;
  169.         }
  170.  
  171.     }
  172.  
  173.  
  174.     /**
  175.      * 向指定list的队列头部批量添加value
  176.      *
  177.      * @param key key
  178.      */
  179.     public boolean rightPush(String key, String value) {
  180.         try {
  181.             Long aLong = redisTemplate.opsForList().rightPush(key, value);
  182.             return aLong != 0;
  183.         } catch (Exception e) {
  184.             e.printStackTrace();
  185.             return false;
  186.         }
  187.  
  188.     }
  189.  
  190.     /**
  191.      * 向指定list的队列头部批量添加value
  192.      *
  193.      * @param key key
  194.      */
  195.     public boolean leftPush(String key, String value) {
  196.         try {
  197.             Long aLong = redisTemplate.opsForList().leftPush(key, value);
  198.             return aLong != 0;
  199.         } catch (Exception e) {
  200.             e.printStackTrace();
  201.             return false;
  202.         }
  203.  
  204.     }
  205.  
  206.  
  207.     /**
  208.      * 移除并获取指定list中(队列-头部/尾部)第一个元素
  209.      *
  210.      * @param key key
  211.      */
  212.     public Object leftPop(String key) {
  213.         try {
  214.             return redisTemplate.opsForList().leftPop(key);
  215.         } catch (Exception e) {
  216.             e.printStackTrace();
  217.             return null;
  218.         }
  219.  
  220.     }
  221.  
  222.  
  223.     /**
  224.      * 指定key+！
  225.      *
  226.      * @param key key
  227.      */
  228.     public Object incr(String key,Long num) {
  229.         try {
  230.             return redisTemplate.opsForValue().increment(key,num);
  231.         } catch (Exception e) {
  232.             e.printStackTrace();
  233.             return null;
  234.         }
  235.  
  236.     }
  237.  
  238.     /**
  239.      * 根据参数查询相关KEY集合
  240.      */
  241.     public Set<String> getKeyListByStr(String key){
  242.         key = key+"**";
  243.         return redisTemplate.keys(key);
  244.     }
  245.  
  246.  
  247. }

虽然有一些简答的没必要，但是一切都是为了统一开发规范，我们给类加个@Compinent注解，让我们的@Autowired注解生效，其次我们可以直接通过@Autowired注入RedisUtil进行方法调用。

  1. @RestController
  2. @RequestMapping("/test")
  3. public class RedisController {
  4.     @Autowired
  5.     private RedisUtil redisUtil;
  6.     @RequestMapping("/aaa")
  7.     public String testA(){
  8.         User user = new User();
  9.         user.setName("张三");
  10.         user.setAge(22);
  11.         redisUtil.set("test","8888888888888");
  12.         return "success";
  13.     }
  14. }

有点累了，后续出常用的操作及其应用场景。

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号