<think>
我们需要将日期类型统一序列化为long类型（时间戳）的形式，同时数字类型保持原样（即不改变数字的序列化方式）。在Spring Boot中，默认情况下，Jackson会将`java.util.Date`序列化为时间戳（long类型），但对于Java 8的日期类型（如`LocalDateTime`）则可能序列化为数组形式。因此，我们需要统一配置，使得所有日期类型都序列化为long类型的时间戳（毫秒级或秒级）。
解决方案：
1. 对于传统的`java.util.Date`，默认就是时间戳，不需要额外配置。
2. 对于Java 8的日期类型，我们需要注册`JavaTimeModule`，并配置`SerializationFeature.WRITE_DATES_AS_TIMESTAMPS`，这样`JavaTimeModule`就会将Java 8日期类型序列化为时间戳（默认为毫秒级，即自1970-01-01T00:00:00Z以来的毫秒数）。
3. 注意：如果希望使用秒级时间戳，则可以通过自定义序列化器来实现。
具体步骤：
- 在`ObjectMapper`中禁用`WRITE_DATES_AS_TIMESTAMPS`会导致日期被序列化为字符串，因此我们需要启用`WRITE_DATES_AS_TIMESTAMPS`（默认是启用的，但为了确保，可以不禁用它，或者显式启用）。
- 注册`JavaTimeModule`以支持Java 8日期类型的序列化和反序列化。
- 如果需要秒级时间戳，我们可以为特定的日期类型注册自定义的序列化器，将日期转换为秒。
配置示例（毫秒级时间戳）：
```java
@Configuration
public class JacksonConfig {
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
// 注册Java 8时间模块
JavaTimeModule javaTimeModule = new JavaTimeModule();
mapper.registerModule(javaTimeModule);
// 启用将日期作为时间戳（毫秒）序列化
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
// 注意：对于Java 8日期类型，在注册了JavaTimeModule后，启用WRITE_DATES_AS_TIMESTAMPS就会将其序列化为时间戳
// 确保日期在反序列化时能正确转换时区
mapper.setTimeZone(TimeZone.getDefault());
return mapper;
}
}
```
但是，上述配置对于`LocalDateTime`等类型会序列化为一个数组（例如[2024,6,15,14,30,45,123456789]）而不是时间戳，这是因为`JavaTimeModule`默认对`LocalDateTime`的序列化并不是时间戳。因此，我们需要为`LocalDateTime`等类型自定义序列化器，将其转换为时间戳。
修正方案：为Java 8日期类型注册自定义的序列化器，将它们转换为毫秒或秒的时间戳。
例如，将`LocalDateTime`转换为毫秒时间戳（需要先转换为`Instant`，通常需要指定时区，因为`LocalDateTime`没有时区信息，所以我们需要指定一个时区来转换为UTC时间或其他时区的时间戳）：
```java
javaTimeModule.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
// 将LocalDateTime转换为指定时区（比如系统默认时区）的Instant，然后获取毫秒数
long millis = value.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
gen.writeNumber(millis);
}
});
```
同样，我们也可以处理`LocalDate`（转换为从1970-01-01开始的天数）：
```java
javaTimeModule.addSerializer(LocalDate.class, new JsonSerializer<LocalDate>() {
@Override
public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
// 将LocalDate转换为从1970-01-01开始的天数
long days = value.toEpochDay();
gen.writeNumber(days);
}
});
```
完整配置（统一为时间戳，包括毫秒和天）：
```java
@Configuration
public class JacksonConfig {
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
JavaTimeModule javaTimeModule = new JavaTimeModule();
// 处理LocalDateTime：转换为毫秒时间戳
javaTimeModule.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
long millis = value.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
gen.writeNumber(millis);
}
});
// 处理LocalDate：转换为天数
javaTimeModule.addSerializer(LocalDate.class, new JsonSerializer<LocalDate>() {
@Override
public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeNumber(value.toEpochDay());
}
});
// 处理ZonedDateTime：直接转换为毫秒时间戳（使用自带的InstantSerializer，但这里我们自定义以保持一致，也可以使用默认的，但默认会序列化为数组）
// 我们也可以使用内置的，但为了统一为时间戳，我们同样转换为毫秒
javaTimeModule.addSerializer(ZonedDateTime.class, new JsonSerializer<ZonedDateTime>() {
@Override
public void serialize(ZonedDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeNumber(value.toInstant().toEpochMilli());
}
});
// 处理Instant：直接转换为毫秒时间戳
javaTimeModule.addSerializer(Instant.class, new JsonSerializer<Instant>() {
@Override
public void serialize(Instant value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeNumber(value.toEpochMilli());
}
});
// 注册模块
mapper.registerModule(javaTimeModule);
// 对于传统的Date，默认就是时间戳，所以不需要额外配置
// 禁用日期序列化为字符串
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
// 设置时区
mapper.setTimeZone(TimeZone.getDefault());
return mapper;
}
}
```
注意：这样配置后，所有的日期类型都会被序列化为long类型的时间戳（毫秒或天）。在反序列化时，我们同样需要配置相应的反序列化器，因为默认情况下Jackson可能无法将long类型的时间戳转换为Java 8的日期类型。
因此，我们还需要添加反序列化器：
```java
// 为LocalDateTime添加反序列化器
javaTimeModule.addDeserializer(LocalDateTime.class, new JsonDeserializer<LocalDateTime>() {
@Override
public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
long millis = p.getLongValue();
return LocalDateTime.ofInstant(Instant.ofEpochMilli(millis), ZoneId.systemDefault());
}
});
// 为LocalDate添加反序列化器
javaTimeModule.addDeserializer(LocalDate.class, new JsonDeserializer<LocalDate>() {
@Override
public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
long days = p.getLongValue();
return LocalDate.ofEpochDay(days);
}
});
// 其他日期类型的反序列化类似
```
完整配置（包括序列化和反序列化）：
```java
@Configuration
public class JacksonConfig {
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
JavaTimeModule javaTimeModule = new JavaTimeModule();
// 序列化器
javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer());
javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer());
javaTimeModule.addSerializer(ZonedDateTime.class, new ZonedDateTimeSerializer());
javaTimeModule.addSerializer(Instant.class, new InstantSerializer());
// 反序列化器
javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer());
javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer());
javaTimeModule.addDeserializer(ZonedDateTime.class, new ZonedDateTimeDeserializer());
javaTimeModule.addDeserializer(Instant.class, new InstantDeserializer());
mapper.registerModule(javaTimeModule);
mapper.setTimeZone(TimeZone.getDefault());
return mapper;
}
// 以下为内部类定义序列化器和反序列化器
private static class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
long millis = value.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
gen.writeNumber(millis);
}
}
private static class LocalDateSerializer extends JsonSerializer<LocalDate> {
@Override
public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeNumber(value.toEpochDay());
}
}
private static class ZonedDateTimeSerializer extends JsonSerializer<ZonedDateTime> {
@Override
public void serialize(ZonedDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeNumber(value.toInstant().toEpochMilli());
}
}
private static class InstantSerializer extends JsonSerializer<Instant> {
@Override
public void serialize(Instant value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeNumber(value.toEpochMilli());
}
}
private static class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
@Override
public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
long millis = p.getLongValue();
return LocalDateTime.ofInstant(Instant.ofEpochMilli(millis), ZoneId.systemDefault());
}
}
private static class LocalDateDeserializer extends JsonDeserializer<LocalDate> {
@Override
public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
long days = p.getLongValue();
return LocalDate.ofEpochDay(days);
}
}
private static class ZonedDateTimeDeserializer extends JsonDeserializer<ZonedDateTime> {
@Override
public ZonedDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
long millis = p.getLongValue();
return ZonedDateTime.ofInstant(Instant.ofEpochMilli(millis), ZoneId.systemDefault());
}
}
private static class InstantDeserializer extends JsonDeserializer<Instant> {
@Override
public Instant deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
return Instant.ofEpochMilli(p.getLongValue());
}
}
}
```
注意：这里我们为每种类型都定义了序列化器和反序列化器。在实际应用中，可以根据需要选择配置哪些类型。
另外，对于传统的`java.util.Date`，Jackson默认已经支持时间戳序列化和反序列化，因此不需要额外配置。
这样配置后，所有日期类型都将被序列化为long类型的时间戳（毫秒或天），而数字类型（如Integer、Long、BigDecimal等）将保持原样（即序列化为数字，不会变成字符串）。
测试：创建一个Controller返回包含各种日期类型的对象，检查JSON输出是否为long类型。
相关问题：
1. 如何将日期类型统一序列化为秒级时间戳？
2. 在序列化为时间戳时，如何考虑时区的影响？
3. 反序列化时，如何处理不同时区的时间戳？
4. 如果某些接口需要返回格式化的日期字符串，而其他接口需要时间戳，如何实现？
注意：根据要求，我们最后需要以指定格式提出相关问题。
</think>### Spring Boot 中 ObjectMapper 统一日期为 Long 时间戳配置指南
#### 核心需求分析
当需要将日期类型统一序列化为 Long 类型时间戳时，需处理：
1. 传统 `java.util.Date` 类型
2. Java 8 时间类型（`LocalDateTime`, `Instant` 等）
3. 时区转换问题
4. 时间精度控制（毫秒/秒）
---
### 一、全局日期转 Long 配置方案
#### 1. 基础配置类
```java
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
@Configuration
public class TimestampConfig {
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
// 禁用日期字符串格式，启用时间戳格式
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
mapper.enable(SerializationFeature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS);
// 注册Java 8时间模块（自定义序列化器）
JavaTimeModule javaTimeModule = new JavaTimeModule();
// 配置LocalDateTime序列化为毫秒时间戳
javaTimeModule.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
long timestamp = value.atZone(ZoneId.systemDefault())
.toInstant()
.toEpochMilli();
gen.writeNumber(timestamp);
}
});
// 配置Instant序列化为毫秒时间戳
javaTimeModule.addSerializer(Instant.class, new JsonSerializer<Instant>() {
@Override
public void serialize(Instant value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
gen.writeNumber(value.toEpochMilli());
}
});
mapper.registerModule(javaTimeModule);
return mapper;
}
}
```
#### 2. 支持秒级时间戳
```java
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
// 配置秒级时间戳
JavaTimeModule module = new JavaTimeModule();
// LocalDateTime转秒级时间戳
module.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
long seconds = value.atZone(ZoneId.systemDefault())
.toEpochSecond();
gen.writeNumber(seconds);
}
});
// Instant转秒级时间戳
module.addSerializer(Instant.class, new JsonSerializer<Instant>() {
@Override
public void serialize(Instant value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
gen.writeNumber(value.getEpochSecond());
}
});
mapper.registerModule(module);
return mapper;
}
```
---
### 二、处理多种日期类型
#### 1. 支持所有日期类型转 Long
```java
@Bean
public ObjectMapper timestampObjectMapper() {
ObjectMapper mapper = new ObjectMapper();
JavaTimeModule module = new JavaTimeModule();
// 处理 java.util.Date
module.addSerializer(Date.class, new JsonSerializer<Date>() {
@Override
public void serialize(Date value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
gen.writeNumber(value.getTime());
}
});
// 处理 java.sql.Timestamp
module.addSerializer(java.sql.Timestamp.class, new JsonSerializer<java.sql.Timestamp>() {
@Override
public void serialize(java.sql.Timestamp value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
gen.writeNumber(value.getTime());
}
});
// 处理 ZonedDateTime
module.addSerializer(ZonedDateTime.class, new JsonSerializer<ZonedDateTime>() {
@Override
public void serialize(ZonedDateTime value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
gen.writeNumber(value.toInstant().toEpochMilli());
}
});
// 处理 OffsetDateTime
module.addSerializer(OffsetDateTime.class, new JsonSerializer<OffsetDateTime>() {
@Override
public void serialize(OffsetDateTime value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
gen.writeNumber(value.toInstant().toEpochMilli());
}
});
mapper.registerModule(module);
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
return mapper;
}
```
#### 2. 时区统一处理
```java
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
// 设置全局时区
mapper.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
JavaTimeModule module = new JavaTimeModule();
// 所有日期类型使用系统默认时区
module.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
ZoneId zoneId = ZoneId.systemDefault();
long timestamp = value.atZone(zoneId).toInstant().toEpochMilli();
gen.writeNumber(timestamp);
}
});
mapper.registerModule(module);
return mapper;
}
```
---
### 三、反序列化：Long 转日期对象
#### 1. 时间戳转日期配置
```java
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
JavaTimeModule module = new JavaTimeModule();
// Long转LocalDateTime
module.addDeserializer(LocalDateTime.class, new JsonDeserializer<LocalDateTime>() {
@Override
public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException {
long timestamp = p.getLongValue();
return LocalDateTime.ofInstant(
Instant.ofEpochMilli(timestamp),
ZoneId.systemDefault()
);
}
});
// Long转Date
module.addDeserializer(Date.class, new JsonDeserializer<Date>() {
@Override
public Date deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException {
return new Date(p.getLongValue());
}
});
// Long转Instant
module.addDeserializer(Instant.class, new JsonDeserializer<Instant>() {
@Override
public Instant deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException {
return Instant.ofEpochMilli(p.getLongValue());
}
});
mapper.registerModule(module);
return mapper;
}
```
#### 2. 智能时间戳转换器
```java
public class SmartTimestampDeserializer extends JsonDeserializer<Object> {
private final Class<?> targetType;
public SmartTimestampDeserializer(Class<?> targetType) {
this.targetType = targetType;
}
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException {
long timestamp = p.getLongValue();
Instant instant = Instant.ofEpochMilli(timestamp);
if (targetType == Date.class) {
return Date.from(instant);
} else if (targetType == LocalDateTime.class) {
return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
} else if (targetType == Instant.class) {
return instant;
} else if (targetType == ZonedDateTime.class) {
return ZonedDateTime.ofInstant(instant, ZoneId.systemDefault());
}
throw new IllegalArgumentException("Unsupported date type: " + targetType);
}
}
// 注册使用
module.addDeserializer(Date.class, new SmartTimestampDeserializer(Date.class));
module.addDeserializer(LocalDateTime.class, new SmartTimestampDeserializer(LocalDateTime.class));
```
---
### 四、测试与验证
#### 测试实体类
```java
public class TimestampModel {
private Date createTime;
private LocalDateTime updateTime;
private Instant eventTime;
private ZonedDateTime expireTime;
// 构造函数、getter和setter
}
```
#### 测试控制器
```java
@RestController
public class TimestampController {
@GetMapping("/timestamp")
public TimestampModel getTimestampModel() {
TimestampModel model = new TimestampModel();
model.setCreateTime(new Date());
model.setUpdateTime(LocalDateTime.now());
model.setEventTime(Instant.now());
model.setExpireTime(ZonedDateTime.now().plusDays(30));
return model;
}
@PostMapping("/timestamp")
public ResponseEntity<String> acceptTimestamp(@RequestBody TimestampModel model) {
// 验证反序列化结果
System.out.println("Received date: " + model.getCreateTime());
System.out.println("Received localDateTime: " + model.getUpdateTime());
return ResponseEntity.ok("Success");
}
}
```
#### 预期 JSON 输出
```json
{
"createTime": 1718433600000,
"updateTime": 1718433600000,
"eventTime": 1718433600000,
"expireTime": 1721025600000
}
```
---
### 五、高级配置技巧
#### 1. 时间戳精度动态控制
```java
public class PrecisionTimestampSerializer extends JsonSerializer<Object> {
private final ChronoUnit precision;
public PrecisionTimestampSerializer(ChronoUnit precision) {
this.precision = precision;
}
@Override
public void serialize(Object value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
long timestamp;
if (value instanceof TemporalAccessor) {
Instant instant;
if (value instanceof LocalDateTime) {
instant = ((LocalDateTime) value).atZone(ZoneId.systemDefault()).toInstant();
} else if (value instanceof ZonedDateTime) {
instant = ((ZonedDateTime) value).toInstant();
} else if (value instanceof Instant) {
instant = (Instant) value;
} else {
throw new IllegalArgumentException("Unsupported temporal type");
}
if (precision == ChronoUnit.MILLIS) {
timestamp = instant.toEpochMilli();
} else {
timestamp = instant.getEpochSecond();
}
} else if (value instanceof Date) {
long ms = ((Date) value).getTime();
timestamp = (precision == ChronoUnit.MILLIS) ? ms : ms / 1000;
} else {
throw new IllegalArgumentException("Unsupported date type");
}
gen.writeNumber(timestamp);
}
}
// 注册使用
module.addSerializer(Date.class, new PrecisionTimestampSerializer(ChronoUnit.SECONDS));
module.addSerializer(LocalDateTime.class, new PrecisionTimestampSerializer(ChronoUnit.MILLIS));
```
#### 2. 注解驱动配置
```java
// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = TimestampSerializer.class)
@JsonDeserialize(using = TimestampDeserializer.class)
public @interface TimestampFormat {
TimeUnit unit() default TimeUnit.MILLISECONDS;
}
// 在实体类中使用
public class Event {
@TimestampFormat(unit = TimeUnit.SECONDS)
private LocalDateTime eventTime;
@TimestampFormat
private Date createTime;
}
```
---
### 六、常见问题解决方案
#### 问题1：时区不一致
```java
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.setTimeZone(TimeZone.getTimeZone("UTC")); // 统一使用UTC时区
JavaTimeModule module = new JavaTimeModule();
module.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
// 强制转换为UTC时区
long timestamp = value.atZone(ZoneId.of("UTC")).toInstant().toEpochMilli();
gen.writeNumber(timestamp);
}
});
mapper.registerModule(module);
return mapper;
}
```
#### 问题2：前端传递字符串时间戳
```java
// 支持字符串格式的时间戳反序列化
module.addDeserializer(LocalDateTime.class, new JsonDeserializer<LocalDateTime>() {
@Override
public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException {
String value = p.getValueAsString();
try {
long timestamp = Long.parseLong(value);
return LocalDateTime.ofInstant(
Instant.ofEpochMilli(timestamp),
ZoneId.systemDefault()
);
} catch (NumberFormatException e) {
// 尝试解析ISO格式
return LocalDateTime.parse(value, DateTimeFormatter.ISO_DATE_TIME);
}
}
});
```
#### 问题3：空值处理
```java
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
// 允许日期字段为null
mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
// 配置空值处理
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
JavaTimeModule module = new JavaTimeModule();
module.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
@Override
public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
if (value == null) {
gen.writeNull(); // 返回null而不是0
} else {
long timestamp = value.atZone(ZoneId.systemDefault())
.toInstant()
.toEpochMilli();
gen.writeNumber(timestamp);
}
}
});
mapper.registerModule(module);
return mapper;
}
```
---
###
当数据库中的bigint类型数据通过接口传递给Vue前端时，出现了精度丢失。解决方案是通过在SpringBoot后端配置Jackson转换器，将Long类型序列化为String，以及对日期进行格式化处理，确保数据正确传输。
扫一扫
730
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
