1.概念

序列化：将对象转化为字节序列的过程

反序列化：将字节序列转化为对象的过程

用途：

A：将对象转化为字节序列保存在硬盘上，如文件中，如文本中的例子就是将person对象序列化成字节序列，存在person.txt文件中

B：网络传输中一般都是以对象序列化的形式存在，在网络的发送/接收两端进行对象的序列化/反序列化

输入/输出的使用：

一般都是针对内存而言，内存--硬盘--》outputStream 从硬盘--内存--》inputStream

具体使用要根据场景来确定

2.Serializable-example

2.1 无显式的指定UID,采用编译系统自动生成的

Object:

package com.java.baseinfo.knowledge.code.serializable;

import java.io.Serializable;

public class Person implements Serializable {

    private int age;

    private String name;

    private String sex;

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    @Override

    public String toString() {

        final StringBuffer sb = new StringBuffer("Person{");

        sb.append("age=").append(age);

        sb.append(", name='").append(name).append('\'');

        sb.append(", sex='").append(sex).append('\'');

        sb.append('}');

        return sb.toString();

    }

}

　object uid

package com.java.baseinfo.knowledge.code.serializable;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

public class TestObjSerializeAndDeserialize {

    public static void main(String[] args) {

        // 序列化

        SerializablePerson();

        // 反序列化

        //Deserialization();

    }

    private static void SerializablePerson() {

        Person person = new Person();

        person.setAge(10);

        person.setName("测试");

        person.setSex("女");

        String path = "src/test/resources/person.txt";

        try {

            FileOutputStream fileOutputStream = new FileOutputStream(new File(path));

            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

            objectOutputStream.writeObject(person);

            System.out.println("序列化成功");

            fileOutputStream.close();

            objectOutputStream.close();

        } catch (FileNotFoundException e) {

            System.out.printf("FileNotFoundException====>" + e);

        } catch (IOException e) {

            System.out.printf("IOException====>" + e);

        }

    }

    private static Person Deserialization() {

        try {

            FileInputStream fileInputStream = new FileInputStream(new File("src/test/resources/person.txt"));

            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

            Person person = (Person) objectInputStream.readObject();

            System.out.printf("Deserialization.person===>"+person);

        } catch (FileNotFoundException e) {

            System.out.printf("FileNotFoundException====>" + e);

        } catch (IOException e) {

            System.out.printf("IOException====>" + e);

        } catch (ClassNotFoundException e) {

            System.out.printf("ClassNotFoundException====>" + e);

        }

        return null;

    }

}

先序列化，才进行反序列化

Deserialization.person===>Person{age=10, name='测试', sex='女'}

给person增加字段，再用原来的序列化后的结果，进行反序列化；

package com.java.baseinfo.knowledge.code.serializable;

import java.io.Serializable;

public class Person implements Serializable {

    private int age;

    private String name;

    private String sex;

    // 增加字段测试序列化

    private String addText;

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    public String getAddText() {

        return addText;

    }

    public void setAddText(String addText) {

        this.addText = addText;

    }

    @Override

    public String toString() {

        final StringBuffer sb = new StringBuffer("Person{");

        sb.append("age=").append(age);

        sb.append(", name='").append(name).append('\'');

        sb.append(", sex='").append(sex).append('\'');

        sb.append(", addText='").append(addText).append('\'');

        sb.append('}');

        return sb.toString();

    }

}

　运行结果

IOException====>java.io.InvalidClassException: com.java.baseinfo.knowledge.code.serializable.Person; local class incompatible: stream classdesc serialVersionUID = 6964452789008335213, local class serialVersionUID = -3534890433624150186

Process finished with exit code 0

　原因是：之前代码中未显示的指定UID，当Object中新增字段时，编译器又新生成一个UID，于是出现序列化版本不一致的问题；

2.2 显式指定UID

package com.java.baseinfo.knowledge.code.serializable;

import java.io.Serializable;

public class Person implements Serializable {

    private static final long serialVersionUID = -3534890433624150186L;

    private int age;

    private String name;

    private String sex;

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    @Override

    public String toString() {

        final StringBuffer sb = new StringBuffer("Person{");

        sb.append("age=").append(age);

        sb.append(", name='").append(name).append('\'');

        sb.append(", sex='").append(sex).append('\'');

        sb.append('}');

        return sb.toString();

    }

}

运行上述main函数, 先进行序列化，然后再对object增加属性,再序列化的结果，进行反序列化

