扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >详解SpringBoot中时间类型的序列化与反序列化
  • 784

0
分享到

详解SpringBoot中时间类型的序列化与反序列化

SpringBoot时间类型序列化 反序列化SpringBoot 序列化 反序列化SpringBoot 序列化SpringBoot 反序列化 2023-02-02 12:02:11 784人浏览 泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录背景约定反序列化局部处理反序列化全局处理序列化局部处理全局处理推荐配置背景 前后端进行时间类型的传递时，往往是 前端传递时间格式的字符串，后端反序列化成对应的时间类型后端返回数据

背景

前后端进行时间类型的传递时，往往是

  • 前端传递时间格式的字符串，后端反序列化成对应的时间类型
  • 后端返回数据时，一般是将时间类型的对象，序列化成时间格式的字符串

spring 的生态中已经为我们提供了对应的解决方案

约定

如下是对本文的讨论背景做出的约定

反序列化

时间格式字符串->时间类型

常见于前端传参，一般分为4种情况

  • Post + Content-Type : application/json
  • Post + Content-Type : application/x-www-fORM-urlencoded
  • Post + Content-Type : multipart/form-data
  • Get

以上四种最常见情况，每种数据编码格式都不一样，因此对应的反序列化方法也不同

在 Spring web 生态中，对于 Post + Content-Type : application/json 的方式 一般是用 json 工具进行反序列化，例如 Spring 自带的 jackson，抑或是阿里巴巴的 fastjson

而其它非 json 提交的情况， json 工具就派不上用场了，Spring 提供了额外的反序列化方式，来处理这些情况

局部处理反序列化

局部处理反序列化的好处在于，粒度更细，使用更灵活，在 Spring web 生态中有两种局部处理方式，来处理上述4种常见情况

@JsonFormat 或 @JSONField

@JsonFormat 或 @JSONField 注解都可以用在时间类型的字段上,用来对该字段提供反序列化支持，例如

@JSONField(format="yyyy-MM-dd HH:mm:ss")
private Date date;

@JSONField(format="yyyy-MM-dd HH:mm:ss")
private LocalDateTime localDateTime4;

@JSONField(format="yyyy-MM-dd")
private LocalDate localDate;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date date;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime localDateTime4;

@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate localDate;

注意 @JsonFormat 或 @JSONField 注解，只能用于json(Post + Content-Type : application/json)提交的反序列化，表单提交或者Get提交是不支持的

// 这种带 @RequestBody 的 Pojo ，内部的 时间类型字段就可以使用  @JsonFormat 或 @JSONField
@PostMapping("/json")
public Pojo json(@RequestBody Pojo pojo) {
    return pojo;
}

@JsonFormat 、 @JSONField 的区别与使用@JsonFormat 注解来源于 Spring web 自带 jackson，无需配置直接可以使用
@JSONField 注解来源于阿里巴巴的 fastjson，需要进行配置，用 fastjson 替换掉Spring web 默认使用的 jackson 之后，才能使用。

@DateTimeFormat

@DateTimeFormat 是 Spring web 提供的针对非 json 提交，如

  • Post + Content-Type : application/x-www-form-urlencoded
  • Post + Content-Type : multipart/form-data
  • Get

等方式时，时间类型的反序列化解决方案

// Get 传参的 Pojo ，内部的 时间类型字段可以使用 @DateTimeFormat 进行反序列化
@GetMapping
public Pojo get(Pojo pojo) {
    return pojo;
}

// 表单传参的 Pojo ，内部的 时间类型字段可以使用 @DateTimeFormat 进行反序列化
@PostMapping
public Pojo post(Pojo pojo) {
    return pojo;
}

@DateTimeFormat 的用法

@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date date;

@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime localDateTime;

@DateTimeFormat(pattern = "yyyy-MM-dd")
private LocalDate localDate;

全局处理

Spring web 对于 json 传参 使用的是 HttpMessageConverter<T> 转换类，而时间字符串作为普通请求参数传入时，转换用的是 Converter<S, T>, Converter 的不同，意味着处理方式也不同。

