SpringBoot的序列化和反序列化

大家好，又见面了，我是你们的朋友全栈君。

序列化与反序列化

1、认识序列化与反序列化

Java序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程。

2、为什么要实现对象的序列化和反序列化？

（1）我们创建的Java对象被存储在Java堆中，当程序运行结束后，这些对象会被JVM回收。但在现实的应用中，可能会要求在程序运行结束之后还能读取这些对象，并在以后检索数据，这时就需要用到序列化。

（2）当Java对象通过网络进行传输的时候。因为数据只能够以二进制的形式在网络中进行传输，因此当把对象通过网络发送出去之前需要先序列化成二进制数据，在接收端读到二进制数据之后反序列化成Java对象。

一个例子：

需要用到的User类

public class User{
    private String name;
    private int age;
    
    @Override
    public String toString() {
        return "User{" +
                "name='"+name+'\''+
                ",age="+age+
                '}';
    }
}

Server类：

public class Server {
    public static void main(String[] args) throws IOException,ClassNotFoundException {
        ServerSocket serverSocket=null;

        serverSocket=new ServerSocket(8080);
        Socket socket = serverSocket.accept();
        ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());

        User user=(User)objectInputStream.readObject();
        System.out.println(user);
    }
}

Client类：

public class Client {
    public static void main(String[] args)throws IOException {
        Socket socket = null;
        socket = new Socket("localhost",8080);

        User user=new User();
        user.setAge(22);
        user.setName("zhangsan");

        ObjectOutputStream out= new ObjectOutputStream(socket.getOutputStream());
        out.writeObject(user);
        socket.close();
    }
}

上述代码模拟两个进程进行通信，代码运行以后，发现程序报错，并不能实现Java对象的正常传输，因为没有实现User类的序列化。

3、序列化与反序列化的实现

被序列化的对象需要实现java.io.Serializable接口，该接口只是一个标记接口，不用实现任何方法。

JDK提供了Java对象的序列化方式实现对象序列化传输，主 要通过输出流java.io.ObjectOutputStream和对象输入流java.io.ObjectInputStream来实现。

java.io.ObjectOutputStream：表示对象输出流 , 它的writeObject(Object obj)方法可以对参 数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

java.io.ObjectInputStream：表示对象输入流 ,它的readObject()方法源输入流中读取字节序 列，再把它们反序列化成为一个对象，并将其返回。

4、serialVersionUID 的作用

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致，这个所谓的序列化ID，就是我们在代码中定义的serialVersionUID。

反序列化的调用链如下：

ObjectInputStream.readObject -> readObject0 -> readOrdinaryObject -> readClassDesc -> readNonProxyDesc -> 
ObjectStreamClass.initNonProxy

在initNonProxy中的关键代码如下：在反序列化的过程中，对serialVersionUID做了比较，如果发现不相等，则直接抛出异常。

serialVersionUID的生成方法：

（1）private static final long serialVersionUID = 1L;

（2）根据包名，类名，继承关系，非私有的方法和属性，以及参数，返回值等诸多因子计算得出的，极度复杂生成的一个64位的哈希字段。基本上计算出来的这个值是唯一的。比如：private static final long serialVersionUID = xxxxL;
显示声明serialVersionUID可以避免对象不一致

（3）如果没有显示的定义serialVersionUID变量的时候，JAVA序列化机制会根据Class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果Class文件(类名，方法明等)没有发生变化(增加空格，换行，增加注释等等)，就算再编译多次，serialVersionUID也不会变化的。

5、SpringBoot中的序列化和反序列化

在项目开发中，我们的类并没有实现Serializable接口，实际上这是Spring框架帮我们做了一些事情，Spring并不是直接把User对象进行网络传输，而是先把Use r对象转换成json格式的字符串，然后再进行传输的，而String类实现了Serializable接口并且显示指定了serialVersionUID 。

Json是一种轻量级的文本数据交换格式，在Json字符串中{}用来表示对象，[]用来表示列表，数据以key-value的形式存放，如：

{
	"name":"zhangsan",
	"age":"22",
	"course":["java","python"]
}

在 Spring Boot 中， 想要一个接口接收Json格式的数据并返回Json格式的数据，前端将http请求头“Accept”设置为“application/json”,Content-Type为”application/json”

中间件只需要在Controller类中做如下定义：

@RestController
@RequestMapping("/breedManagement/breedAnalysis")
public class BreedAnalysisController {

    @Resource(name="BreedAnalysisService")
    private BreedAnalysisService breedAnalysisService;

    @RequestMapping("/getBaseInfo")
    public JsonResult getBaseInfo(@RequestBody HashMap<String,Object> map){
        return breedAnalysisService.getBaseInfo(map);
    }
}

