<think>我们正在讨论Spring Boot集成
Redis时的
序列化与
反序列化配置。根据引用内容，特别是引用[3]和[4]，我们可以详细解释如下：
### 1
. 序列化与
反序列化的概念
- **
序列化**：将Java对象
转换为字节序列的过程，以便存储到
Redis或通过网络传输[^4]。
- **
反序列化**：将
Redis中存储的字节序列重新
转换为Java对象的过程[^4]。
###
2. 默认
序列化机制的问题
Spring Data
Redis默认
使用`JdkSerialization
RedisSerializer`，它有以下缺点：
-
序列化后的数据是二进制格式，可读性差
- 跨语言兼容性差（仅适用于Java）
- 可能存在安全漏洞（如
反序列化攻击）
### 3
. 常用
序列化方案
#### a) String
序列化
- 适用场景：键(key)的
序列化
- 实现：`String
RedisSerializer`
- 特点：将字符串直接
转换为字节数组（UTF-8编码）
#### b) JSON
序列化（推荐）
- 实现：`GenericJackson
2Json
RedisSerializer`
- 优点：
- 人类可读的文本格式
- 跨语言兼容
- 支持复杂对象
- 配置示例（引用[3]）：
```java
@Configuration
public class
RedisConfig {
@Bean
public
RedisTemplate<String, Object>
redisTemplate(
RedisConnectionFactory
redisConnectionFactory) {
RedisTemplate<String, Object> template = new
RedisTemplate<>();
template
.setConnectionFactory(
redisConnectionFactory);
// 键
使用字符串
序列化
template
.setKeySerializer(new String
RedisSerializer());
// 值
使用JSON
序列化
template
.setValueSerializer(new GenericJackson
2Json
RedisSerializer());
// Hash键
序列化
template
.setHashKeySerializer(new String
RedisSerializer());
// Hash值
序列化
template
.setHashValueSerializer(new GenericJackson
2Json
RedisSerializer());
return template;
}
}
```
- 依赖配置（引用[3]）：
```xml
<dependency>
<groupId>com
.fasterxml
.jackson
.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>
2.15.0</version>
</dependency>
```
#### c) 其他方案
- `Jackson
2Json
RedisSerializer`：需指定具体类型
- `GenericToStringSerializer`：通过Spring
转换服务实现
### 4
. 泛型处理（引用[
5]）
使用JSON
序列化时，处理泛型集合需通过`TypeReference`：
```java
List<User> users =
redisTemplate
.opsForValue()
.get("users", new TypeReference<List<User>>() {});
```
###
5. 序列化配置原理
```mermaid
graph LR
A[
RedisTemplate] --> B[
序列化器]
B --> C[键
序列化器]
B --> D[值
序列化器]
B --> E[Hash键
序列化器]
B --> F[Hash值
序列化器]
```
### 6
. 最佳实践
1
. **键统一
使用String
序列化**：确保键的可读性和兼容性
2. **值
使用JSON
序列化**：平衡可读性和数据结构支持
3
. **避免JDK默认
序列化**：除非明确需要Java专属环境
4
. **处理泛型时显式声明类型**：防止类型擦除问题[^
5]
### 示例：用户对象存储
```java
@Data
public class User {
private Long id;
private String name;
}
// 存储操作
User user = new User(1L, "Alice");
redisTemplate
.opsForValue()
.set("user:1", user);
// 读取操作
User cachedUser = (User)
redisTemplate
.opsForValue()
.get("user:1");
```
> **警告**：
使用`GenericJackson
2Json
RedisSerializer`时，JSON中会包含类全限定名（如`"@class":"com
.example
.User"`），可能导致安全问题和存储开销。若需隐藏类型信息，可
使用`Jackson
2Json
RedisSerializer`并显式指定类型。
§§相关问题§§
1
. Spring Boot集成
Redis时如何避免默认JDK
序列化带来的安全问题？
2. 使用JSON
序列化时如何
解决类型擦除问题？
3
. 如何为
Redis的不同数据结构（String/Hash/List）配置不同的
序列化策略？
</think>### Spring Boot集成
Redis序列化与
反序列化配置详解
#### 一、核心概念
1
. **
序列化（Serialization）**
将Java对象
转换为字节序列的过程，便于存储到
Redis或网络传输[^4]。
公式表示：$ \text{Object} \xrightarrow{\text{serialize}} \text{byte[]} $
2. **
反序列化（Deserialization）**
将
Redis中的字节序列恢复为Java对象的过程[^4]。
公式表示：$ \text{byte[]} \xrightarrow{\text{deserialize}} \text{Object} $
#### 二、默认行为与问题
- **默认
序列化器**：`JdkSerialization
RedisSerializer`
- **问题表现**：
```java
// 默认
序列化后的
Redis数据（不可读）
"\xac\xed\x00\x0
5t\x00\x0
5user:1"
```
- 产生二进制数据，可读性差[^3]
- 跨语言兼容性差
- 存储空间较大（包含类元信息）
#### 三、
序列化方案对比
|
序列化器 | 特点 | 适用场景 |
|----------------------------------|-----------------------------|---------------------|
| `JdkSerialization
RedisSerializer`| 默认，二进制格式 | 不推荐
使用 |
| `String
RedisSerializer` | 字符串格式，UTF-8编码 | **Key的
序列化** |
| `Jackson
2Json
RedisSerializer` | JSON格式，需指定类型 | 简单对象
序列化 |
| `GenericJackson
2Json
RedisSerializer` | JSON格式，记录类型信息 | **推荐方案**（通用场景）|
#### 四、最佳配置实践（基于引用[3]）
```java
@Configuration
public class
RedisConfig {
@Bean
public
RedisTemplate<String, Object>
redisTemplate(
RedisConnectionFactory
redisConnectionFactory) {
RedisTemplate<String, Object> template = new
RedisTemplate<>();
template
.setConnectionFactory(
redisConnectionFactory);
// Key
序列化：String格式
template
.setKeySerializer(new String
RedisSerializer());
// Value
序列化：JSON格式（带类型信息）
template
.setValueSerializer(new GenericJackson
2Json
RedisSerializer());
// HashKey
序列化
template
.setHashKeySerializer(new String
RedisSerializer());
// HashValue
序列化
template
.setHashValueSerializer(new GenericJackson
2Json
RedisSerializer());
return template;
}
}
```
##### 关键配置说明：
1
. **Key
序列化**
必须
使用`String
RedisSerializer`，确保Key可读性：
```java
redisTemplate
.opsForValue()
.set("user:1001", userObj); // Key显示为"user:1001"
```
2. **Value
序列化**
`GenericJackson
2Json
RedisSerializer`会在JSON中添加类型元数据：
```json
{
"@class": "com
.example
.User",
"id": 1001,
"name": "Alice"
}
```
3
. **必备依赖**（引用[3]）：
```xml
<dependency>
<groupId>com
.fasterxml
.jackson
.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>
2.15.0</version>
</dependency>
```
#### 五、特殊场景处理
1
. **泛型集合
反序列化**（引用[
5]）
使用`TypeReference`
解决类型擦除问题：
```java
List<User> users =
redisTemplate
.opsForValue()
.get("users", new TypeReference<List<User>>() {});
```
2. **自定义
序列化规则**
扩展`
RedisSerializer`接口：
```java
public class CustomSerializer implements
RedisSerializer<MyObject> {
@Override
public byte[] serialize(MyObject obj) {
// 自定义
序列化逻辑
}
@Override
public MyObject deserialize(byte[] bytes) {
// 自定义
反序列化逻辑
}
}
```
#### 六、配置效果对比
|
序列化方式 |
Redis数据示例 | 可读性 | 跨语言支持 |
|----------------|-------------------------------|-------|----------|
| JDK默认 | `\xac\xed\x00\x0
5t
...` | 差 | 不支持 |
| String | `"name:Alice"` | 优 | 支持 |
| **JSON（推荐）** | `{"@class":"
...","name":"Alice"}` | 良 | 支持 |
> **验证公式**：
序列化前后对象一致性
> $$ \text{deserialize(serialize}(obj)) \equiv obj $$
本文介绍了一种在SpringBoot结合Redis缓存时遇到的类型转换异常问题，该问题在单元测试中未出现，但在实际运行环境中发生。经过排查发现，问题根源在于SpringBoot DevTools导致的类加载器不一致。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