非 json 传参的反序列化全局处理

import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.TimeZone;


@Configuration
public class DateConverterConfig {

    
    private static final String DATE_REGEX = "[1-9]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])";

    
    private static final String TIME_REGEX = "(20|21|22|23|[0-1]\d):[0-5]\d:[0-5]\d";

    
    private static final String DATE_TIME_REGEX = DATE_REGEX + "\s" + TIME_REGEX;

    
    private static final String DATE_T_TIME_REGEX = DATE_REGEX + "T" + TIME_REGEX;

    
    private static final String DATE_T_TIME_MS_REGEX = DATE_REGEX + "T" + TIME_REGEX + ".\d{3}";

    
    private static final String TIME_STAMP_REGEX = "1\d{12}";

    
    private static final String YEAR_MONTH_REGEX = "[1-9]\d{3}-(0[1-9]|1[0-2])";

    
    private static final String YEAR_MONTH_PATTERN = "yyyy-MM";

    
    private static final String DEFAULT_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    
    private static final String DEFAULT_DATETIME_ISO_PATTERN = "yyyy-MM-ddTHH:mm:ss";

    
    private static final String DEFAULT_DATETIME_MS_ISO_PATTERN = "yyyy-MM-ddTHH:mm:ss.SSS";

    
    private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";

    
    private static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    
    private SimpleDateFormat getSimpleDateFormat(String pattern){
        SimpleDateFormat df =  new SimpleDateFormat(pattern);
        System.out.println(TimeZone.getDefault());
        df.setTimeZone(TimeZone.getTimeZone ("GMT"));
        return df;
    }

    
    @Bean
    public Converter<String, Date> dateConverter() {
        return new Converter<String, Date>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public Date convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // 13位毫秒值 -> Date
                if (source.matches(TIME_STAMP_REGEX)) {
                    return new Date(Long.parseLong(source));
                }
                try {
                    // yyyy-MM-dd HH:mm:ss -> Date
                    if (source.matches(DATE_TIME_REGEX)) {
                        return getSimpleDateFormat(DEFAULT_DATETIME_PATTERN).parse(source);
                    }

                    // yyyy-MM-dd -> Date
                    if (source.matches(DATE_REGEX)) {
                        return getSimpleDateFormat(DEFAULT_DATE_FORMAT).parse(source);
                    }

                    // yyyy-MM -> Date
                    if (source.matches(YEAR_MONTH_REGEX)) {
                        return getSimpleDateFormat(YEAR_MONTH_PATTERN).parse(source);
                    }
                } catch (ParseException e) {
                    throw new RuntimeException(e);
                }
                return null;
            }
        };
    }


    
    @Bean
    public Converter<String, LocalDateTime> localDateTimeConverter() {
        return new Converter<String, LocalDateTime>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public LocalDateTime convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // 13位毫秒值 -> LocalDateTime
                if (source.matches(TIME_STAMP_REGEX)) {
                    Instant instant = Instant.ofEpochMilli(Long.parseLong(source));
                    ZoneId zone = ZoneId.systemDefault();
                    return LocalDateTime.ofInstant(instant, zone);
                }
                // yyyy-MM-dd HH:mm:ss -> LocalDateTime
                if (source.matches(DATE_TIME_REGEX)) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN));
                }

                // yyyy-MM-ddTHH:mm:ss -> LocalDateTime
                if (source.matches(DATE_T_TIME_REGEX)) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_ISO_PATTERN));
                }

                // yyyy-MM-ddTHH:mm:ss.SSS -> LocalDateTime
                if (source.matches(DATE_T_TIME_MS_REGEX)) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_MS_ISO_PATTERN));
                }

                return null;
            }
        };
    }

    
    @Bean
    public Converter<String, LocalDate> localDateConverter() {
        return new Converter<String, LocalDate>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public LocalDate convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // 13位毫秒值 -> LocalDate
                if (source.matches(TIME_STAMP_REGEX)) {
                    Instant instant = Instant.ofEpochMilli(Long.parseLong(source));
                    ZoneId zone = ZoneId.systemDefault();
                    return LocalDateTime.ofInstant(instant, zone).toLocalDate();
                }

                // yyyy-MM-dd -> LocalDate
                if (source.matches(DATE_REGEX)) {
                    return LocalDate.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT));
                }

                return null;
            }
        };
    }

    
    @Bean
    public Converter<String, LocalTime> localTimeConverter() {
        return new Converter<String, LocalTime>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public LocalTime convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // HH:mm:ss -> LocalTime
                return LocalTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT));
            }
        };
    }

}

