SpringBoot之集成Redis

一、Redis集成简介

Redis是我们Java开发中，利用频次非常高的一个nosql数据库，数据以key-value键值对的形式存储在内存中。redis的常用利用场景，可以做缓存，分布式锁，自增序列等，利用redis的方式和我们利用数据库的方式差不多，起首我们要在自己的本机电脑或者服务器上安装一个redis的服务器，通过我们的java客户端在步伐中进行集成，然后通过客户端完成对redis的增删改查操作。
redis的Java客户端范例照旧很多的，常见的有jedis, redission,lettuce等，
以是我们在集成的时候，我们可以选择直接集成这些原生客户端。
但是在springBoot中更常见的方式是集成spring-data-redis，这是spring提供的一个专门用来操作redis的项目，封装了对redis的常用操作，里边主要封装了jedis和lettuce两个客户端。相称于是在他们的基础上加了一层门面。
二、集成步调

2.1 添加依靠

添加redis所需依靠：（spring-boot-starter-data-redis 默认利用的就是lettuce这个客户端）

1. <!-- 集成redis依赖  -->
2. <dependency>
3.     <groupId>org.springframework.boot</groupId>
4.     <artifactId>spring-boot-starter-data-redis</artifactId>
5. </dependency>

复制代码

完备pom.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
6.     <modelVersion>4.0.0</modelVersion>
8.     <groupId>com.lsqingfeng.springboot</groupId>
9.     <artifactId>springboot-learning</artifactId>
10.     <version>1.0.0</version>
12.     <properties>
13.         <maven.compiler.source>8</maven.compiler.source>
14.         <maven.compiler.target>8</maven.compiler.target>
15.     </properties>
17.     <dependencyManagement>
18.         <dependencies>
19.             <dependency>
20.                 <groupId>org.springframework.boot</groupId>
21.                 <artifactId>spring-boot-dependencies</artifactId>
22.                 <version>2.6.2</version>
23.                 <type>pom</type>
24.                 <scope>import</scope>
25.             </dependency>
26.         </dependencies>
27.     </dependencyManagement>
29.     <dependencies>
30.         <dependency>
31.             <groupId>org.springframework.boot</groupId>
32.             <artifactId>spring-boot-starter-web</artifactId>
33.         </dependency>
35.         <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
36.         <dependency>
37.             <groupId>org.projectlombok</groupId>
38.             <artifactId>lombok</artifactId>
39.             <version>1.18.22</version>
40.             <scope>provided</scope>
41.         </dependency>
43.         <!-- mybatis-plus 所需依赖  -->
44.         <dependency>
45.             <groupId>com.baomidou</groupId>
46.             <artifactId>mybatis-plus-boot-starter</artifactId>
47.             <version>3.5.1</version>
48.         </dependency>
50.         <dependency>
51.             <groupId>com.baomidou</groupId>
52.             <artifactId>mybatis-plus-generator</artifactId>
53.             <version>3.5.1</version>
54.         </dependency>
56.         <dependency>
57.             <groupId>org.freemarker</groupId>
58.             <artifactId>freemarker</artifactId>
59.             <version>2.3.31</version>
60.         </dependency>
62.         <!-- 开发热启动 -->
63.         <dependency>
64.             <groupId>org.springframework.boot</groupId>
65.             <artifactId>spring-boot-devtools</artifactId>
66.             <optional>true</optional>
67.         </dependency>
69.         <!-- MySQL连接 -->
70.         <dependency>
71.             <groupId>mysql</groupId>
72.             <artifactId>mysql-connector-java</artifactId>
73.             <scope>runtime</scope>
74.         </dependency>
76.         <!-- 集成redis依赖  -->
77.         <dependency>
78.             <groupId>org.springframework.boot</groupId>
79.             <artifactId>spring-boot-starter-data-redis</artifactId>
80.         </dependency>
81.     </dependencies>
82. </project>

复制代码

注意点：如果我们想要利用jedis客户端怎么办呢？就必要排除lettuce这个依靠，再引入jedis的相干依靠就可以了。

1. <dependency>  
2.     <groupId>org.springframework.boot</groupId>  
3.     <artifactId>spring-boot-starter-data-redis</artifactId>  
4.     <exclusions>  
5.         <exclusion>  
6.             <groupId>io.lettuce</groupId>  
7.             <artifactId>lettuce-core</artifactId>  
8.         </exclusion>  
9.     </exclusions>  
10. </dependency>
12. <dependency>  
13.     <groupId>redis.clients</groupId>  
14.     <artifactId>jedis</artifactId>  
15.     <version>你的Jedis版本号</version>  
16. </dependency>

复制代码