package com.java.baseinfo.knowledge.code.serializable;

import java.io.Serializable;

public class Person implements Serializable {

    private static final long serialVersionUID = -3534890433624150186L;

    private int age;

    private String name;

    private String sex;

    // 增加字段测试序列化

    private String addText;

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    public String getAddText() {

        return addText;

    }

    public void setAddText(String addText) {

        this.addText = addText;

    }

    @Override

    public String toString() {

        final StringBuffer sb = new StringBuffer("Person{");

        sb.append("age=").append(age);

        sb.append(", name='").append(name).append('\'');

        sb.append(", sex='").append(sex).append('\'');

        sb.append(", addText='").append(addText).append('\'');

        sb.append('}');

        return sb.toString();

    }

}

反序列化结果，新增的字段为空值

Deserialization.person===>Person{age=10, name='测试', sex='女', addText='null'}

Process finished with exit code 0

显式的指定UID，目前常用到的场景是：当object增加的字段时候，不希望反序列化出现异常，即希望类的不同版本对序列化兼容；

等用到其他场景的时候，再更新。。

3. Externalizable-example

import java.io.Externalizable;

import java.io.IOException;

import java.io.ObjectInput;

import java.io.ObjectOutput;

public class PersonExternal implements Externalizable {

    private int age;

    private String name;

    private String sex;

    @Override

    public void writeExternal(ObjectOutput out) throws IOException {
     //未实现

    }

    @Override

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
      //未实现

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    @Override

    public String toString() {

        final StringBuffer sb = new StringBuffer("PersonExternal{");

        sb.append("age=").append(age);

        sb.append(", name='").append(name).append('\'');

        sb.append(", sex='").append(sex).append('\'');

        sb.append('}');

        return sb.toString();

    }

先序列化再反序列化

package com.java.baseinfo.knowledge.code.serializable;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

public class TetsExternalizable {

    public static void main(String[] args) {

        //ExternalizableEnCode();

        ExternalizableDecode();

    }

    private static void ExternalizableEnCode() {

        PersonExternal personExternal = new PersonExternal();

        personExternal.setName("测试");

        personExternal.setAge(18);

        personExternal.setSex("女");

        File file = new File("src/test/resources/personExternal.txt");

        try {

            FileOutputStream fileOutputStream = new FileOutputStream(file);

            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);

            outputStream.writeObject(personExternal);

            System.out.printf("ExternalizableEnCode===>序列化完成");

        } catch (FileNotFoundException e) {

            System.out.printf("ExternalizableEnCode.FileNotFoundException===>" + e);

        } catch (IOException e) {

            System.out.printf("ExternalizableEnCode.IOException===>" + e);

        }

    }

    private static void ExternalizableDecode() {

        try {

            File file = new File("src/test/resources/personExternal.txt");

            FileInputStream fileInputStream = new FileInputStream(file);

            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);

            PersonExternal personExternal = (PersonExternal) inputStream.readObject();

            System.out.println("ExternalizableDecode.personExternal====>" + personExternal);

        } catch (FileNotFoundException e) {

            System.out.printf("ExternalizableDecode.FileNotFoundException===>" + e);

        } catch (IOException e) {

            System.out.printf("ExternalizableDecode.IOException===>" + e);

        } catch (ClassNotFoundException e) {

            System.out.printf("ExternalizableDecode.ClassNotFoundException===>" + e);

        }

    }

}

运行结果

ExternalizableDecode.personExternal====>PersonExternal{age=0, name='null', sex='null'}

此时发现，当时序列化的对象值并未持久化，是因为我们没有重写Externalizable的writeExternal和readExternal方法

重写externalizable方法

package com.java.baseinfo.knowledge.code.serializable;

import java.io.Externalizable;

import java.io.IOException;

import java.io.ObjectInput;

import java.io.ObjectOutput;

public class PersonExternal implements Externalizable {

    private int age;

    private String name;

    private String sex;

    @Override

    public void writeExternal(ObjectOutput out) throws IOException {

        out.writeInt(age);

        out.writeObject(name);

        out.writeObject(sex);

    }

    @Override

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

        age = in.readInt();

        name = (String) in.readObject();

        sex = (String) in.readObject();

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    @Override

    public String toString() {

        final StringBuffer sb = new StringBuffer("PersonExternal{");

        sb.append("age=").append(age);

        sb.append(", name='").append(name).append('\'');

        sb.append(", sex='").append(sex).append('\'');

        sb.append('}');

        return sb.toString();

    }

}

