序列化 订阅
序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储区。以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象。序列化使其他代码可以查看或修改,那些不序列化便无法访问的对象实例数据。确切地说,代码执行序列化需要特殊的权限:即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下,通过 Internet 下载的代码或 Internet 代码不会授予该权限;只有本地计算机上的代码才被授予该权限。通常,对象实例的所有字段都会被序列化,这意味着数据会被表示为实例的序列化数据。这样,能够解释该格式的代码有可能能够确定这些数据的值,而不依赖于该成员的可访问性。类似地,反序列化从序列化的表示形式中提取数据,并直接设置对象状态,这也与可访问性规则无关。对于任何可能包含重要的安全性数据的对象,如果可能,应该使该对象不可序列化。如果它必须为可序列化的,请尝试生成特定字段来保存不可序列化的重要数据。如果无法实现这一点,则应注意该数据会被公开给任何拥有序列化权限的代码,并确保不让任何恶意代码获得该权限。 展开全文
序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储区。以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象。序列化使其他代码可以查看或修改,那些不序列化便无法访问的对象实例数据。确切地说,代码执行序列化需要特殊的权限:即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下,通过 Internet 下载的代码或 Internet 代码不会授予该权限;只有本地计算机上的代码才被授予该权限。通常,对象实例的所有字段都会被序列化,这意味着数据会被表示为实例的序列化数据。这样,能够解释该格式的代码有可能能够确定这些数据的值,而不依赖于该成员的可访问性。类似地,反序列化从序列化的表示形式中提取数据,并直接设置对象状态,这也与可访问性规则无关。对于任何可能包含重要的安全性数据的对象,如果可能,应该使该对象不可序列化。如果它必须为可序列化的,请尝试生成特定字段来保存不可序列化的重要数据。如果无法实现这一点,则应注意该数据会被公开给任何拥有序列化权限的代码,并确保不让任何恶意代码获得该权限。
信息
类    型
概念
类    别
通信
中文名
序列化
外文名
Serialization
序列化目的
1、以某种存储形式使自定义对象持久化;2、将对象从一个地方传递到另一个地方。3、使程序更具维护性。
收起全文
精华内容
下载资源
问答
  • 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储区。以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象。 ...

    序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储区。以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象。

    序列化使其他代码可以查看或修改,那些不序列化便无法访问的对象实例数据。确切地说,代码执行序列化需要特殊的权限:即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下,通过 Internet 下载的代码或 Internet 代码不会授予该权限;只有本地计算机上的代码才被授予该权限。

    通常,对象实例的所有字段都会被序列化,这意味着数据会被表示为实例的序列化数据。这样,能够解释该格式的代码有可能能够确定这些数据的值,而不依赖于该成员的可访问性。类似地,反序列化从序列化的表示形式中提取数据,并直接设置对象状态,这也与可访问性规则无关。

    对于任何可能包含重要的安全性数据的对象,如果可能,应该使该对象不可序列化。如果它必须为可序列化的,请尝试生成特定字段来保存不可序列化的重要数据。如果无法实现这一点,则应注意该数据会被公开给任何拥有序列化权限的代码,并确保不让任何恶意代码获得该权限。

    摘自百度百科:https://baike.baidu.com/item/序列化/2890184?fr=aladdin

    java中一般将需要序列化的对象实现serializable接口。如果你想某个字段不序列化,将其声明为transient.

    序列化的原因是想将对象转换成流,方便存储和在网络上传输。

    什么情况下会用到序列化?

     1当你想把内存中的对象写入到硬盘时
     2当你想用套接字在网络上传输对象时
     3当你想通过RMI调用对象时
    (RMI是什么东西?):RMI总结来说就是远程调用对象,在一个jvm上调用另一个jvm的对象。
    

    序列化需要注意的事项

     1序列化只保存对象的状态,而不管对象的方法。
    
     2当一个父类实现了序列化,它的子类也自动实现序列化,不用显示进行实现了。
    
     3当一个实例对象引用其他对象,当序列化该对象时也把引用的对象进行了实例化。
    

    参考链接:https://www.cnblogs.com/mkl34367803/p/10659776.html


    展开全文
  • 遇到这个 Java Serializable 序列化这个接口,我们可能会有如下的问题a,什么叫序列化和反序列化 b,作用。为啥要实现这个 Serializable 接口,也就是为啥要序列化 c,serialVersionUID 这个的值到底是在怎么设置的...

    遇到这个 Java Serializable 序列化这个接口,我们可能会有如下的问题
    a,什么叫序列化和反序列化
    b,作用。为啥要实现这个 Serializable 接口,也就是为啥要序列化
    c,serialVersionUID 这个的值到底是在怎么设置的,有什么用。有的是1L,有的是一长串数字,迷惑ing。

    我刚刚见到这个关键字 Serializable 的时候,就有如上的这么些问题。

    在处理这个问题之前,你要先知道一个问题,这个比较重要。
    这个Serializable接口,以及相关的东西,全部都在 Java io 里面的。
     

    1,序列化和反序列化的概念

    序列化:把对象转换为字节序列的过程称为对象的序列化。
    反序列化:把字节序列恢复为对象的过程称为对象的反序列化。

    上面是专业的解释,现在来点通俗的解释。在代码运行的时候,我们可以看到很多的对象(debug过的都造吧),
    可以是一个,也可以是一类对象的集合,很多的对象数据,这些数据中,
    有些信息我们想让他持久的保存起来,那么这个就叫序列化。
    就是把内存里面的这些对象给变成一连串的字节(bytes)描述的过程。
    常见的就是变成文件
    我不序列化也可以保存文件啥的呀,有什么影响呢?我也是这么问的。

    2,什么情况下需要序列化 

    当你想把的内存中的对象状态保存到一个文件中或者数据库中时候;
    当你想用套接字在网络上传送对象的时候;
    当你想通过RMI传输对象的时候;

    (老实说,上面的几种,我可能就用过个存数据库的。)

     

    3,java如何实现序列化

    实现Serializable接口即可

    上面这些理论都比较简单,下面实际代码看看这个序列化到底能干啥,以及会产生的bug问题。

    先上对象代码,飞猪.java

    package com.lxk.model;
    
    import java.io.Serializable;
    
    /**
     * @author lxk on 2017/11/1
     */
    public class FlyPig implements Serializable {
        //private static final long serialVersionUID = 1L;
        private static String AGE = "269";
        private String name;
        private String color;
        transient private String car;
    
        //private String addTip;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    
        public String getCar() {
            return car;
        }
    
        public void setCar(String car) {
            this.car = car;
        }
    
        //public String getAddTip() {
        //    return addTip;
        //}
        //
        //public void setAddTip(String addTip) {
        //    this.addTip = addTip;
        //}
    
        @Override
        public String toString() {
            return "FlyPig{" +
                    "name='" + name + '\'' +
                    ", color='" + color + '\'' +
                    ", car='" + car + '\'' +
                    ", AGE='" + AGE + '\'' +
                    //", addTip='" + addTip + '\'' +
                    '}';
        }
    }
    

    注意下,注释的代码,是一会儿要各种情况下使用的。

    下面就是main方法啦

    package com.lxk.test;
    
    import com.lxk.model.FlyPig;
    
    import java.io.*;
    
    /**
     * 序列化测试
     *
     * @author lxk on 2017/11/1
     */
    public class SerializableTest {
        public static void main(String[] args) throws Exception {
            serializeFlyPig();
            FlyPig flyPig = deserializeFlyPig();
            System.out.println(flyPig.toString());
    
        }
    
        /**
         * 序列化
         */
        private static void serializeFlyPig() throws IOException {
            FlyPig flyPig = new FlyPig();
            flyPig.setColor("black");
            flyPig.setName("naruto");
            flyPig.setCar("0000");
            // ObjectOutputStream 对象输出流,将 flyPig 对象存储到E盘的 flyPig.txt 文件中,完成对 flyPig 对象的序列化操作
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:/flyPig.txt")));
            oos.writeObject(flyPig);
            System.out.println("FlyPig 对象序列化成功!");
            oos.close();
        }
    
        /**
         * 反序列化
         */
        private static FlyPig deserializeFlyPig() throws Exception {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:/flyPig.txt")));
            FlyPig person = (FlyPig) ois.readObject();
            System.out.println("FlyPig 对象反序列化成功!");
            return person;
        }
    }
    

    对上面的2个操作文件流的类的简单说明

    ObjectOutputStream代表对象输出流:

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

    ObjectInputStream代表对象输入流:

    它的readObject()方法从一个源输入流中读取字节序列,再把它们反序列化为一个对象,并将其返回。

    具体怎么看运行情况。

    第一种:上来就这些代码,不动,直接run,看效果。

    实际运行结果,他会在 d:/flyPig.txt 生成个文件。

    从运行结果上看:

    1,他实现了对象的序列化和反序列化。

    2,transient 修饰的属性,是不会被序列化的。我设置的奥迪四个圈的车不见啦,成了null。my god。

    3,你先别着急说,这个静态变量AGE也被序列化啦。这个得另测。

     

    第二种:为了验证这个静态的属性能不能被序列化和反序列化,可如下操作。

        public static void main(String[] args) throws Exception {
            serializeFlyPig();
            //FlyPig flyPig = deserializeFlyPig();
            //System.out.println(flyPig.toString());
        }

    这个完了之后,意思也就是说,你先序列化个对象到文件了。这个对象是带静态变量的static。

    现在修改flyPig类里面的AGE的值,给改成26吧。

    然后,看下图里面的运行代码和执行结果。

    可以看到,刚刚序列化的269,没有读出来。而是刚刚修改的26,如果可以的话,应该是覆盖这个26,是269才对。

    所以,得出结论,这个静态static的属性,他不序列化。

     

    第三种:示范这个 serialVersionUID 的作用和用法

    最暴力的改法,直接把model的类实现的这个接口去掉。然后执行后面的序列化和反序列化的方法。直接报错。

    抛异常:NotSerializableException

    这个太暴力啦,不推荐这么干。

    然后就是,还和上面的操作差不多,先是单独执行序列化方法。生成文件。
    然后,打开属性 addTip ,这之后,再次执行反序列化方法,看现象。

    抛异常:InvalidClassException  详情如下。

    InvalidClassException: com.lxk.model.FlyPig; 
    local class incompatible: 
    stream classdesc serialVersionUID = -3983502914954951240, 
    local class serialVersionUID = 7565838717623951575

    解释一下:

    因为我再model里面是没有明确的给这个 serialVersionUID 赋值,但是,Java会自动的给我赋值的,

    这个值跟这个model的属性相关计算出来的。

    我保存的时候,也就是我序列化的时候,那时候还没有这个addTip属性呢,

    所以,自动生成的serialVersionUID 这个值,

    在我反序列化的时候Java自动生成的这个serialVersionUID值是不同的,他就抛异常啦。

    (你还可以反过来,带ID去序列化,然后,没ID去反序列化。也是同样的问题。)

    再来一次,就是先序列化,这个时候,把 private static final long serialVersionUID = 1L; 这行代码的注释打开。那个addTip属性先注释掉,序列化之后,再把这个属性打开,再反序列化。看看什么情况。

    这个时候,代码执行OK,一切正常。good。序列化的时候,是没的那个属性的,在发序列化的时候,对应的model多了个属性,但是,反序列化执行OK,没出异常。

     

    这个现象对我们有什么意义:

    老铁,这个意义比较大,首先,你要是不知道这个序列化是干啥的,万一他真的如开头所讲的那样存数据库(这个存db是否涉及到Java的序列化估计还的看什么数据库吧)啦,socket传输啦,rmi传输啦。虽然我也不知道这是干啥的。你就给model bean 实现了个这个接口,你没写这个 serialVersionUID 那么在后来扩展的时候,可能就会出现不认识旧数据的bug,那不就炸啦吗。回忆一下上面的这个出错情况。想想都可怕,这个锅谁来背? 

    所以,有这么个理论,就是在实现这个Serializable 接口的时候,一定要给这个 serialVersionUID 赋值,就是这么个问题。

    这也就解释了,我们刚刚开始编码的时候,实现了这个接口之后,为啥eclipse编辑器要黄色警告,需要添加个这个ID的值。而且还是一长串你都不知道怎么来的数字。

     

    下面解释这个 serialVersionUID 的值到底怎么设置才OK

    首先,你可以不用自己去赋值,Java会给你赋值,但是,这个就会出现上面的bug,很不安全,所以,还得自己手动的来。

    那么,我该怎么赋值,eclipse可能会自动给你赋值个一长串数字。这个是没必要的。

    可以简单的赋值个 1L,这就可以啦。。这样可以确保代码一致时反序列化成功。

    不同的serialVersionUID的值,会影响到反序列化,也就是数据的读取,你写1L,注意L大些。计算机是不区分大小写的,但是,作为观众的我们,是要区分1和L的l,所以说,这个值,闲的没事不要乱动,不然一个版本升级,旧数据就不兼容了,你还不知道问题在哪。。。

     

    下面是摘自 jdk api 文档里面关于接口 Serializable 的描述
    类通过实现 java.io.Serializable 接口以启用其序列化功能。
    未实现此接口的类将无法使其任何状态序列化或反序列化。
    可序列化类的所有子类型本身都是可序列化的。因为实现接口也是间接的等同于继承。
    序列化接口没有方法或字段,仅用于标识可序列化的语义。

    关于 serialVersionUID 的描述

    https://blog.csdn.net/qq_27093465?viewmode=contents

    (注意对比一下,这个截图的两段话,就是对应下面的2段中文。仔细看这2段话,就能解释43楼的问题,静态属性不会被序列化,但是却又有一个特殊的静态属性,会被序列化,没办法,这个静态属性是亲生的。自带的。)

    序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联,该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同,则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段(该字段必须是静态 (static)、最终 (final) 的 long 型字段)显式声明其自己的 serialVersionUID:

    如果可序列化类未显式声明 serialVersionUID,则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值,如“Java(TM) 对象序列化规范”中所述。不过,强烈建议 所有可序列化类都显式声明 serialVersionUID 值,原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性,根据编译器实现的不同可能千差万别,这样在反序列化过程中可能会导致意外的 InvalidClassException。因此,为保证 serialVersionUID 值跨不同 java 编译器实现的一致性,序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID(如果可能),原因是这种声明仅应用于直接声明类 -- serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID,因此它们总是具有默认的计算值,但是数组类没有匹配 serialVersionUID 值的要求。

     

    最后更新一下

    1,(针对25楼的留言:序列化的类的所有成员变量是不是都要是基本类型或实现Serializable接口的类型?)

    当属性是对象的时候,如果这个对象,没实现序列化接口,那么上面的方法在序列化的时候就在执行oos.writeObject(flyPig)时候,报错了“Exception in thread "main" java.io.NotSerializableException: com.lxk.model.Bird”。然后给刚刚的属性的对象加上实现序列化的接口之后,上面的测试就正常通过了。你这个问题问的好。

    结论:要实现序列化的对象,所有涉及的引用,都需要实现序列化接口才可以。

    2,(38楼问,这个serialVersionUID的值在存数据库的时候,存哪里了?)

    大师兄

    大师兄

    好问题,答不上来呀!!!我也是郁闷了,那大概猜一下,数据库没有使用Java这一套序列化,而是不同db各自实现了一套自己的序列化,so,就跟Java的这个静态属性没关系啦。静态属性是不存db的。然后,你就发现,你即使没实现这个Java的序列化的接口,也可以正常的存db,取db。太机智了,这个解释,满分,为啥呢,这个serialVersionUID是Java给你提供的一个序列化和反序列化用的,你要是不使Java这一套的话,那就不需要考虑这个问题啦呀。在上面的测试代码里面也是使用这些个API去序列化以及反序列化的。???

    3,(43楼问的问题:既然要比较新旧serialVersionUID, 旧的serialVersionUID是不是也应该序列化到文件中, 但serialVersionUID是static类型的, 是不会被序列化到文件中的)

    这个serialVersionUID是jdk亲生的,你写或者不写,只要实现了接口,他就是存在的,在序列化的时候,他还真就序列化,存起来了。不然在反序列化的时候,就没的对比了嘛,因为他是亲生的,所以,咱手动添加的静态,和这个静态是不能比的。

     

    我写完文章,给自己点个赞,不过分吧,
    不过分,那我可就点啦啊。
    我先点为敬,你们随意。大家随意。不要客气。。。

    展开全文
  • C++ JSON 序列化与反序列化

    热门讨论 2013-06-22 14:23:31
    C++ JSON 序列化与反序列化 相关的博客文章见:http://blog.csdn.net/TragicGuy
  • SpringBoot的序列化和反序列化

    千次阅读 2020-11-11 15:06:16
    序列化与反序列化 1、认识序列化与反序列化 Java序列化是指把Java对象转换为字节序列的过程,而Java反序列化是指把字节序列恢复为Java对象的过程。 2、为什么要实现对象的序列化和反序列化? (1)我们创建的Java...

    序列化与反序列化

    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配置属性的解释

    属性名称解释
    QuoteFieldNames输出key时是否使用双引号,默认为true
    UseSingleQuotes使用单引号而不是双引号,默认为false
    WriteMapNullValue是否输出值为null的字段,默认为false。应用场景:前端必须需要所有字段
    UseISO8601DateFormatDate使用ISO8601格式输出,默认为false
    WriteNullListAsEmptyList字段如果为null,输出为[],而不是null
    WriteNullStringAsEmpty字符类型字段如果为null,输出为"",而不是null
    WriteNullNumberAsZero数值字段如果为null,输出为0,而非null
    WriteNullBooleanAsFalseBoolean字段如果为null,输出为false,而非null
    SkipTransientField如果是true,类中的Get方法对应的Field是transient,序列化时将会被忽略。默认为true
    SortField按字段名称排序后输出。默认为false

    配置前:默认不输出为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();

    
    
    展开全文
  • C# Protobuf-Net 序列化
  • Java 序列化与反序列化

    千次阅读 2020-09-05 13:04:20
    介绍 Java 的序列化与反序列化

    Java 序列化与反序列化


    1 序列化与反序列化的概念

    • Java 序列化是指:将对象转化成一个字节序列(二进制数据)的过程。

    • 将序列化对象写入文件之后,可以从文件中读取出来,并且对它进行反序列化。

    • Java 反序列化是指:将一个对象的字节序列恢复成 Java 对象的过程。

    • 一个平台中序列化的对象,可以在另一个平台中进行反序列化,因为这个过程是在 JVM 中独立完成的,可以依赖于 Java 的可移植性。


    2 核心类与关键字总览

    • ObjectOutputStream:IO 类,包含序列化对象的方法,writeObject()

    • ObjectInputStream:IO 类,包含反序列化对象的方法,readObject()

    • 上面两个 IO 流类是高层次的数据库,需要借助文件流进行序列化与反序列化操作。

    • Serializable ,接口,是一个标志性接口,标识可以在 JVM 中进行序列化,JVM 会为该类自动生成一个序列化版本号。参与序列化与反序列化的类必须实现 Serializable 接口。

    • serialVersionUID,类属性,序列化版本号,用于给 JVM 区别同名类,没有提供版本号,JVM会默认提供序列化版本号。

    • transient,关键字,当序列化时,不希望某些属性参与,则可以使用这个关键字标注该属性。


    3 序列化与反序列化的过程

    • 内存中的数据信息被拆分成一小块一小块的部分,为每个小块设置编号,然后存放到硬盘文件中,也就是将 Java 对象对象的状态保存下来存储到文件中的过程就叫做序列化。

    • 将硬盘中保存了 Java 对象状态的字节序列按照编号组装成对象恢复到内存中,这个过程称为反序列化。


    3 应用示例

    参与序列化和反序列化的 Java 类

    public class Student implements Serializable {
        private String name;
        private int age;
        //  以下省略有参构造、无参构造、set、get、toString
    }
    
    • 参与序列化和反序列化的类必须实现 Serializable 接口。

    序列化操作

    public static void main(String[] args) throws Exception {
        //  创建 Java 对象
        Student student = new Student("张三",22);
        //  对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student"));
        // 使用 writeObject 序列化对象
        oos.writeObject(student);
        // 刷新
        oos.flush();
        //  关闭流
        oos.close();
    }
    
    • 序列化后的二进制文件会被保存到文件输出流指定的路径。

    反序列化操作

    public static void main(String[] args) throws Exception {
        //  对象输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student"));
        //  使用 readObject() 反序列化  
        Object obj = ois.readObject();
        //  使用对象
        System.out.println(obj);
        //  关闭流
        ois.close();
    }
    
    • 反序列化需要借助文件输入流读取指定路径的二进制文件。

    4 序列化版本号的作用 serialVersionUID

    • JVM 首先会通过类名来区分 Java 类,类名不同,则不是同一个类。当类名相同时,JVM 就会通过序列化版本号来区分 Java 类,如果序列化版本号相同就为同一个类,序列化版本号不同就为不同的类。

    • 在序列化一个对象时,如果没有指定序列化版本号,后期对该类的源码进行修改并重新编译后,会导致修改前后的序列化版本号不一致,因为 JVM 会提供一个新的序列化版本号给该类对象。

    • 此时再用以往的反序列化代码去反序列化该类的对象,就会抛出异常 java.io.InvalidClassException ,所以序列化一个类时最好指定一个序列化版本号,或者永远不修改此类。

    public class Student implements Serializable {
        private static final Long serialVersionUID = 1L;
    }
    
    • 由 JVM 提供序列化版本号的好处是,同名却不同功能的类,会有两个不同的序列化版本号,JVM 可以通过序列化版本号加以区分,缺点是一旦修改源码,会重新提供序列化版本号,导致修改前后的序列化版本号不一致,进行反序列化时会出现运行出现异常。

    • 由 开发人员 手动提供序列化版本号的好处是,当修改了被序列化类的源码后,以往写的反序列化代码依然可以使用,如 JDK 中的 String 类。以便后期进行增强和维护不会影响使用。

    在这里插入图片描述


    5 transient 关键字

    • 这个关键字表示游离的,不参与序列化的。

    • 在序列化一个对象时,如果不希望某个属性参加序列化,可以使用 transient 修饰该属性。

    • 被该关键字修饰的属性不会参与到序列化中。

    public class Student implements Serializable {
    
        private static final Long serialVersionUID = 1L;
    
        private String name;
        private transient int age;
    }
    
    • 如上类,在序列化时就不会保存 age 属性,在反序列化时就不能会付出该属性,默认恢复成 null 或 0 ,由属性类型决定。

    6 序列化的好处及应用场景

    • 序列化会将内存中对象的状态转换成二进制文件保存到磁盘当中,当再次使用时会从磁盘中读取该二进制文件,将 Java 对象的状态恢复到内存中。

    • 当你想把内存中的对象保存到磁盘文件或数据库中时可以使用序列化。

    • 当你想在网络传输中传送 Java 对象时,可以使用序列化。

    • 当你想通过 RMI 传输对象时,可以使用序列化。


    7 序列化注意事项

    • 序列化只会保存对象的属性状态,不会保存对象中的方法。

    • 父类实现了 Serializable 接口,则其子类也自动实例化了该接口,也就是说子类不用显式实现 Serializable 接口也能参与序列化和反序列化。

    • 一个对象 A 的实例变量引用了其他对象 B,在 A 对象实例化的过程中 ,也会序列化 B ,前提是 A、B 两个类都实现了 Serializable 接口。

    • 当一个类实现 Serializable 接口时,最好手动指定一个序列化版本号(serialVersionUID),避免修改源代码后导致反序列化出现异常。

    • 当一个类对象会被多次重复使用,且一般不会对其属性做修改,就可以对其进行序列化。例如数据库操作中的实体类。


    参考博文:

    展开全文
  • java序列化和反序列化,面试必备

    千次阅读 多人点赞 2020-04-26 17:04:19
    一、序列化、反序列化、使用场景、意义。 序列化:将对象写入IO流中; 反序列化:从IO流中恢复对象; 意义:序列化机制允许将实现序列化的Java对象转换为字节序列,并将字节序列保存在磁盘中,或通过网络传输,以...
  • C# 后台序列化Json序列、反序列化Json序列(三种方法)
  • 序列化和反序列化的底层实现原理是什么?

    万次阅读 多人点赞 2018-04-07 13:53:41
    序列化和反序列化作为Java里一个较为基础的知识点,大家心里也有那么几句要说的,但我相信很多小伙伴掌握的也就是那么几句而已,如果再深究问一下Java如何实现序列化和反序列化的,就可能不知所措了!遥记当年也被问...
  • 遇到这个 Java Serializable 序列化这个接口,我们可能会有如下的问题a,什么叫序列化和反序列化 b,作用。为啥要实现这个 Serializable 接口,也就是为啥要序列化 c,serialVersionUID 这个的值到底是在怎么设置的...
  • 序列化和反序列化是Java中最基础的知识点,也是很容易被大家遗忘的,虽然天天使用它,但并不一定都能清楚的说明白。我相信很多小伙伴们掌握的也就几句概念、关键字(Serializable)而已,如果深究问一下序列化和反序列...
  • 序列化/反序列作高层API的核心概念,重要程度可见一斑。但是关于序列化/反序列化是什么,大多数小伙伴其实停留在概念阶段,并不知其内幕。 > 说明:本文讨论的序列化/反序列化自然是是关注JSON方面的 学习本专栏...
  • FastJson在scala中序列化与反序列化

    千次阅读 2019-08-29 10:19:46
    FastJson在scala中序列化与反序列化 Alibaba的一款开源JSON组件FastJson,非常好用,在序列化和反序列化方面性能突出,而且API接口简单易用,算是处理JSON的一大利器 首先,添加依赖,注意这里的版本号,务必使用...
  • 深入序列化和反序列化原理一个问题引发的思考什么是序列化和反序列化序列化 一个问题引发的思考 下面是一个简单的socket通信demo。 通信数据类: package com.zwx.serialize.demo; public class SocketUser { ...
  • Java 序列化的一些简单总结 Java序列化只是针对对象的状态进行保存,至于对象中的方法,序列化不关心 当一个父类实现了序列化,那么子类会自动实现序列化,不需要显示实现序列化接口 当一个对象的实例变量引用了...
  • 1.序列化与反序列化 1、序列化和反序列化简介: 序列化就是指把对象转换为字节码; 对象传递和保存时,保证对象的完整性和可传递性。把对象转换为有字节码,以便在网络上传输或保存在本地文件中; 反序列化就是...
  • 一、序列化与反序列化 内存中的数据对象只有转换成二进制才可以进行数据持久化和网络传输。将数据对象转换成二进制的流程称之为对象的序列化(Serialization)。 反之,将二进制流恢复为数据对象的过程称之为反...
  • 这个库,它是Flutter官方推荐的一个序列化的库,主要的功能是自动化生成序列化源代码(核心在于为我们自动生成上面提到的 fromJson() 构造方法和 toJson() 方法)。 在项目中引入json_serializable依赖 要将 json_...
  • 序列化与反序列化 - Java基础

    千次阅读 2020-08-22 05:29:13
    知识的广度来自知识的深度,学习如果不成体系那是多可怕的一件事儿...序列化与反序列化 - Java基础一、序列化简介二、序列化的使用三、自定义序列化功能3.1 transient关键字的使用3.2 writeObject方法的使用3.3 readO.
  • Django框架中序列化和反序列化

    千次阅读 多人点赞 2018-09-29 11:35:43
    1.序列化 DRF的核心 就是 前后端分离的核心 前后端分离开发的核心: 将模型转换为json 称之为 序列化 将json转换为模型 称之为 反序列化 1.序列化器的字段 Serializer 序列化器 # 将模型转换为json 称之为 序列...
  • c#中的序列化和反序列化

    千次阅读 2019-08-13 21:25:48
    第一步:什么是序列化和反序列化 序列化定义:将对象转化为容易传输的格式的过程。 反序列化定义:重新解析构造被序列化的对象 第二步:为什么要序列化和反序列化 当两个进程在进行远程通信时,彼此可以发送各种...
  • 序列化和反序列化的详解

    万次阅读 多人点赞 2018-09-19 09:09:29
    1、序列化和反序列化的定义:  (1)Java序列化就是指把Java对象转换为字节序列的过程  Java反序列化就是指把字节序列恢复为Java对象的过程。  (2)序列化最重要的作用:在传递和保存对象时.保证对象的完整性和可...
  • Android中序列化与反序列化

    千次阅读 2018-06-15 17:26:46
    这几天在看到设计模式时,看到有关于序列化的知识,发现自己之前这块知识很欠缺,所以这花了两天仔细研究了一下,感觉这个东西还是很有趣的(当然也很有用-。+),今天给大家带来这篇文章,希望对大家有帮助。序列化...
  • 面向对象——序列化与反序列化

    千次阅读 2020-04-07 13:05:27
    概念:序列化是将对象状态转换为可保持或传输的形式的过程。如果一个类所创建的对象,能够被序列化,那么要求必须给这个类加上[Serializable]特性。 1. 使用二进制形式序列化对象 必须添加System.Runtime....
  • 前言 上一篇已经介绍了优雅的操作...下几种常用的序列化方式 最近在做一个项目,由于并发量大,大量使用到了RedisTemplate来操作Redis。但使用过程中,遇到了不少的坑,各种翻看源码 来跟踪,也总结出了不少的经...
  • java序列化和反序列化以及序列化ID的作用分析

    万次阅读 多人点赞 2017-08-07 20:26:07
    java序列化和反序列化以及序列化ID的作用分析
  • kafka系列之序列化和反序列化

    千次阅读 2019-08-16 20:03:28
    文章目录简介基本原理分析自定义序列化组件测试 简介 kafka内部发送和接收消息的时候,使用的是byte[]字节数组的方式(RPC底层也是用这种通讯格式)。但是我们在应用层其实可以使用更多的数据类型,比如int,short,...
  • c语言序列化和反序列化

    千次阅读 2019-05-03 20:15:08
    这里写自定义目录标题c语言序列化和反序列化tplut.htplut.c测试代码参考 c语言序列化和反序列化 网络调用,数据传输都需要把数据序列化和反序列化。杀鸡不喜欢用牛刀,自己从底层设计协议又太繁琐,难以维护和扩展...
  • 排序、序列化及反序列化

    千次阅读 2019-11-20 12:31:09
    序列化、反序列化 一、概念 序列化(Serialization)是指把结构化对象转化为字节流。 反序列化(Deserialization)是序列化的逆过程。把字节流转为结构化对象。 Java序列化(java.io.Serializable) 当要在进程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,189,108
精华内容 475,643
关键字:

序列化