【java IO序列化详解】

最新推荐文章于 2024-07-27 17:56:15 发布

积善之家、必有余庆

最新推荐文章于 2024-07-27 17:56:15 发布

阅读量315

点赞数

分类专栏： #java io 文章标签： java 编程语言

本文链接：https://blog.csdn.net/qq_44682003/article/details/109057032

版权

#java io 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

唐门崛起

在这里插入图片描述

序列化

1.对象序列化和反序列化

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

序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。
反序列化：根据字节流恢复对象的过程

对象的序列化主要有两种用途：

（1）把对象的字节序列化永久的存放在磁盘上，通常放在一个文件夹下
（2）在网络上传输对象的字节序列

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

2.JDK类库中的序列化API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式

对象序列化包括如下步骤：
1）创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2）通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：
1）创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2）通过对象输入流的readObject()方法读取对象。

对象序列化和反序列范例：

//定义一个Person类，实现Serializable接口
class Dog implements Serializable {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ObjectStreamTest {
    public static void main(String[] args) {
        Dog dog = new Dog("pig",7);
        //对象变为字节，存储到文件中
        ObjectOutputStream out = null;
        ObjectInputStream in = null;
        try {
            out = new ObjectOutputStream(new FileOutputStream("D:\\qq\\A\\dog.txt"));
            out.writeObject(dog);
            System.out.println("-----反序列化结果：--------");
            in = new ObjectInputStream(new FileInputStream("D:\\qq\\A\\dog.txt"));
            Dog o =(Dog)in.readObject();
            System.out.println(o);
        }catch (IOException e){
            e.printStackTrace();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述

序列化Dog成功后在D盘生成了一个dog.txt文件，而反序列化Dog是读取D盘的dog.txt后生成了一个dog对象

3.为什么实现了Serializable接口，就可以被序列化

//源码
public interface Serializable {
}

我们看到，Serializable是一个空接口，那么我们从Serializable下的方法来探究

使用ObjectOutputStream来持久化对象到文件中，使用了writeObject方法，该方法又调用了如下方法：

//源码
private void writeObject0(Object obj, boolean unshared) throws IOException {  
      ...
    if (obj instanceof String) {  
        writeString((String) obj, unshared);  
    } else if (cl.isArray()) {  
        writeArray(obj, desc, unshared);  
    } else if (obj instanceof Enum) {  
        writeEnum((Enum) obj, desc, unshared);  
    } else if (obj instanceof Serializable) {  
        writeOrdinaryObject(obj, desc, unshared);  
    } else {  
        if (extendedDebugInfo) {  
            throw new NotSerializableException(cl.getName() + "\n" 
                    + debugInfoStack.toString());  
        } else {  
            throw new NotSerializableException(cl.getName());  
        }  
    }  
    ...  
}

从上述代码可知，如果被写对象的类型是String，或数组，或Enum，或Serializable，那么就可以对该对象进行序列化，否则将抛出NotSerializableException
String类型的对象、枚举类型的对象、数组对象，都是默认可以被序列化的

4.serialVersionUID

4.1 serialVersionUID的生成

serialVersionUID: 字面意思上是序列化的版本号，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量

通过编译器生成serialVersionUID：
在这里插入图片描述

结果：
上面这种这种方式生成的serialVersionUID是根据类名，接口名，方法和属性等来生成的

注意：默认的private static final long serialVersionUID = 1L;

4.2 serialVersionUID的作用

serialVersionUID(序列化版本号)到底有什么用呢，我们来举个例子：

//定义一个Person类，实现Serializable接口
class Dog implements Serializable {

    String name;
    int age;

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

    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ObjectStreamTest {
    public static void main(String[] args) {
        Dog dog = new Dog("pig",7);
        //对象变为字节，存储到文件中
        ObjectOutputStream out = null;
        ObjectInputStream in = null;
        try {
            out = new ObjectOutputStream(new FileOutputStream("D:\\qq\\A\\dog.txt"));
            out.writeObject(dog);
            System.out.println("序列化成功");
            System.out.println("-----反序列化结果：--------");
            in = new ObjectInputStream(new FileInputStream("D:\\qq\\A\\dog.txt"));
            Dog o =(Dog)in.readObject();
            System.out.println(o);
        }catch (IOException e){
            e.printStackTrace();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述
序列化和反序列化都成功了
下面我们修改一下Dog类，添加多一个sex属性，如下：

//定义一个Person类，实现Serializable接口
class Dog implements Serializable {

    String name;
    int age;
    
    String Sex;//新增属性
    
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;

    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public Dog(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        Sex = sex;
    }
}

然后执行反序列操作，此时就会抛出如下的异常信息：

 Exception in thread "main" java.io.InvalidClassException:Dog; local class incompatible: stream classdesc serialVersionUID = 170680626635197888, local class serialVersionUID = -6768061766116160869

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID）序列化操作的时候系统会把当前类的serialVersionUID（特殊处理）写入到序列化文件中，当反序列化时系统会去检测文件中的serialVersionUID，判断它是否与当前类的serialVersionUID一致，如果一致就说明序列化类的版本与当前类版本是一样的，可以反序列化成功，否则失败。serialVersionUID 用来表明类的不同版本间的兼容性。

我们真的有需求要在序列化后添加一个字段或者方法呢？应该怎么办？那就是自己去指定serialVersionUID

下面继续修改Dog类，给Dog指定一个serialVersionUID，修改后的代码如下：

class Dog implements Serializable {


    private static final long serialVersionUID = -5061770832529915969L;
    String name;
    int age;
    //新增字段
    // String Sex;

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

    }

//    public Dog(String name, int age, String sex) {
//        this.name = name;
//        this.age = age;
//        Sex = sex;
//    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

重新执行序列化操作，将Dog对象序列化到本地硬盘的Dog.txt文件存储，然后修改Dog类，添加sex属性，修改后的Dog类代码如下：

class Dog implements Serializable {


    private static final long serialVersionUID = -5061770832529915969L;
    String name;
    int age;
    //新增字段
     String Sex;

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

    }

    public Dog(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        Sex = sex;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

执行反序列操作，这次就可以反序列成功了，如下所示：
在这里插入图片描述

4.3 serialVersionUID的取值

serialVersionUID的取值是Java运行时环境根据类的内部细节自动生成的。如果对类的源代码作了修改，再重新编译，新生成的类文件的serialVersionUID的取值有可能也会发生变化。
类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的 serialVersionUID，也有可能相同。为了提高serialVersionUID的独立性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。

显式地定义serialVersionUID有两种用途：
1、在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；
2、在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID

4.4 序列化需要注意的点

1、序列化并不保存静态变量
这句话什么意思呢，我们来看个例子，还是以：上面第1节Dog类为例
在这里插入图片描述
结果：

我们发现，age结果未受影响，还是7

我们对Dog类稍作改变，把age属性变为静态属性，还是运行上述的序列和反序列代码：

class Dog implements Serializable {

    private static final long serialVersionUID = -2801048688496433611L;


    String name;
    static int age;
    


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

    }

    public static int getAge() {
        return age;
    }

    public static void setAge(int age) {
        Dog.age = age;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
  

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

结果：
在这里插入图片描述
为什么，我们把改变静态属性就可以反序列化出结果呢？
答：因为静态属性是属于类，而不是我们我们操作的当前对象：dog；也就是当我们改变静态属性时，直接作用的是我们这个类，不需要通过对象

2、要想将父类对象也序列化，就需要让父类也实现Serializable 接口

3、Transient 关键字
Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null

Transient 只能修饰属性加上关键字之后，不使用默认的序列化和反序列化方式用我们重写的方式去序列化和反序列化
使用场景：
Transient 不使用默认的序列化和反序列化方式并不去重写的方式去序列化和反序列化

（1）为了安全起见，有时候我们不需要在网络间传输一些数据,不希望明文形式存储到文件中（如身份证号码，密码，银行卡号等）
重写：readObject、writeObject
（2）当你不想让某个字段序列化时，直接加上关键字，不用做后续处理

举例：

import java.io.*;
//Serializable  标记接口
class Dog implements Serializable {

    private static final long serialVersionUID = 3345858508042116669L;
    //默认就是1L
    String name;
    transient int age;   //当你不想让某个字段序列化，或者不想让某个字段按照默认方式
    //序列化  就是用这个字段

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


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    //重新定义序列化方式
    private void writeObject(ObjectOutputStream out) {
        try {
            //会对一些没有被transient修饰的字段使用默认方式序列化
            out.defaultWriteObject();
            //md5
            age = age * 9 + 10;
            out.writeInt(age);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //重新定义反序列化方式
    private void readObject(ObjectInputStream in) {
        try {
            in.defaultReadObject();
            int i = in.readInt();  //加密过的age
            age = (i - 10) / 9;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ObjectStreamTest {  //对象持久化的过程   数据落地
    public static void main(String[] args) {
        Dog dog = new Dog("迪克", 8);
        ObjectOutputStream out = null;
        ObjectInputStream in = null;
        try {
            out = new ObjectOutputStream(
                    new FileOutputStream("D:\\qq\\dog.txt"));
         out.writeObject(dog);
//            out.writeObject(b);
            out.writeUTF(dog.getName());
            out.writeInt(dog.getAge());
            System.out.println("---------------反序列化的结果如下-------------------");
            in = new ObjectInputStream(
                    new FileInputStream("D:\\qq\\dog.txt"));
            Dog d1 = (Dog) in.readObject();  //只有name
            System.out.println(d1);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

4、ArrayList数组的序列化
ArrayList实际上是动态数组，每次在放满以后自动增长设定的长度值，如果数组自动增长长度设为100，而实际只放了一个元素，那就会序列化99个null元素。为了保证在序列化的时候不会将这么多null同时进行序列化，ArrayList把元素数组设置为transient。

一般情况下：对一个变量进行不序列化的标记之后紧跟着就会对writeObject 和readObject 对这个变量进行特殊的序列户和序列化

通过ArrayList底层源码了解Java的序列化
1、writeObject和readObject方法

在序列化过程中，如果被序列化的类中定义了writeObject 和 readObject 方法，虚拟机会试图调用对象类里的
writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化。如果没有这样的方法，则默认调用是
ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的
defaultReadObject 方法

源码：
writeObject：

private void readObject(java.io.ObjectInputStream s)
       throws java.io.IOException, ClassNotFoundException {
       elementData = EMPTY_ELEMENTDATA;
       // Read in size, and any hidden stuff
       s.defaultReadObject();
       // Read in capacity
       s.readInt(); // ignored
       if (size > 0) {
           // be like clone(), allocate array based upon size not capacity
           ensureCapacityInternal(size);
           Object[] a = elementData;
           // Read in all elements in the proper order.
           for (int i=0; i<size; i++) {
               a[i] = s.readObject();
           }
       }
   }

readObject：

private void writeObject(java.io.ObjectOutputStream s)
       throws java.io.IOException{
       // Write out element count, and any hidden stuff
       int expectedModCount = modCount;
       s.defaultWriteObject();
       // Write out size as capacity for behavioural compatibility with clone()
       s.writeInt(size);
       // Write out all elements in the proper order.
       for (int i=0; i<size; i++) {
           s.writeObject(elementData[i]);
       }
       if (modCount != expectedModCount) {
           throw new ConcurrentModificationException();
       }
   }

writeObject方法把elementData数组中的元素遍历的保存到输出流（ObjectOutputStream）中。readObject方法从输入流（ObjectInputStream）中读出对象并保存赋值到elementData数组中

5.DataInputStream,DataOutput

DataInputStream,DataOutput和ObjectInputStream与ObjectOutputStream作用是一样的，都是用于序列化和反序列化

举例：

public class DataTest {
    public static void main(String[] args) {
        DataOutputStream out = null;
        DataInputStream in = null;
        People p = new People("张三", 13, new A(1, "dsad"));
        try {
            out = new DataOutputStream(new FileOutputStream("D:\\Java\\IoTest\\p.txt"));
            out.writeUTF(p.getName());
            out.writeInt(p.getAge());
            out.writeInt(p.getA().getSex());
            out.writeUTF(p.getA().getName());
            in = new DataInputStream(new FileInputStream("D:\\Java\\IoTest\\p.txt"));
            People p1 = new People();
            p1.setName(in.readUTF());
            p1.setAge(in.readInt());
            A a = new A();
            a.setSex(in.readInt());
            a.setName(in.readUTF());
            p1.setA(a);
            System.out.println(p1);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.Object相当于装IO流的一个盒子,我们可以把对象比作一个个拼好的积木,IO流就是拼积木的积木块,那么如果要搬走积木(对象),肯定需要把积木(对象)先拆了,再扔进盒子(Object)里,这就是为什么对象要序列化(Serializable)
2.当然装的时候我们可以有两种装法一种是全放入(output.writeObject(this))第一种盒子(ObjectInputStream) 另一种是分类别 (如:,比如屋顶,地板,这就是流里面的) 放入(output.writeUTF(number),output.writeUTF(name),output.writeInt(age)…)第二种盒子(DataInputStream),所以在搬到另一个地方的时候第一种盒子里我们把混在一起的积木块倒出((Member)intput.readObject()), 第二种盒子则是分块拿出来({input.readUTF(),input.readUTF(),input.readInt()…)
处理基本类型的时候没有什么很大的区别，区别是Object的可将一个实现了序列化的类实例写入输出流中， ObjectInput可以从输入流中将ObjectOutput输出的类实例读入到一个实例中。DataOutputStream只能处理基本类型。 Object处理的类必须是实现了序列化的类

总结：

1、如果一个类想被序列化，需要实现Serializable接口。否则将抛出NotSerializableException异常，这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。

2、在变量声明前加上该关键字，可以阻止该变量被序列化到文件中。

3、在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略

6.创建对象的四种方式（练习）

1.使用new关键字
这是最常见也是最简单的创建对象的方式了。通过这种方式，我们可以调用任意的构造函数(无参的和带参数的)。
Employee emp1 =new Employee();

2.使用Class类的newInstance方法
我们也可以使用Class类的newInstance方法创建对象。这个newInstance方法调用无参的构造函数创建对象。
我们可以通过下面方式调用newInstance方法创建对象:
Employee emp2 = (Employee) Class.forName(“org.programming.mitra.exercises.Employee”).newInstance();//或者
Employee emp2 = Employee.class.newInstance();

3.使用clone方法
无论何时我们调用一个对象的clone方法，jvm就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。
要使用clone方法，我们需要先实现Cloneable接口并实现其定义的clone方法。
Employee emp4 = (Employee) emp3.clone();

4.使用反序列化
当我们序列化和反序列化一个对象，jvm会给我们创建一个单独的对象。在反序列化时，jvm创建对象并不会调用任何构造函数。
为了反序列化一个对象，我们需要让我们的类实现Serializable接口
ObjectInputStream in =new ObjectInputStream(newFileInputStream(“data.obj”));
Employee emp5 = (Employee) in.readObject();

积善之家、必有余庆

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【java IO序列化详解】

唯编程和动漫不可缺得序列化1.对象序列化1.1 什么是序列化1.2 .序列化的作用（序列化的使用场景）1.对象序列化1.1 什么是序列化序列化是一种对象持久化的手段：指将对象转换为字节流的过程。那我们之前做的是不就是把一个具体东西，比如文本，比如照片等等转换成字节流的过程。我们之前是把文件无论是什么类型的转为字节序列那序列化做的就是将对象转为字节序列。1.2 .序列化的作用（序列化的使用场景）（1）把对象的字节序列化永久的存放在磁盘上，通常放在一个文件夹下（2）在网络上传输对象的字节.
复制链接

扫一扫

专栏目录