在 Controller 中使用@ResponseBody注解即可返回 Json 格式的数据，而@RestController注解包含了@ResponseBody 注解，所以默认情况下，@RestController即可将返回的数据结构转换成Json格式。

这些注解之所以可以进行Json与JavaBean之间的相互转换，就是因为HttpMessageConverter发挥着作用。

org.springframework.http.converter.HttpMessageConverter 是一个策略接口，是Http request请求和response响应的转换器，该接口只有五个方法，它的canRead()方法返回true，然后它的read()方法会从请求中读出请求参数，绑定到readString()方法的string变量中。
当SpringMVC执行readString方法后，由于返回值标识了@ResponseBody，SpringMVC将使用StringHttpMessageConverter的write()方法，将结果作为String值写入响应报文，当然，此时canWrite()方法返回true。

public interface HttpMessageConverter<T> {
 
	//判断当前转换器是否可以解析前端传来的数据
	boolean canRead(Class<?> clazz, MediaType mediaType);
	
	//判断当前转换器是否可以将后端数据解析为前端需要的格式
	boolean canWrite(Class<?> clazz, MediaType mediaType);
 
	//获取当前转换器可以解析的数据类型
	List<MediaType> getSupportedMediaTypes();
 
	//读取前端传来的数据
	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;
 
	//将后台数据转换，返回给前端
	void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;
 }

Spring为HttpMessageConverter接口提供了多个实现类，在启动时会自动配置一些消息转换器，包括MappingJackson2HttpMessageConverter。

流程图如下：

前端发来请求后，先调用HttpInputMessage从输入流中获取Json字符串，然后在HttpMessageConverter中把Json转换为接口需要的形参类型。在HttpMessageConverter内部流程图如下：

6、定制化

当出现特定的需求时，比如：。此时需要自定义自己的消息转换器，有两种方式

方式一 使用Spring或者第三方提供的HttpMessageConverter（如FastJson，Gson，Jackson）

问题引入字符类型字段为null时，输出为””,而不是null

step1：引入依赖

<dependency>
	<groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.31</version>
</dependency>

step2：对FastJsonHttpMessageConverter进行配置

@Configuration
public class MyWebmvcConfiguration implements WebMvcConfigurer {

    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter fjc = new FastJsonHttpMessageConverter();
        FastJsonConfig fj = new FastJsonConfig();
     
        //字符类型字段如果为null，则输出"",而非null
        fj.setSerializerFeatures(SerializerFeature.WriteNullStringAsEmpty);
        fjc.setFastJsonConfig(fj);
        converters.add(fjc);
    }
}

SerializerFeature配置属性的解释

配置前：默认不输出为null的字符型字段

配置后：字符类型字段如果为null,输出为””

方式二 重写TypeAdapter

问题引入：在使用Gson将HashMap<String,Object>中的结果反序列化时，发现Integer类型自动转成了Double类型。示例代码如下：

	@RequestMapping("/convert")
    public void converter(@RequestBody HashMap<String,Object> map) {
        Gson gson=new Gson();
        List<Integer> numList =gson.fromJson(map.get("numList").toString(),List.class);
        System.out.println(numList.get(0));
    }

这是因为在反序列化的过程中，Gson会根据待解析的类型定位到具体的TypeAdaptor类，并通过该类的read方法组装成最后的对象，由于Map对应的是Object，这里的Gson最终定位到内置的ObjectTypeAdaptor类，该类的关键代码如下：我们可以看到，数值类型（NUMBER）全部被转换成了Double类型。

在这种情况下，可以使用DecimalFormat进行转换，也可以重写TypeAdapyter。

step1：重写TypeAdapter中的read方法,主要是修改数字的处理逻辑

 case NUMBER:
 	/**
    * 改写数字的处理逻辑，将数字值分为整型与浮点型。
    */
    double dbNum = in.nextDouble();

    // 数字超过long的最大值，返回浮点类型
    if (dbNum > Long.MAX_VALUE) {
    	return dbNum;
    }

     // 判断数字是否为整数值
     long lngNum = (long) dbNum;
     if (dbNum == lngNum) {
     	return lngNum;
     } else {
     	return dbNum;
     }

step2：修改Gson的适配器为自定义的

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(List.class,new DataTypeAdapter());
Gson gson = gsonBuilder.create();

 long lngNum = (long) dbNum;
 if (dbNum == lngNum) {
 	return lngNum;
 } else {
 	return dbNum;
 }

step2：修改Gson的适配器为自定义的

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(List.class,new DataTypeAdapter());
Gson gson = gsonBuilder.create();