Spring Boot 项目中 Redis 与数据库性能对比实战：从缓存配置到时间分析， ...

一、媒介：

    在现代应用中，随着数据量的增大和访问频率的提高，怎样提高数据存取的性能变得尤为告急。缓存技能作为一种常见的优化本领，被广泛应用于减少数据库访问压力、提拔体系响应速度。Redis 作为一种高效的内存缓存数据库，因其卓越的性能和丰富的数据范例支持，在开发中占据了告急位置。
    本篇文章将详细先容怎样在 Spring Boot 项目中使用 Redis，创建简朴的缓存机制，并实现数据存取的时间比力。通过这个实战项目，你将学习怎样在 Redis 和 MySQL 之间存取数据，并丈量两者的性能差异，从而对缓存策略有更加深入的明确。
二、详细利用：

2.1、环境预备和项目布局

起首，你需要预备一个 Spring Boot 项目，并确保项目布局中包含以下依赖：

• Spring Web：用于构建 RESTful API
  
• MyBatis：数据库利用框架
  
• Spring Data Redis：用于 Redis 利用
  
• MySQL Driver：用于与 MySQL 数据库交互
  

1. <dependencies>
2.         <dependency>
3.             <groupId>org.springframework.boot</groupId>
4.             <artifactId>spring-boot-starter-web</artifactId>
5.         </dependency>
7.         <dependency>
8.             <groupId>com.mysql</groupId>
9.             <artifactId>mysql-connector-j</artifactId>
10.             <scope>runtime</scope>
11.         </dependency>
13.         <dependency>
14.             <groupId>org.springframework.boot</groupId>
15.             <artifactId>spring-boot-starter-test</artifactId>
16.             <scope>test</scope>
17.         </dependency>
18.         <!-- MyBatis Starter -->
19.         <dependency>
20.             <groupId>org.mybatis.spring.boot</groupId>
21.             <artifactId>mybatis-spring-boot-starter</artifactId>
22.             <version>3.0.0</version>
23.         </dependency>
24.         <!-- Spring Boot Redis Starter -->
25.         <dependency>
26.             <groupId>org.springframework.boot</groupId>
27.             <artifactId>spring-boot-starter-data-redis</artifactId>
28.         </dependency>
29.         
30.         <dependency>
31.             <groupId>org.projectlombok</groupId>
32.             <artifactId>lombok</artifactId>
33.             <version>1.18.30</version>
34.         </dependency>
35.     </dependencies>

复制代码

同时项目布局如下，是一个非常普通的SpringBoot项目

同时还要在application.properties中配置好对应的MySQL和MyBatis信息：