两者的区别
Lettuce更适合必要异步处理、线程安全以及支持哨兵和集群模式的场景（线程安全）；
而Jedis则更适合简单的同步操作，以及在不必要哨兵和集群模式的场景中利用（线程不安全）。
2.2 添加配置

然后我们必要配置连接redis所需的账号暗码等信息，这里大家要提前安装好redis,保证我们的本机步伐可以连接到我们的redis， 如果不知道redis如何安装，可以参考文章: [Linux系统安装redis6.0.5] blog.csdn.net/lsqingfeng/…
常规配置如下： 在application.yml配置文件中配置 redis的连接信息

1. spring:
2.   redis:
3.     host: localhost
4.     port: 6379
5.     password: 123456
6.     database: 0

复制代码

如果有其他配置放到一起：

1. server:
2.   port: 19191
4. spring:
5.   datasource:
6.     driver-class-name: com.mysql.cj.jdbc.Driver
7.     url: jdbc:mysql://localhost:3306/springboot_learning?serverTimezone=Asia/Shanghai&characterEncoding=utf-8
8.     username: root
9.     password: root
10.   redis:
11.     host: localhost
12.     port: 6379
13.     password: 123456
14.     database: 0
15.     lettuce:
16.       pool:
17.         max-idle: 16
18.         max-active: 32
19.         min-idle: 8
20.   devtools:
21.     restart:
22.       enable: true
25. third:
26.   weather:
27.     url: http://www.baidu.com
28.     port: 8080
29.     username: test
30.     cities:
31.       - 北京
32.       - 上海
33.       - 广州
34.     list[0]: aaa
35.     list[1]: bbb
36.     list[2]: ccc

复制代码

这样我们就可以直接在项目当中操作redis了。如果利用的是集群，那么利用如下配置方式：

1. spring:
2.   redis:
3.     password: 123456
4.     cluster:
5.       nodes: 10.255.144.115:7001,10.255.144.115:7002,10.255.144.115:7003,10.255.144.115:7004,10.255.144.115:7005,10.255.144.115:7006
6.       max-redirects: 3

复制代码

但是有的时候我们想要给我们的redis客户端配置上连接池。
就像我们连接mysql的时候，也会配置连接池一样，目标就是增加对于数据连接的管理，提升访问的效率，也保证了对资源的合理利用。那么我们如何配置连接池呢，这里大家肯定要注意了，很多网上的文章中，介绍的方法可能由于版本太低，都不是特别的准确。
比如很多人利用spring.redis.pool来配置，这个是不对的（不清楚是不是老版本是这样的配置的，但是在springboot-starter-data-redis中这种写法不对）。起首是配置文件，由于我们利用的lettuce客户端，以是配置的时候，在spring.redis下加上lettuce再加上pool来配置，详细如下；

1. spring:
2.   redis:
3.     host: 10.255.144.111
4.     port: 6379
5.     password: 123456
6.     database: 0
7.     lettuce:
8.       pool:
9.         max-idle: 16
10.         max-active: 32
11.         min-idle: 8

复制代码

如果利用的是jedis,就把lettuce换成jedis（同时要注意依靠也是要换的）。
但是仅仅这在配置文件中参加，实在连接池是不会生效的。这里大家肯定要注意，很多同砚在配置文件上加上了这段就以为连接池已经配置好了，实在并没有，还少了最关键的一步，就是要导入一个依靠，不导入的话，这么配置也没有用。

1. <dependency>
2.     <groupId>org.apache.commons</groupId>
3.     <artifactId>commons-pool2</artifactId>
4. </dependency>

复制代码

之后，连接池才会生效。我们可以做一个对比。 在导包前后，观察RedisTemplate对象的值就可以看出来。
导入之前：

导入之后：

导入之后，我们的连接池信息才有值，这也印证了我们上面的结论。
详细的配置信息我们可以看一下源代码，源码中利用RedisProperties 这个类来接收redis的配置参数。

2.3 项目中利用

我们的配置工作准备就绪以后，我们就可以在项目中操作redis了，操作的话，利用spring-data-redis中为我们提供的 RedisTemplate 这个类，就可以操作了。我们先举个简单的例子，插入一个键值对（值为string）。

1. package com.lsqingfeng.springboot.controller;
3. import com.lsqingfeng.springboot.base.Result;
4. import org.springframework.data.redis.core.RedisTemplate;
5. import org.springframework.web.bind.annotation.GetMapping;
6. import org.springframework.web.bind.annotation.RequestMapping;
7. import org.springframework.web.bind.annotation.RestController;
9. /**
10. * @className: RedisController
11. * @description:
12. * @author: sh.Liu
13. * @date: 2022-03-08 14:28
14. */
15. @RestController
16. @RequestMapping("redis")
17. public class RedisController {
19.     private final RedisTemplate redisTemplate;
21.     public RedisController(RedisTemplate redisTemplate) {
22.         this.redisTemplate = redisTemplate;
23.     }
25.     @GetMapping("save")
26.     public Result save(String key, String value){
27.         redisTemplate.opsForValue().set(key, value);
28.         return Result.success();
29.     }
31. }

