Spring Boot 序列化、反序列化

1. 简介

在软件开发中，序列化和反序列化是一种将对象转换为字节流以便存储或传输的机制。序列化将对象转换为字节流，而反序列化则将字节流转换为对象。序列化和反序列化在许多应用场景中都起着重要的作用，比如在网络通信中传输对象、将对象存储到数据库中、实现分布式缓存等。

2. Java中的序列化和反序列化

Java提供了默认的序列化机制，可以通过实现Serializable接口来实现对象的序列化和反序列化。序列化的过程是将对象转换为字节流，可以通过ObjectOutputStream类来实现；反序列化的过程是将字节流转换为对象，可以通过ObjectInputStream类来实现。在进行序列化和反序列化时，需要注意一些事项，比如版本控制、字段的访问控制等。

import java.io.*;

public class SerializationDemo {
    public static void main(String[] args) {
        // 序列化对象
        try {
            // 创建一个对象
            User user = new User("John", 25);
            // 创建一个输出流
            FileOutputStream fileOut = new FileOutputStream("user.ser");
            // 创建一个对象输出流
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            // 将对象写入输出流
            out.writeObject(user);
            // 关闭流
            out.close();
            fileOut.close();
            System.out.println("Serialized data is saved in user.ser");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化对象
        try {
            // 创建一个输入流
            FileInputStream fileIn = new FileInputStream("user.ser");
            // 创建一个对象输入流
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // 从输入流中读取对象
            User user = (User) in.readObject();
            // 关闭流
            in.close();
            fileIn.close();
            // 输出对象的属性
            System.out.println("Name: " + user.getName());
            System.out.println("Age: " + user.getAge());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class User implements Serializable {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

3. Spring Boot中的序列化和反序列化

在Spring Boot中，默认使用Jackson库进行JSON的序列化和反序列化。可以通过配置文件或注解来自定义序列化和反序列化的规则。比如，可以使用@JsonSerialize注解来指定对象的序列化规则，使用@JsonDeserialize注解来指定对象的反序列化规则。

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

@SpringBootApplication
public class SerializationApplication {

    public static void main(String[] args) {
        SpringApplication.run(SerializationApplication.class, args);
    }

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer customizer() {
        return new Jackson2ObjectMapperBuilderCustomizer() {
            @Override
            public void customize(Jackson2ObjectMapperBuilder builder) {
                builder.serializationInclusion(JsonInclude.Include.NON_NULL);
                builder.visibility(JsonAutoDetect.Visibility.ANY);
            }
               };
    }

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        return objectMapper;
    }
}