1. spring.datasource.url=jdbc:mysql://localhost:3306/yourDatabase
2. spring.datasource.username=root
3. spring.datasource.password=root
4. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
6. mybatis.mapper-locations=classpath:mapper/*.xml

复制代码

2.2、创建实体类

实体类 User 用于表示用户的基本信息，包含 id 和 name 两个字段。代码如下：

1. @Data
2. public class User {
3.     private Long id;
4.     private String name;
5. }

复制代码

2.3、配置MyBatis Mapper层

创建一个接口 UserMapper 来利用数据库，并通过 MyBatis 的 XML 文件实现具体的 SQL 利用：

1. @Mapper
2. public interface UserMapper {
3.     User selectUserById(Long id);
4. }

复制代码

1. <mapper namespace="com.example.redis.mapper.UserMapper">
2.     <select id="selectUserById" resultType="com.example.redis.entity.User">
3.         SELECT id, name FROM user WHERE id = #{id}
4.     </select>
5. </mapper>

复制代码

2.4、Redis配置与工具类

自界说的 Redis 配置类 RedisConfig，它基于 Jackson 的 JSON 序列化器进行 Redis 数据存储与读取，确保数据可以以对象形式生存到 Redis 中。（这个配置类和工具类是在网上找的）配置如下：

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

复制代码

工具类 RedisUtil 提供了简朴的 Redis 利用方法，例如设置键值对、获取缓存、检查键是否存在等：

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

复制代码

2.5、Service层实现

在 UserService 中，创建数据时不仅将数据写入数据库，还将其缓存到 Redis 中。查询数据时，优先从 Redis 中获取，若 Redis 中不存在，则查询数据库并缓存结果。还会记载并输出 Redis 和数据库的查询时间：

1. @Service
2. public class UserService {
3.     @Autowired
4.     private UserMapper userMapper;
6.     @Autowired
7.     private RedisUtil redisUtil;
9.     public User  getUserById(Long id){
10.         //先从Redis中读取数据
11.         String key = "user:"+id;
12.         //判断该数据是否在Redis中
13.         long redisStartTime = System.currentTimeMillis();
14.         Object testUser = redisUtil.hasKey(key)?redisUtil.get(key):null;//先判断是否有，有就得到，没有就返回null
15.         long redisEndTime = System.currentTimeMillis();
16.         //存在的话则返回数据
17.         if(testUser!=null){
18.             System.out.println("Redis 查询时间: " + (redisEndTime - redisStartTime) + " ms");
19.             return (User) testUser;
20.         }
21.         //不存在的话则从数据库中读取数据并将数据保存到Redis中
22.         long dbStartTime = System.currentTimeMillis();
23.         User user = userMapper.selectUserById(id);
24.         long dbEndTime = System.currentTimeMillis();
25.         System.out.println("数据库查询时间: " + (dbEndTime - dbStartTime) + " ms");
27.         redisUtil.set(key,user);
28.         return user;
29.     }
31. }

复制代码

2.6、Controller层实现

通过 UserController 提供 RESTful 接口，用于创建用户和查询用户信息：

1. @RestController
2. @RequestMapping("/test")
3. public class UserController {
4.     @Autowired
5.     private UserService userService;
7.     @GetMapping("/{id}")
8.     public User test1(@PathVariable Long id) {
9.         return userService.getUserById(id);
10.     }
11. }

复制代码

三、Redis相关知识点整理：

1. Redis 在缓存中的作用

在本项目中，Redis 主要用于缓存用户数据。通常，在频繁的数据库读利用中，每次查询数据库都会泯灭一定的时间和资源。而 Redis 作为一个基于内存的缓存，可以极大地减少对数据库的直接访问，提拔体系性能。
在下面我展示一下使用数据库与Redis查询数据的时间对比，还是很显着的，使用Redis能很洪流平地减少查询时间

2. Redis 与数据库的数据存取逻辑

在 UserService 中，我们实现了从 Redis 获取数据的逻辑：

1. Object cachedUser = redisUtil.hasKey(key) ? redisUtil.get(key) : null;

复制代码

这里，我们起首判断 Redis 中是否已经缓存了对应用户数据（通过 redisUtil.hasKey(key)）。如果缓存存在，则直接从 Redis 中获取数据，从而避免了数据库查询的延时。如果缓存不存在，则实行数据库查询，并将查询结果存入 Redis：

1. User user = userMapper.selectUserById(id);
2. redisUtil.set(key, user);

复制代码

这种 "缓存穿透" 的模式，确保了只有在 Redis 缓存未命中的环境下才会访问数据库，从而实现了高效的数据查询。
3. Redis 数据的存储与序列化

在 Redis 中存储复杂数据范例（如 Java 对象）时，使用了 Jackson2JsonRedisSerializer 来序列化对象：

1. Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
2. template.setValueSerializer(jackson2JsonRedisSerializer);
3. template.setHashValueSerializer(jackson2JsonRedisSerializer);

复制代码

这段代码确保了 Redis 可以将 User 对象序列化为 JSON 字符串并存储在 Redis 中，当需要从缓存中获取数据时，再反序列化为 Java 对象。
四、总结：

    在本篇文章中，我们通过一个简朴的 Spring Boot 项目，联合 Redis 和 MySQL 实现了数据的存取，并比力了它们在时间上的差异。通过 Redis 的引入，可以明显提拔体系的性能，特别是在频繁读写的场景下，缓存策略能够有效减轻数据库的压力。
    本项目展示了怎样使用 Redis 来优化应用性能，以及 Redis 在现代应用架构中的告急性。如果你正在构建一个需要高性能、低延迟的应用，Redis 绝对是你不可或缺的技能之一。
    如果这篇文章有资助到你的话，就点个赞和关注吧，你的鼓励是我最大的动力！


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。