复制代码

三、工具类封装

1. package com.lsqingfeng.springboot.utils;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.data.redis.core.RedisTemplate;
5. import org.springframework.stereotype.Component;
7. import java.util.List;
8. import java.util.Map;
9. import java.util.Set;
10. import java.util.concurrent.TimeUnit;
12. /**
13. * @className: RedisUtil
14. * @description:
15. * @author: sh.Liu
16. * @date: 2022-03-09 14:07
17. */
18. @Component
19. public class RedisUtil {
21.     @Autowired
22.     private RedisTemplate redisTemplate;
23.     /**
24.      * 给一个指定的 key 值附加过期时间
25.      *
26.      * @param key
27.      * @param time
28.      * @return
29.      */
30.     public boolean expire(String key, long time) {
31.         return redisTemplate.expire(key, time, TimeUnit.SECONDS);
32.     }
33.     /**
34.      * 根据key 获取过期时间
35.      *
36.      * @param key
37.      * @return
38.      */
39.     public long getTime(String key) {
40.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
41.     }
42.     /**
43.      * 根据key 获取过期时间
44.      *
45.      * @param key
46.      * @return
47.      */
48.     public boolean hasKey(String key) {
49.         return redisTemplate.hasKey(key);
50.     }
51.     /**
52.      * 移除指定key 的过期时间
53.      *
54.      * @param key
55.      * @return
56.      */
57.     public boolean persist(String key) {
58.         return redisTemplate.boundValueOps(key).persist();
59.     }
61.     //- - - - - - - - - - - - - - - - - - - - -  String类型 - - - - - - - - - - - - - - - - - - - -
63.     /**
64.      * 根据key获取值
65.      *
66.      * @param key 键
67.      * @return 值
68.      */
69.     public Object get(String key) {
70.         return key == null ? null : redisTemplate.opsForValue().get(key);
71.     }
73.     /**
74.      * 将值放入缓存
75.      *
76.      * @param key   键
77.      * @param value 值
78.      * @return true成功 false 失败
79.      */
80.     public void set(String key, String value) {
81.         redisTemplate.opsForValue().set(key, value);
82.     }
84.     /**
85.      * 将值放入缓存并设置时间
86.      *
87.      * @param key   键
88.      * @param value 值
89.      * @param time  时间(秒) -1为无期限
90.      * @return true成功 false 失败
91.      */
92.     public void set(String key, String value, long time) {
93.         if (time > 0) {
94.             redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
95.         } else {
96.             redisTemplate.opsForValue().set(key, value);
97.         }
98.     }
100.     /**
101.      * 批量添加 key (重复的键会覆盖)
102.      *
103.      * @param keyAndValue
104.      */
105.     public void batchSet(Map<String, String> keyAndValue) {
106.         redisTemplate.opsForValue().multiSet(keyAndValue);
107.     }
109.     /**
110.      * 批量添加 key-value 只有在键不存在时,才添加
111.      * map 中只要有一个key存在,则全部不添加
112.      *
113.      * @param keyAndValue
114.      */
115.     public void batchSetIfAbsent(Map<String, String> keyAndValue) {
116.         redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
117.     }
119.     /**
120.      * 对一个 key-value 的值进行加减操作,
121.      * 如果该 key 不存在 将创建一个key 并赋值该 number
122.      * 如果 key 存在,但 value 不是长整型 ,将报错
123.      *
124.      * @param key
125.      * @param number
126.      */
127.     public Long increment(String key, long number) {
128.         return redisTemplate.opsForValue().increment(key, number);
129.     }
131.     /**
132.      * 对一个 key-value 的值进行加减操作,
133.      * 如果该 key 不存在 将创建一个key 并赋值该 number
134.      * 如果 key 存在,但 value 不是 纯数字 ,将报错
135.      *
136.      * @param key
137.      * @param number
138.      */
139.     public Double increment(String key, double number) {
140.         return redisTemplate.opsForValue().increment(key, number);
141.     }
143.     //- - - - - - - - - - - - - - - - - - - - -  set类型 - - - - - - - - - - - - - - - - - - - -
145.     /**
146.      * 将数据放入set缓存
147.      *
148.      * @param key 键
149.      * @return
150.      */
151.     public void sSet(String key, String value) {
152.         redisTemplate.opsForSet().add(key, value);
153.     }
155.     /**
156.      * 获取变量中的值
157.      *
158.      * @param key 键
159.      * @return
160.      */
161.     public Set<Object> members(String key) {
162.         return redisTemplate.opsForSet().members(key);
163.     }
165.     /**
166.      * 随机获取变量中指定个数的元素
167.      *
168.      * @param key   键
169.      * @param count 值
170.      * @return
171.      */
172.     public void randomMembers(String key, long count) {
173.         redisTemplate.opsForSet().randomMembers(key, count);
174.     }
176.     /**
177.      * 随机获取变量中的元素
178.      *
179.      * @param key 键
180.      * @return
181.      */
182.     public Object randomMember(String key) {
183.         return redisTemplate.opsForSet().randomMember(key);
184.     }
186.     /**
187.      * 弹出变量中的元素
188.      *
189.      * @param key 键
190.      * @return
191.      */
192.     public Object pop(String key) {
193.         return redisTemplate.opsForSet().pop("setValue");
194.     }
196.     /**
197.      * 获取变量中值的长度
198.      *
199.      * @param key 键
200.      * @return
201.      */
202.     public long size(String key) {
203.         return redisTemplate.opsForSet().size(key);
204.     }
206.     /**
207.      * 根据value从一个set中查询,是否存在
208.      *
209.      * @param key   键
210.      * @param value 值
211.      * @return true 存在 false不存在
212.      */
213.     public boolean sHasKey(String key, Object value) {
214.         return redisTemplate.opsForSet().isMember(key, value);
215.     }
217.     /**
218.      * 检查给定的元素是否在变量中。
219.      *
220.      * @param key 键
221.      * @param obj 元素对象
222.      * @return
223.      */
224.     public boolean isMember(String key, Object obj) {
225.         return redisTemplate.opsForSet().isMember(key, obj);
226.     }
228.     /**
229.      * 转移变量的元素值到目的变量。
230.      *
231.      * @param key     键
232.      * @param value   元素对象
233.      * @param destKey 元素对象
234.      * @return
235.      */
236.     public boolean move(String key, String value, String destKey) {
237.         return redisTemplate.opsForSet().move(key, value, destKey);
238.     }
240.     /**
241.      * 批量移除set缓存中元素
242.      *
243.      * @param key    键
244.      * @param values 值
245.      * @return
246.      */
247.     public void remove(String key, Object... values) {
248.         redisTemplate.opsForSet().remove(key, values);
249.     }
251.     /**
252.      * 通过给定的key求2个set变量的差值
253.      *
254.      * @param key     键
255.      * @param destKey 键
256.      * @return
257.      */
258.     public Set<Set> difference(String key, String destKey) {
259.         return redisTemplate.opsForSet().difference(key, destKey);
260.     }
263.     //- - - - - - - - - - - - - - - - - - - - -  hash类型 - - - - - - - - - - - - - - - - - - - -
265.     /**
266.      * 加入缓存
267.      *
268.      * @param key 键
269.      * @param map 键
270.      * @return
271.      */
272.     public void add(String key, Map<String, String> map) {
273.         redisTemplate.opsForHash().putAll(key, map);
274.     }
276.     /**
277.      * 获取 key 下的 所有  hashkey 和 value
278.      *
279.      * @param key 键
280.      * @return
281.      */
282.     public Map<Object, Object> getHashEntries(String key) {
283.         return redisTemplate.opsForHash().entries(key);
284.     }
286.     /**
287.      * 验证指定 key 下 有没有指定的 hashkey
288.      *
289.      * @param key
290.      * @param hashKey
291.      * @return
292.      */
293.     public boolean hashKey(String key, String hashKey) {
294.         return redisTemplate.opsForHash().hasKey(key, hashKey);
295.     }
297.     /**
298.      * 获取指定key的值string
299.      *
300.      * @param key  键
301.      * @param key2 键
302.      * @return
303.      */
304.     public String getMapString(String key, String key2) {
305.         return redisTemplate.opsForHash().get("map1", "key1").toString();
306.     }
308.     /**
309.      * 获取指定的值Int
310.      *
311.      * @param key  键
312.      * @param key2 键
313.      * @return
314.      */
315.     public Integer getMapInt(String key, String key2) {
316.         return (Integer) redisTemplate.opsForHash().get("map1", "key1");
317.     }
319.     /**
320.      * 弹出元素并删除
321.      *
322.      * @param key 键
323.      * @return
324.      */
325.     public String popValue(String key) {
326.         return redisTemplate.opsForSet().pop(key).toString();
327.     }
329.     /**
330.      * 删除指定 hash 的 HashKey
331.      *
332.      * @param key
333.      * @param hashKeys
334.      * @return 删除成功的 数量
335.      */
336.     public Long delete(String key, String... hashKeys) {
337.         return redisTemplate.opsForHash().delete(key, hashKeys);
338.     }
340.     /**
341.      * 给指定 hash 的 hashkey 做增减操作
342.      *
343.      * @param key
344.      * @param hashKey
345.      * @param number
346.      * @return
347.      */
348.     public Long increment(String key, String hashKey, long number) {
349.         return redisTemplate.opsForHash().increment(key, hashKey, number);
350.     }
352.     /**
353.      * 给指定 hash 的 hashkey 做增减操作
354.      *
355.      * @param key
356.      * @param hashKey
357.      * @param number
358.      * @return
359.      */
360.     public Double increment(String key, String hashKey, Double number) {
361.         return redisTemplate.opsForHash().increment(key, hashKey, number);
362.     }
364.     /**
365.      * 获取 key 下的 所有 hashkey 字段
366.      *
367.      * @param key
368.      * @return
369.      */
370.     public Set<Object> hashKeys(String key) {
371.         return redisTemplate.opsForHash().keys(key);
372.     }
374.     /**
375.      * 获取指定 hash 下面的 键值对 数量
376.      *
377.      * @param key
378.      * @return
379.      */
380.     public Long hashSize(String key) {
381.         return redisTemplate.opsForHash().size(key);
382.     }
384.     //- - - - - - - - - - - - - - - - - - - - -  list类型 - - - - - - - - - - - - - - - - - - - -
386.     /**
387.      * 在变量左边添加元素值
388.      *
389.      * @param key
390.      * @param value
391.      * @return
392.      */
393.     public void leftPush(String key, Object value) {
394.         redisTemplate.opsForList().leftPush(key, value);
395.     }
397.     /**
398.      * 获取集合指定位置的值。
399.      *
400.      * @param key
401.      * @param index
402.      * @return
403.      */
404.     public Object index(String key, long index) {
405.         return redisTemplate.opsForList().index("list", 1);
406.     }
408.     /**
409.      * 获取指定区间的值。
410.      *
411.      * @param key
412.      * @param start
413.      * @param end
414.      * @return
415.      */
416.     public List<Object> range(String key, long start, long end) {
417.         return redisTemplate.opsForList().range(key, start, end);
418.     }
420.     /**
421.      * 把最后一个参数值放到指定集合的第一个出现中间参数的前面，
422.      * 如果中间参数值存在的话。
423.      *
424.      * @param key
425.      * @param pivot
426.      * @param value
427.      * @return
428.      */
429.     public void leftPush(String key, String pivot, String value) {
430.         redisTemplate.opsForList().leftPush(key, pivot, value);
431.     }
433.     /**
434.      * 向左边批量添加参数元素。
435.      *
436.      * @param key
437.      * @param values
438.      * @return
439.      */
440.     public void leftPushAll(String key, String... values) {
441. //        redisTemplate.opsForList().leftPushAll(key,"w","x","y");
442.         redisTemplate.opsForList().leftPushAll(key, values);
443.     }
445.     /**
446.      * 向集合最右边添加元素。
447.      *
448.      * @param key
449.      * @param value
450.      * @return
451.      */
452.     public void leftPushAll(String key, String value) {
453.         redisTemplate.opsForList().rightPush(key, value);
454.     }
456.     /**
457.      * 向左边批量添加参数元素。
458.      *
459.      * @param key
460.      * @param values
461.      * @return
462.      */
463.     public void rightPushAll(String key, String... values) {
464.         //redisTemplate.opsForList().leftPushAll(key,"w","x","y");
465.         redisTemplate.opsForList().rightPushAll(key, values);
466.     }
468.     /**
469.      * 向已存在的集合中添加元素。
470.      *
471.      * @param key
472.      * @param value
473.      * @return
474.      */
475.     public void rightPushIfPresent(String key, Object value) {
476.         redisTemplate.opsForList().rightPushIfPresent(key, value);
477.     }
479.     /**
480.      * 向已存在的集合中添加元素。
481.      *
482.      * @param key
483.      * @return
484.      */
485.     public long listLength(String key) {
486.         return redisTemplate.opsForList().size(key);
487.     }
489.     /**
490.      * 移除集合中的左边第一个元素。
491.      *
492.      * @param key
493.      * @return
494.      */
495.     public void leftPop(String key) {
496.         redisTemplate.opsForList().leftPop(key);
497.     }
499.     /**
500.      * 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
501.      *
502.      * @param key
503.      * @return
504.      */
505.     public void leftPop(String key, long timeout, TimeUnit unit) {
506.         redisTemplate.opsForList().leftPop(key, timeout, unit);
507.     }
509.     /**
510.      * 移除集合中右边的元素。
511.      *
512.      * @param key
513.      * @return
514.      */
515.     public void rightPop(String key) {
516.         redisTemplate.opsForList().rightPop(key);
517.     }
519.     /**
520.      * 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
521.      *
522.      * @param key
523.      * @return
524.      */
525.     public void rightPop(String key, long timeout, TimeUnit unit) {
526.         redisTemplate.opsForList().rightPop(key, timeout, unit);
527.     }
528. }