注意：使用了自定义参数转化器（Converter），Spring 会优先使用该方式进行处理，@DateTimeFormat 注解将不生效!!! 这两种方案是不兼容!!!

json 传参的反序列化全局处理

如果是 json 传参，反序列化时，可以通过配置 json 工具进行全局处理。

以 Spring web 自带的 jackson 为例，它配置全局时间格式化时， java.util 包中的时间类型与 java 8 之后引入了 java.time 包中的时间类型，要分开配置

全局配置 java.util 包中的时间类型的反序列化格式

常用的时间类型包括

  • java.util.Date
  • java.util.Calendar

通过配置文件配置，以 yaml 为例

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

这是最简单的配置方式，也可以采取其他方式，这里就不例举了

全局配置 java.time 包中的时间类型的反序列化格式

常用的时间类型包括

  • java.time.LocalDateTime
  • java.time.LocalDate
@Configuration
public class JacksonConfig {
    private static final String DATE_FORMAT = "yyyy-MM-dd";
    private static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return builder -> {
            builder.deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
            builder.deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
        };
    }
}

序列化

时间类型->时间格式字符串

常见于后端返回，现在后端接口，返回格式一般都采用 json ，因此处理起来比反序列化要简单

局部处理

在要返回类的时间类型字段上使用 @JsonFormat 或 @JSONField 注解，来对该字段提供序列化支持。例如

@JSONField(format="yyyy-MM-dd HH:mm:ss")
private Date date;

@JSONField(format="yyyy-MM-dd HH:mm:ss")
private LocalDateTime localDateTime4;

@JSONField(format="yyyy-MM-dd")
private LocalDate localDate;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date date;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime localDateTime4;

@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate localDate;

是的 @JsonFormat 或 @JSONField 注解，既能用于json提交的反序列化，也能用于返回 json 的序列化

同样，使用 @JSONField 注解之前，需要先进行配置。用 fastjson 替换掉Spring web 默认使用的 jackson 之后，才能使用。

全局处理

以 Spring web 自带的 jackson 为例，它配置全局时间格式化时， java.util 包中的时间类型与 java 8 之后引入了 java.time 包中的时间类型，要分开配置

全局配置 java.util 包中的时间类型的序列化格式

常用的时间类型包括

  • java.util.Date
  • java.util.Calendar

通过配置文件配置

以 yaml 为例

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

这是最简单的配置方式，也可以采取其他方式，这里就不例举了

全局配置 java.time 包中的时间类型的序列化格式

常用的时间类型包括

  • java.time.LocalDateTime
  • java.time.LocalDate
@Configuration
public class JacksonConfig {
    private static final String DATE_FORMAT = "yyyy-MM-dd";
    private static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return jacksonObjectMapperBuilder -> {
            // 配置 Jackson 序列化 LocalDate、LocalDateTime 时使用的格式
            jacksonObjectMapperBuilder.serializers(new LocalDateSerializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
            jacksonObjectMapperBuilder.serializers(new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
        };
    }
}

推荐配置

对时间类型进行 序列化 时, 由于统一返回的都是 json 格式，推荐进行全局配置，实际开发过程中，如果遇到特殊情况，再选择用 @JsonFormat 进行局部覆盖

对时间类型进行 反序列化 时