运行结果

ExternalizableEnCode===>序列化完成ExternalizableDecode.personExternal====>PersonExternal{age=18, name='测试', sex='女'}

结论：

Externalizable反序列化的时候，会调用被序列化的无参构造函数去创建一个新的对象，然后再将被保存的对象的字段分别填充到新的对象中；所以使用Externalizable时候，除了重写write/read方法外，所需要序列化的对象还需要提供一个无参的构造函数；若没有无参构造函数，则会抛异常：java.io.InvalidClassException

eg:

package com.java.baseinfo.knowledge.code.serializable;

import java.io.Externalizable;

import java.io.IOException;

import java.io.ObjectInput;

import java.io.ObjectOutput;

public class PersonExternal implements Externalizable {

    private int age;

    private String name;

    private String sex;

    //构造函数

    public PersonExternal(int age, String name, String sex) {

        this.age = age;

        this.name = name;

        this.sex = sex;

    }

    @Override

    public void writeExternal(ObjectOutput out) throws IOException {

        out.writeInt(age);

        out.writeObject(name);

        out.writeObject(sex);

    }

    @Override

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

        age = in.readInt();

        name = (String) in.readObject();

        sex = (String) in.readObject();

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    @Override

    public String toString() {

        final StringBuffer sb = new StringBuffer("PersonExternal{");

        sb.append("age=").append(age);

        sb.append(", name='").append(name).append('\'');

        sb.append(", sex='").append(sex).append('\'');

        sb.append('}');

        return sb.toString();

    }

}

test main

package com.java.baseinfo.knowledge.code.serializable;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

public class TetsExternalizable {

    public static void main(String[] args) {

        ExternalizableEnCode();

        ExternalizableDecode();

    }

    private static void ExternalizableEnCode() {

        PersonExternal personExternal = new PersonExternal(18,"测试","女");

/*        personExternal.setName("测试");

        personExternal.setAge(18);

        personExternal.setSex("女");*/

        File file = new File("src/test/resources/personExternal.txt");

        try {

            FileOutputStream fileOutputStream = new FileOutputStream(file);

            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);

            outputStream.writeObject(personExternal);

            System.out.printf("ExternalizableEnCode===>序列化完成");

        } catch (FileNotFoundException e) {

            System.out.printf("ExternalizableEnCode.FileNotFoundException===>" + e);

        } catch (IOException e) {

            System.out.printf("ExternalizableEnCode.IOException===>" + e);

        }

    }

    private static void ExternalizableDecode() {

        try {

            File file = new File("src/test/resources/personExternal.txt");

            FileInputStream fileInputStream = new FileInputStream(file);

            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);

            PersonExternal personExternal = (PersonExternal) inputStream.readObject();

            System.out.println("ExternalizableDecode.personExternal====>" + personExternal);

        } catch (FileNotFoundException e) {

            System.out.printf("ExternalizableDecode.FileNotFoundException===>" + e);

        } catch (IOException e) {

            System.out.printf("ExternalizableDecode.IOException===>" + e);

        } catch (ClassNotFoundException e) {

            System.out.printf("ExternalizableDecode.ClassNotFoundException===>" + e);

        }

    }

}

运行结果

ExternalizableEnCode===>序列化完成ExternalizableDecode.IOException===>java.io.InvalidClassException: com.java.baseinfo.knowledge.code.serializable.PersonExternal; no valid constructor

4.transient 关键字

如果对象的属性被赋予transient属性，则该对象在序列化的时候，当前字段不会被序列化；那么再反序列化的时候，该字段会被赋予默认值，如int类型会是0，String为null

public class Person implements Serializable {

    private static final long serialVersionUID = -3534890433624150186L;

    private transient int age;

    private transient String name;

    private String sex;

    // 增加字段测试序列化