复制代码

四、序列化 （正常都必要自定义序列化）

Redis本身提供了一下一种序列化的方式：

• GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
  
• Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer现实上是一样的
  
• JacksonJsonRedisSerializer: 序列化object对象为json字符串
  
• JdkSerializationRedisSerializer: 序列化java对象
  
• StringRedisSerializer: 简单的字符串序列化
  

如果我们存储的是String范例，默认利用的是StringRedisSerializer 这种序列化方式。
如果我们存储的是对象，默认利用的是 JdkSerializationRedisSerializer，也就是Jdk的序列化方式（通过ObjectOutputStream和ObjectInputStream实现，缺点是我们无法直观看到存储的对象内容）。
通过观察RedisTemplate的源码我们就可以看出来，默认利用的是JdkSerializationRedisSerializer. 这种序列化最大的题目就是存入对象后，我们很难直观看到存储的内容，很不方便我们排查题目：

而一般我们最经常利用的对象序列化方式是： Jackson2JsonRedisSerializer
设置序列化方式的主要方法就是我们在配置类中，自己来创建RedisTemplate对象，并在创建的过程中指定对应的序列化方式。

1. @Configuration  
2. public class RedisConfig {  
3.     // 定义一个Bean，名称为"redisTemplate"，返回类型为RedisTemplate<String, Object>  
4.     @Bean(name = "redisTemplate")  
5.     public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {  
6.         // 创建一个新的RedisTemplate实例，用于操作Redis  
7.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();  
8.         // 设置RedisTemplate使用的连接工厂，以便它能够连接到Redis服务器  
9.         redisTemplate.setConnectionFactory(factory);  
10.          
11.         // 创建一个StringRedisSerializer实例，用于序列化Redis的key为字符串  
12.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
13.          
14.         // 创建一个Jackson2JsonRedisSerializer实例，用于序列化Redis的value为JSON格式  
15.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);  
16.          
17.         // 创建一个ObjectMapper实例，用于处理JSON的序列化和反序列化  
18.         ObjectMapper objectMapper = new ObjectMapper();  
19.          
20.         // 设置ObjectMapper的属性访问级别，以便能够序列化对象的所有属性  
21.         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
22.          
23.         // 启用默认的类型信息，以便在反序列化时能够知道对象的实际类型  
24.         // 注意：这里使用了新的方法替换了过期的enableDefaultTyping方法  
25.         // 方法过期，改为下面代码  
26.         // objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);  
27.         objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
28.                 ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
29.          
30.         // 设置Jackson2JsonRedisSerializer使用的ObjectMapper  
31.         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);  
32.   
33.         // 设置RedisTemplate的key序列化器为stringRedisSerializer  
34.         redisTemplate.setKeySerializer(stringRedisSerializer); // key的序列化类型  
35.         // 设置RedisTemplate的value序列化器为jackson2JsonRedisSerializer  
36.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型  
37.          
38.         // 设置RedisTemplate的hash key序列化器为stringRedisSerializer  
39.         redisTemplate.setHashKeySerializer(stringRedisSerializer);  // key的序列化类型  
40.         // 设置RedisTemplate的hash value序列化器为jackson2JsonRedisSerializer  
41.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);   // value的序列化类型  
42.         
43.         // 调用RedisTemplate的afterPropertiesSet方法，该方法会执行一些初始化操作，比如检查序列化器是否设置等  
44.         redisTemplate.afterPropertiesSet();  
45.          
46.         // 返回配置好的RedisTemplate实例  
47.         return redisTemplate;  
48.     }  
49. }

