<think>嗯，用户现在想了解Spring Boot的
序列化。首先，我需要确认他们对
序列化的基本概念是否清楚。
序列化就是把对象转换成字节流或其他格式，以便存储或传输，反
序列化则是相反的过程。Spring Boot中常用的是JSON
序列化，可能用到Jackson或者Gson库。
接下来，用户可能想知道在Spring Boot中如何配置和自定义
序列化。比如，如何控制日期格式、处理空值、或者自定义字段名称。这时候需要提到Jackson的注解，比如@JsonFormat、@JsonInclude，以及如何通过配置类
修改ObjectMapper的设置。
另外，用户可能遇到实际问题，比如循环引用导致
序列化失败，或者需要忽略某些字段。这时候需要解释@JsonIgnore、@JsonManagedReference和@JsonBackReference的用法，以及如何配置ObjectMapper来忽略null值。
可能用户还关心性能方面的优化，比如使用哪个库更高效，或者如何自定义
序列化器。这时候需要比较Jackson和Gson的特点，说明如何通过实现JsonSerializer来自定义处理逻辑。
此外，用户可能不清楚Spring Boot
默认使用的
序列化库是什么，以及如何切换。需要指出Spring Boot
默认使用Jackson，并给出切换为Gson的配置方法，比如在pom.xml中排除Jackson并引入Gson依赖，然后在配置文件中设置。
还要考虑到实际开发中的常见问题，比如LocalDateTime的格式处理，或者多态类型的
序列化。这时候需要提供具体的代码示例，比如在实体类中使用@JsonFormat注解，或者配置ObjectMapper注册模块来处理Java 8的日期类型。
最后，总结一下Spring Boot
序列化的关键点，强调配置灵活性和常用注解的使用，帮助用户系统理解并应用到实际项目中。</think>### Spring Boot
序列化 **系统详解**
---
#### 一、
序列化的核心概念
1. **什么是
序列化？**
- **
序列化**：将对象转换为可存储或传输的格式（如 JSON、XML、二进制流）。
- **反
序列化**：将
序列化后的数据还原为对象。
- **应用场景**：
HTTP API 响应、缓存存储、消息队列传输等。
2. **Spring Boot 中的
默认序列化工具**
- **Jackson**：Spring Boot
默认集成（通过 `spring-boot-starter-web`），支持 JSON
序列化与反
序列化。
- 其他选项：Gson、Fastjson（需手动配置）。
---
#### 二、Jackson 的 **核心配置**
1. **全局配置（`application.properties`）**
```properties
# 日期格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8
# 空值处理
spring.jackson.default-property-inclusion=non_null # 忽略 null 值
# 美化输出
spring.jackson.serialization.indent-output=true
```
2. **自定义 `ObjectMapper`**
```java
@Configuration
public class JacksonConfig {
@Bean
public ObjectMapper objectMapper
() {
ObjectMapper mapper = new ObjectMapper
();
mapper.setDateFormat
(new SimpleDateFormat
("yyyy-MM-dd"
));
mapper.setSerializationInclusion
(JsonInclude.Include.NON_EMPTY
); // 忽略空值和空字符串
mapper.configure
(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false
); // 忽略未知字段
return mapper;
}
}
```
---
#### 三、常用 **注解**
1. **字段控制**
| 注解 | 作用 |
|---------------------|----------------------------------------|
| `@JsonIgnore` | 忽略字段（
序列化和反
序列化均不处理） |
| `@JsonProperty` | 自定义 JSON 字段名（如 `@JsonProperty
("user_name"
)`） |
| `@JsonInclude` | 指定字段包含条件（如 `Include.NON_NULL`） |
2. **时间格式处理**
```java
public class User {
@JsonFormat
(pattern = "yyyy/MM/dd", timezone = "Asia/Shanghai"
)
private LocalDateTime createTime;
}
```
3. **多态类型处理**
```java
@JsonTypeInfo
(use = Id.NAME, include = As.PROPERTY, property = "type"
)
@JsonSubTypes
({
@JsonSubTypes.Type
(value = Dog.class, name = "dog"
),
@JsonSubTypes.Type
(value = Cat.class, name = "cat"
)
}
)
public abstract class Animal { /* ... */ }
```
---
#### 四、**自定义
序列化器**
1. **实现 `JsonSerializer`**
```java
public class CustomDateSerializer extends JsonSerializer<LocalDateTime> {
@Override
public void serialize
(LocalDateTime value, JsonGenerator gen, SerializerProvider provider
)
throws IOException {
gen.writeString
(value.format
(DateTimeFormatter.ISO_LOCAL_DATE_TIME
));
}
}
// 在字段上应用
public class Order {
@JsonSerialize
(using = CustomDateSerializer.class
)
private LocalDateTime orderTime;
}
```
2. **注册自定义模块**
```java
@Bean
public Module customModule
() {
SimpleModule module = new SimpleModule
();
module.addSerializer
(LocalDateTime.class, new CustomDateSerializer
());
return module;
}
```
---
#### 五、**处理循环引用**
1. **问题场景**
```java
@Entity
public class User {
@OneToMany
(mappedBy = "user"
)
private List<Order> orders;
}
@Entity
public class Order {
@ManyToOne
@JoinColumn
(name = "user_id"
)
private User user;
}
```
-
序列化 `User` 时会递归
序列化 `Order`，导致堆栈溢出。
2. **解决方案**
- **使用 `@JsonIgnore`**：
```java
public class User {
@JsonIgnore // 忽略 orders 字段的
序列化
private List<Order> orders;
}
```
- **使用 `@JsonManagedReference` 和 `@JsonBackReference`**：
```java
public class User {
@JsonManagedReference // 标记“主控方”
private List<Order> orders;
}
public class Order {
@JsonBackReference // 标记“被控方”
private User user;
}
```
---
#### 六、**切换
序列化工具（如 Gson）**
1. **排除 Jackson，引入 Gson**
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>
```
2. **配置 Gson**
```java
@Bean
public Gson gson
() {
return new GsonBuilder
()
.setDateFormat
("yyyy-MM-dd"
)
.serializeNulls
() //
序列化 null 值
.create
();
}
```
---
#### 七、**常见问题与调试**
1. **日期格式不一致**
- **现象**：返回的日期为长整型时间戳。
- **解决**：使用 `@JsonFormat` 注解或配置全局日期格式。
2. **字段丢失或命名不符合预期**
- **检查点**：确认是否使用 `@JsonProperty` 或 Lombok 的 `@Getter`/`@Setter`。
3. **
序列化性能优化**
- 使用 `Jackson` 的 `Afterburner` 模块加速：
```xml
<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
<artifactId>jackson-module-afterburner</artifactId>
</dependency>
```
---
### 总结
- **
默认使用 Jackson**：通过注解和配置可灵活控制
序列化行为。
- **关键注解**：`@JsonFormat`、`@JsonIgnore`、`@JsonProperty`。
- **避免循环引用**：使用 `@JsonManagedReference` 和 `@JsonBackReference`。
- **自定义需求**：通过实现 `JsonSerializer` 或切换
序列化工具（如 Gson）实现。
扫一扫
835
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