    private String addText;

运行2中的序列化代码，则结果为

序列化成功

反序列化Deserialization.person===>Person{age=0, name='null', sex='女', addText='addText'}

Process finished with exit code 0

参考：https://www.cnblogs.com/xdp-gacl/p/3777987.html

http://www.importnew.com/17964.html

java_对象序列化、反序列化的更多相关文章

java_对象序列化
对象序列化(serializable) 序列化读:ObjectInputStream ois=new ObjectInputStream(new FileInputStream("./gg ...
Java对象序列化/反序列化的注意事项(转)
Java对象序列化对于一个存在Java虚拟机中的对象来说,其内部的状态只是保存在内存中.JVM退出之后,内存资源也就被释放,Java对象的内部状态也就丢失了.而在很多情况下,对象内部状态是需要被持久 ...
Java对象序列化/反序列化的注意事项
Java对象序列化对于一个存在Java虚拟机中的对象来说,其内部的状态只是保存在内存中.JVM退出之后,内存资源也就被释放,Java对象的内部状态也就丢失了.而在很多情况下,对象内部状态是需要被持久 ...
c# XML-Object对象序列化-反序列化
using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Tex ...
java 对象序列化与反序列化
Java序列化与反序列化是什么? 为什么需要序列化与反序列化? 如何实现Java序列化与反序列化? 本文围绕这些问题进行了探讨. 1.Java序列化与反序列化 Java序列化是指把Java对象转换为 ...
C#对象序列化与反序列化zz
C#对象序列化与反序列化(转载自:http://www.cnblogs.com/LiZhiW/p/3622365.html) 1. 对象序列化的介绍........................ ...
C#对象序列化与反序列化
C#对象序列化与反序列化(转载自:http://www.cnblogs.com/LiZhiW/p/3622365.html) 1. 对象序列化的介绍.......................... ...
Java Io 对象序列化和反序列化
Java 支持将任何对象进行序列化操作,序列化后的对象文件便可通过流进行网络传输. 1. 对象序列化就是将对象转换成字节序列,反之叫对象的反序列化 2. 序列化流ObjectOut ...
Json对象序列化与反序列化
如果后台的参数数对象,需要在前台传入: JS代码: //创建JS对象 var CUTTING_TABLET_MO = new Object(); CUTTING_TABLET_MO.CUTTING_T ...

随机推荐

KVM虚拟化之windows虚拟机性能调整
通过KVM安装WindowsXP/2003/7/2008操作系统后,由于默认的磁盘驱动(IDE)性能与网卡驱动(RTL8139100M)的性能都极其低下,需要调整,通过加载Redhatvirtio驱动 ...
“全栈2019”Java第三十五章：面向对象
难度初级学习时间 10分钟适合人群零基础开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...
Kettle 行列互换之——行转列（多列数据合并成一列变为多行）
原始需求如下: 业务系统设置成这样,见截图. 工资项目为了方便录入,都是做成列的. 但是这些数据需要和另外的费用报销系统的数据关联,费用报销系统的费用项目是横向的,用费用项目.金额的多行来表达.那么这 ...
【Python】二进制转ASCII码小脚本
#coding:utf-8 #developed by carrypan! import binascii import optparse def main(): usage="%prog ...
vue-tree 组织架构图/树形图自动生成(含添加、删除、修改)
项目中用代码生成组织架构图有新增,编辑,删除的功能生成树形图的组件git-hub地址: https://github.com/tower1229/Vue-Tree-Char ...
SpringBoot 整合 ActiveMq
消息队列,用来处理开发中的高并发问题,通过线程池.多线程高效的处理并发任务. 首先,需要下载一个ActiveMQ的管理端:我本地的版本是 activemq5.15.8,打开activemq5.15.8 ...
Linux Intro - Remove 302 字符
I have a file originally provided from a SQL database on a Windows platform. I transfer the file via ...
https迁移实践手记
前言什么是公钥和私钥?使用OpenssL生成私钥.使用Keytool导出私钥.主流数字证书都有哪些格式?SSL证书类型注册SSL证书使用OpenSSL工具生成CSR文件使用keytool工具生成CSR ...
Robot Framework_Ride（Run标签）
前言我一直在想 Robot Framework 不要 RIDE 可不可以.对于编写测试用例来说,只要掌握 RobotFramework 的语法规则,随便在一个你顺手的编辑器下编写也没问题,甚至效率更 ...
Java万年历，输入年月获取该年月日历表
//输入年份和月份,打印出这个月的日历表 /* 1.1900年1月1日是星期一 2.计算输入的年份距离1900年有多少天再计算当年1月1日距这个月有多少天 1) 3.总天数%7得出从星期几开始注:计 ...

java_对象序列化、反序列化

1.概念

2.Serializable-example

2.1 无显式的指定UID,采用编译系统自动生成的

2.2 显式指定UID

3. Externalizable-example

4.transient 关键字

java_对象序列化、反序列化的更多相关文章

随机推荐

热门专题