复制代码

这样利用的时候，就会按照我们设置的json序列化方式进行存储，我们也可以在redis中查察内容的时候方便的查察到属性值。
五、分布式锁

（一）RedisTemplate 去实现

场景一：单体应用

单机数据同等性架构如下图所示：多个可客户访问同一个服务器，连接同一个数据库。

场景形貌：客户端模拟购买商品过程，在Redis中设定库存总数剩100个，多个客户端同时并发购买。

1. @RestController
2. public class IndexController1 {
4.     @Autowired
5.     StringRedisTemplate template;
7.     @RequestMapping("/buy1")
8.     public String index(){
9.         // Redis中存有goods:001号商品，数量为100
10.         String result = template.opsForValue().get("goods:001");
11.         // 获取到剩余商品数
12.         int total = result == null ? 0 : Integer.parseInt(result);
13.         if( total > 0 ){
14.             // 剩余商品数大于0 ，则进行扣减
15.             int realTotal = total -1;
16.             // 将商品数回写数据库
17.             template.opsForValue().set("goods:001",String.valueOf(realTotal));
18.             System.out.println("购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001");
19.             return "购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001";
20.         }else{
21.             System.out.println("购买商品失败，服务端口为8001");
22.         }
23.         return "购买商品失败，服务端口为8001";
24.     }
25. }