  • 如果是 json 传参同样推荐全局配置，实际开发过程中，如果遇到特殊情况，再选择用 @JsonFormat 进行局部覆盖。
  • 如果是 Get 请求或是 Post表单，全局配置 Converter<S, T> 后，@DateTimeForma 注解将失效。看情况自行选择。

配置一览

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

@Configuration
public class JacksonConfig {
    private static final String DATE_FORMAT = "yyyy-MM-dd";
    private static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return jacksonObjectMapperBuilder -> {
            // 配置 Jackson 序列化 LocalDate、LocalDateTime 时使用的格式
            jacksonObjectMapperBuilder.serializers(new LocalDateSerializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
            jacksonObjectMapperBuilder.serializers(new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
            // 配置 Jackson 反序列化 LocalDate、LocalDateTime 时使用的格式
            jacksonObjectMapperBuilder.deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
            jacksonObjectMapperBuilder.deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
        };
    }
}
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.TimeZone;


@Configuration
public class DateConverterConfig {

    
    private static final String DATE_REGEX = "[1-9]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])";

    
    private static final String TIME_REGEX = "(20|21|22|23|[0-1]\d):[0-5]\d:[0-5]\d";

    
    private static final String DATE_TIME_REGEX = DATE_REGEX + "\s" + TIME_REGEX;

    
    private static final String DATE_T_TIME_REGEX = DATE_REGEX + "T" + TIME_REGEX;

    
    private static final String DATE_T_TIME_MS_REGEX = DATE_REGEX + "T" + TIME_REGEX + ".\d{3}";

    
    private static final String TIME_STAMP_REGEX = "1\d{12}";

    
    private static final String YEAR_MONTH_REGEX = "[1-9]\d{3}-(0[1-9]|1[0-2])";

    
    private static final String YEAR_MONTH_PATTERN = "yyyy-MM";

    
    private static final String DEFAULT_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    
    private static final String DEFAULT_DATETIME_ISO_PATTERN = "yyyy-MM-ddTHH:mm:ss";

    
    private static final String DEFAULT_DATETIME_MS_ISO_PATTERN = "yyyy-MM-ddTHH:mm:ss.SSS";

    
    private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";

    
    private static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    
    private SimpleDateFormat getSimpleDateFormat(String pattern){
        SimpleDateFormat df =  new SimpleDateFormat(pattern);
        System.out.println(TimeZone.getDefault());
        df.setTimeZone(TimeZone.getTimeZone ("GMT"));
        return df;
    }

    
    @Bean
    public Converter<String, Date> dateConverter() {
        return new Converter<String, Date>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public Date convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // 13位毫秒值 -> Date
                if (source.matches(TIME_STAMP_REGEX)) {
                    return new Date(Long.parseLong(source));
                }
                try {
                    // yyyy-MM-dd HH:mm:ss -> Date
                    if (source.matches(DATE_TIME_REGEX)) {
                        return getSimpleDateFormat(DEFAULT_DATETIME_PATTERN).parse(source);
                    }

                    // yyyy-MM-dd -> Date
                    if (source.matches(DATE_REGEX)) {
                        return getSimpleDateFormat(DEFAULT_DATE_FORMAT).parse(source);
                    }

                    // yyyy-MM -> Date
                    if (source.matches(YEAR_MONTH_REGEX)) {
                        return getSimpleDateFormat(YEAR_MONTH_PATTERN).parse(source);
                    }
                } catch (ParseException e) {
                    throw new RuntimeException(e);
                }
                return null;
            }
        };
    }


    
    @Bean
    public Converter<String, LocalDateTime> localDateTimeConverter() {
        return new Converter<String, LocalDateTime>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public LocalDateTime convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // 13位毫秒值 -> LocalDateTime
                if (source.matches(TIME_STAMP_REGEX)) {
                    Instant instant = Instant.ofEpochMilli(Long.parseLong(source));
                    ZoneId zone = ZoneId.systemDefault();
                    return LocalDateTime.ofInstant(instant, zone);
                }
                // yyyy-MM-dd HH:mm:ss -> LocalDateTime
                if (source.matches(DATE_TIME_REGEX)) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN));
                }

                // yyyy-MM-ddTHH:mm:ss -> LocalDateTime
                if (source.matches(DATE_T_TIME_REGEX)) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_ISO_PATTERN));
                }

                // yyyy-MM-ddTHH:mm:ss.SSS -> LocalDateTime
                if (source.matches(DATE_T_TIME_MS_REGEX)) {
                    return LocalDateTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATETIME_MS_ISO_PATTERN));
                }

                return null;
            }
        };
    }

    
    @Bean
    public Converter<String, LocalDate> localDateConverter() {
        return new Converter<String, LocalDate>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public LocalDate convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // 13位毫秒值 -> LocalDate
                if (source.matches(TIME_STAMP_REGEX)) {
                    Instant instant = Instant.ofEpochMilli(Long.parseLong(source));
                    ZoneId zone = ZoneId.systemDefault();
                    return LocalDateTime.ofInstant(instant, zone).toLocalDate();
                }

                // yyyy-MM-dd -> LocalDate
                if (source.matches(DATE_REGEX)) {
                    return LocalDate.parse(source, DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT));
                }

                return null;
            }
        };
    }

    
    @Bean
    public Converter<String, LocalTime> localTimeConverter() {
        return new Converter<String, LocalTime>() {
            @SuppressWarnings("NullableProblems")
            @Override
            public LocalTime convert(String source) {
                if (StringUtils.isEmpty(source)) {
                    return null;
                }
                // HH:mm:ss -> LocalTime
                return LocalTime.parse(source, DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT));
            }
        };
    }

}