复制代码

利用Jmeter模拟高并发场景，测试结果如下

测试结果出现多个用户购买同一商品，发生了数据差别等题目！
办理办法：单体应用的情况下，对并发的操作进行加锁操作，保证对数据的操作具有原子性

• synchronized
  
• ReentrantLock
  

synchronized （自动获取锁，并在退出时自动开释锁）去实现如下

1. @RestController  
2. public class IndexController2 {  
3.   
4.     @Autowired  
5.     StringRedisTemplate template;  
6.   
7.     @RequestMapping("/buy2")  
8.     public synchronized String index() {  
9.         String result = template.opsForValue().get("goods:001");  
10.         int total = result == null ? 0 : Integer.parseInt(result);  
11.         if (total > 0) {  
12.             int realTotal = total - 1;  
13.             template.opsForValue().set("goods:001", String.valueOf(realTotal));  
14.             System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");  
15.             return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";  
16.         } else {  
17.             System.out.println("购买商品失败，服务端口为8001");  
18.         }  
19.         return "购买商品失败，服务端口为8001";  
20.     }  
21. }

复制代码

ReentrantLock（必要手动获取锁，并在退出时手动开释锁） 去实现
在针对单体应用时的操作（ReentrantLock去实现相对来说好一点，由于颗粒度更细）

1. @RestController
2. public class IndexController2 {
4.     // 使用ReentrantLock锁解决单体应用的并发问题
5.     Lock lock = new ReentrantLock();
7.     @Autowired
8.     StringRedisTemplate template;
10.     @RequestMapping("/buy2")
11.     public String index() {
13.         lock.lock();
14.         try {
15.             String result = template.opsForValue().get("goods:001");
16.             int total = result == null ? 0 : Integer.parseInt(result);
17.             if (total > 0) {
18.                 int realTotal = total - 1;
19.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
20.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
21.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
22.             } else {
23.                 System.out.println("购买商品失败，服务端口为8001");
24.             }
25.         } catch (Exception e) {
26.             lock.unlock();
27.         } finally {
28.             lock.unlock();
29.         }
30.         return "购买商品失败，服务端口为8001";
31.     }
32. }

复制代码

100个商品100个人买最后剩余为0
场景二：分布式架构部署

提供两个服务，端口分别为8001、8002，连接同一个Redis服务，在服务前面有一台Nginx作为负载均衡

两台服务代码相同，只是端口差别
将8001、8002两个服务启动，每个服务依然用ReentrantLock加锁，用Jmeter做并发测试，发现会出现数据同等性题目！

我这边直接写终极版本（存粹的只用redis）
   要求：
1.保证自己加的锁，自己删自己的（由以下的uuid生成value去控制，以防止其他的线程把自己的删除了或者自己删除了别人的）


  

• REDIS_LOCK: 这是你想要设置的Redis键（Key）。在分布式锁的场景中，它通常是一个唯一的字符串，用于标识某个资源或操作。
  
• value: 这是你想要设置的Redis值（Value）。在分布式锁的场景中，这通常是一个表示锁持有者的唯一标识，例如线程ID或进程ID。
  
• 10L: 这是锁的过期时间，单位是秒。这意味着如果持有锁的客户端在这个时间内没有开释锁（例如，由于崩溃或网络题目），那么锁将自动过期，其他客户端可以获取它。这是一个重要的安全机制，可以防止死锁。
  
• TimeUnit.SECONDS: 这是时间单位。TimeUnit是一个罗列范例，表示时间的单位，如毫秒、秒、分钟等。在这里，我们利用SECONDS表示过期时间是以秒为单位的。
  

    redis事件或lua脚本（lua脚本的实行是原子的）,如下