以上就是详解SpringBoot中时间类型的序列化与反序列化的详细内容，更多关于SpringBoot序列化 反序列化的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

--结束END--

本文标题: 详解SpringBoot中时间类型的序列化与反序列化

本文链接: https://lsjlt.com/news/193922.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 详解SpringBoot中时间类型的序列化与反序列化
    目录背景约定反序列化局部处理反序列化全局处理序列化局部处理全局处理推荐配置背景 前后端进行时间类型的传递时，往往是 前端传递时间格式的字符串，后端反序列化成对应的时间类型后端返回数据...
    99+
    2023-02-02
    SpringBoot时间类型序列化 反序列化 SpringBoot 序列化 反序列化 SpringBoot 序列化 SpringBoot 反序列化
  • golang函数类型的序列化与反序列化
    golang 函数类型可通过 encoding/gob 包实现序列化和反序列化。序列化：注册自定义类型并使用 gob.newencoder 将函数类型编码为字节数组。反序列化：使用 go...
    99+
    2024-04-29
    golang 序列化
  • JavaIO之序列化与反序列化详解
    目录1、什么是序列化与反序列化？2、为什么要做序列化？3、Java 怎么进行序列化？总结1、什么是序列化与反序列化？ 序列化：指把堆内存中的 Java 对象数据，通过某种方式把对象存...
    99+
    2024-04-02
  • 序列化与反序列化
    序列化(pickling) 　　把变量从内存中变成可存储或传输的过程 反序列化(unpickling) 　　把变量内容从序列化的对象重新读到内存里的过程 序列化&反序列化的意义　　在程序运行过程中，对象可在内存中被自由的修改　　一...
    99+
    2023-01-31
    序列 化与 序列化
  • Java对象的序列化与反序列化详解
    一、序列化和反序列化的概念把对象转换为字节序列的过程称为对象的序列化，把字节序列恢复为对象的过程称为对象的反序列化。对象的序列化主要有两种途径：Ⅰ . 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中Ⅱ.  在网络上传送对...
    99+
    2023-05-31
    java 序列化 反序列化
  • Java序列化与反序列化
    目录Java 序列化与反序列化序列化APIObjectOutputStreamObjectInputStreamserialVersionUIDTransient (瞬态变量)实例理...
    99+
    2023-05-14
    Java序列化 Java反序列化
  • Java基础之序列化与反序列化详解
    目录1、什么是序列化与反序列化？2、Java如何实现序列化和反序列化？3、如何自定义序列化和反序列化呢？4、writeObject和readObject方法5、serializabl...
    99+
    2024-04-02
  • Java序列化和反序列化(详解)
    一、理解Java序列化和反序列化 Serialization(序列化)：将java对象以一连串的字节保存在磁盘文件中的过程，也可以说是保存java对象状态的过程。序列化可以将数据永久保存在磁盘上(通常保存在文件中)。 deserializa...
    99+
    2023-09-11
    java 开发语言
  • Go语言中序列化与反序列化示例详解
    目录前言序列化array、slice、map、struct对象序列化的接口反序列化slice、map、struct反序列化总结前言 Go语言的序列化与反序列化在工作中十分常用，在Go...
    99+
    2024-04-02
  • 【反序列化漏洞-01】序列化与反序列化概述
    为什么要序列化 百度百科上关于序列化的定义是，将对象的状态信息转换为可以存储或传输的形式(字符串)的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区(非关系型键值对形式的数据库Redis，与数组类似)。以后，可以通过从存储区中...
    99+
    2023-09-06
    web安全 安全 反序列化 序列化 PHP反序列化漏洞 Powered by 金山文档
  • 【Java 基础篇】Java序列化与反序列化详解
    文章目录 导言一、序列化与反序列化的原理二、序列化与反序列化的使用方法1、序列化对象2、反序列化对象 三、序列化与反序列化的应用场景1、持久化存储2、网络传输3、缓存机制 总结 ...
    99+
    2023-10-08
    java jvm 开发语言
  • Python文件的应用之序列化与反序列化详解
    目录初识序列化与反序列化什么是序列化？可序列化的数据类型Python 中的jsondumps() 与 loads() 函数可序列化数据类型演示案例bool 、None 类型的序列化与...
    99+
    2024-04-02
  • 深入理解Java序列化与反序列化
    目录一、前言1.1 String1.2 Integer二、案例2.1 编写大象类2.2 大象测试类三、运行结果一、前言 序列化：将对象转换为二进制序列在网络中传输或保存到磁盘 反序列...
    99+
    2024-04-02
  • ＰＨＰ的序列化和反序列化详情
    目录一、PHP 为什么要反序列化？二、PHP如何反序列化？三、PHP反序列化漏洞1、常用 的魔术方法2、漏洞产生条件3、题目一、PHP 为什么要反序列化？ PHP程序执行结束以后会将...
    99+
    2024-04-02
  • SpringBoot之Json的序列化和反序列化问题
    目录控制json序列化/反序列化1. @JsonIgnoreProperties的用法2. @JsonProperty 注解3. @JsonCreator 注解4. @JsonSet...
    99+
    2024-04-02
  • springboot序列化和反序列化怎么定义
    在Spring Boot中，序列化和反序列化可以通过以下方式进行定义：1. 实现Serializable接口：在需要进行序列化和反序...
    99+
    2023-08-14
    springboot
  • C#实现XML序列化与反序列化
    目录一、使用 System.Xml.Serialization类1、定义元数据2、简单序列化与反序列化3、集合的序列化与反序列化4、在不能更改数据的情况下，可以用代码重载 XmlAt...
    99+
    2024-04-02
  • Java中序列化与反序列化的示例分析
    这篇文章将为大家详细讲解有关Java中序列化与反序列化的示例分析，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。一、前言序列化：将对象转换为二进制序列在网络中传输或保存到磁盘反序列化：从网络或磁盘中将二进制...
    99+
    2023-06-15
  • Python中序列化与反序列化的示例分析
    这篇文章将为大家详细讲解有关Python中序列化与反序列化的示例分析，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。初识序列化与反序列化什么是序列化？通俗一点来说，序列化就是将 对象的信息 或者 数据结构的...
    99+
    2023-06-29
  • 一文搞懂Java中的序列化与反序列化
    目录序列化和反序列化的概念应用场景序列化实现的方式继承Serializable接口，普通序列化继承Externalizable接口，强制自定义序列化serialVersionUID的...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作