1. @RestController
2. public class IndexController7 {
4.     public static final String REDIS_LOCK = "lock";
6.     @Autowired
7.     StringRedisTemplate template;
9.     @RequestMapping("/buy7")
10.     public String index(){
12.         // 每个人进来先要进行加锁，key值为"lock"
13.         String value = UUID.randomUUID().toString().replace("-","");
14.         try{
15.             // 为key加一个过期时间
16.             Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
17.             // 加锁失败
18.             if(!flag){
19.                 return "抢锁失败！";
20.             }
21.             System.out.println( value+ " 抢锁成功");
22.             String result = template.opsForValue().get("goods:001");
23.             int total = result == null ? 0 : Integer.parseInt(result);
24.             if (total > 0) {
25.                 // 如果在此处需要调用其他微服务，处理时间较长。。。
26.                 int realTotal = total - 1;
27.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
28.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
29.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
30.             } else {
31.                 System.out.println("购买商品失败，服务端口为8001");
32.             }
33.             return "购买商品失败，服务端口为8001";
34.         }finally {
35.             // 谁加的锁，谁才能删除
36.             // 也可以使用redis事务
37.             // https://redis.io/commands/set
38.             // 使用Lua脚本，进行锁的删除
40.             Jedis jedis = null;
41.             try{
42.                 jedis = RedisUtils.getJedis();
44.                 String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
45.                         "then " +
46.                         "return redis.call('del',KEYS[1]) " +
47.                         "else " +
48.                         "   return 0 " +
49.                         "end";
51.                 Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
52.                 if("1".equals(eval.toString())){
53.                     System.out.println("-----del redis lock ok....");
54.                 }else{
55.                     System.out.println("-----del redis lock error ....");
56.                 }
57.             }catch (Exception e){
59.             }finally {
60.                 if(null != jedis){
61.                     jedis.close();
62.                 }
63.             }
65. // redis事务
66. //            while(true){
67. //                template.watch(REDIS_LOCK);
68. //                if(template.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
69. //                    template.setEnableTransactionSupport(true);
70. //                    template.multi();
71. //                    template.delete(REDIS_LOCK);
72. //                    List<Object> list = template.exec();
73. //                    if(list == null){
74. //                        continue;
75. //                    }
76. //                }
77. //                template.unwatch();
78. //                break;
79. //            }
82.         }
83.     }
84. }

复制代码

（二） Redisson去实现

先引入maven依靠（redisson和springboot的集成包）

1. <!-- 添加Redisson依赖 -->  
2. <dependency>
3.   <groupId>org.redisson</groupId>
4.   <artifactId>redisson-spring-boot-starter</artifactId>
5.   <version>3.15.0</version>
6.   <exclusions>
7.     <exclusion>
8.       <groupId>org.redisson</groupId>
9.       <!-- 默认是 Spring Data Redis v.2.3.x ,所以排除掉-->
10.       <artifactId>redisson-spring-data-23</artifactId>
11.     </exclusion>
12.   </exclusions>
13. </dependency>

复制代码

网上其他的有可能是引入

1. <dependency>
2.     <groupId>org.redisson</groupId>
3.     <artifactId>redisson</artifactId>
4.     <version>3.6.1</version>
5. </dependency>

复制代码

根据以上例子用redisson去实现分布式锁，更加nice
利用Redisson的getLock方法时，你现实上是在利用RedLock（红锁）算法来获取分布式锁

1. @RestController
2. public class IndexController8 {
4.     public static final String REDIS_LOCK = "lock";
6.     @Autowired
7.     StringRedisTemplate template;
9.     @Autowired
10.     Redisson redisson;
12.     @RequestMapping("/buy8")
13.     public String index(){
14.         //创建锁“lock”
15.         RLock lock = redisson.getLock(REDIS_LOCK);
16.         //加锁
17.         lock.lock();
18.         
19.         try{
20.             String result = template.opsForValue().get("goods:001");
21.             int total = result == null ? 0 : Integer.parseInt(result);
22.             if (total > 0) {
23.                 // 如果在此处需要调用其他微服务，处理时间较长。。。
24.                 int realTotal = total - 1;
25.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
26.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
27.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
28.             } else {
29.                 System.out.println("购买商品失败，服务端口为8001");
30.             }
31.             return "购买商品失败，服务端口为8001";
32.         }finally {
33.         //避免竞态条件，不要if判断检查锁的状态。需直接使用 lock.unlock();
34. //            if(lock.isLocked() && lock.isHeldByCurrentThread()){
35. //                lock.unlock();
36. //            }
37.              lock.unlock();
38.         }
39.     }
40. }

复制代码

总结

现实为了保证redis高可用，redis一般会集群部署。
redis集群办理方案,利用redlock办理（redlock的特点如下）:

• 次序向5个节点哀求加锁（5个节点相互独立，没任何关系）
  
• 根据超时时间来判断是否要跳过该节点
  
• 如果大于等于3节点加锁乐成，并且利用时间小于锁有效期，则加锁乐成，否则获取锁失败，解锁
  

参考文章
【1】SpringBoot教程(十四) | SpringBoot集成Redis(全网最全)
【2】Redis实现分布式锁方法详细
【3】Redis实现分布式锁
【4】陪你一起学redis(十一)——redis分布式锁

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