Java Serializable（序列化）

最新推荐文章于 2024-04-21 09:35:37 发布

shuos_yan

最新推荐文章于 2024-04-21 09:35:37 发布

阅读量917

点赞数

分类专栏： Java

原文链接：https://blog.csdn.net/dreamtdp/article/details/15378329

版权

Java 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

1、序列化是干什么的？
简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
2、什么情况下需要序列化
a）持久化时；
b）网络传输数据；
c）通过RMI(远程方法调用)传输对象的时候；
3、当对一个对象实现序列化时，究竟发生了什么？
在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）
当通过序列化之后，可以将实例变量的值保存在文件中，做长久保存，保存的时候不仅保存的值变量的值，也保存了类的类型等信息以便回复到原来的对象
4. 举例一下：

package com.example.demo.test;

import lombok.Data;

import java.io.Serializable;

/**
 * @author:Shuoshi.Yan
 * @description: 
 * @date: 2020/4/21 10:51
 */
@Data
public class Test04 implements Serializable {
    private String id;
    private String uuid;
}

package com.example.demo.test;

import lombok.Cleanup;

import java.io.*;

/**
 * @author:Shuoshi.Yan
 * @description: 
 * @date: 2020/4/21 10:52
 */

public class Test04Main {
    public static void main(String[] args) {
        Test04 test04 = new Test04();
        test04.setId("1");
        test04.setUuid("1");

        try {
            @Cleanup FileOutputStream fileOutputStream = new FileOutputStream("test04.text");
            @Cleanup ObjectOutput objectOutput = new ObjectOutputStream(fileOutputStream);
            objectOutput.writeObject(test04);
//            @Cleanup ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test04.text"));
//            Test04 test041 = (Test04) objectInputStream.readObject();
//            System.out.println(test041.getId() + ";" + test041.getUuid());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
//        catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
    }
}

在这里插入图片描述
上面的是将对象保存到test04.text中，在这里的对象上我们加了Serializable，再来看一下不加Serializable，去掉Implement Serializable，结果：

所以需要加上Serializable，main方法里的注释掉的是读取刚刚保存的对象的文件的，将输出流注释掉，然后读取一下文件内容：
在这里插入图片描述
5. 相关注意事项
a）序列化时，只对对象的状态进行保存，而不管对象的方法；
b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
d）并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：

安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现。

简而言之:序列化的作用就是为了不同jvm之间共享实例对象的一种解决方案.由java提供此机制,效率之高,是其他解决方案无法比拟的
6. 什么是Java对象序列化
Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。
使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的"状态"，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。
除了在持久化对象时会用到对象序列化之外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用，在本文的后续章节中将会陆续讲到。
7. 使用
在Java中，只要一个类实现了java.io.Serializable接口，那么它就可以被序列化。可以具体看一下上面的例子
8. 默认序列化机制
如果仅仅只是让某个类实现Serializable接口，而没有其它任何处理的话，则就是使用默认序列化机制。使用默认机制，在序列化对象时，不仅会序列化当前对象本身，还会对该对象引用的其它对象也进行序列化，同样地，这些其它对象引用的另外对象也将被序列化，以此类推。所以，如果一个对象包含的成员变量是容器类对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。
9.影响序列化
在现实应用中，有些时候不能使用默认序列化机制。比如，希望在序列化过程中忽略掉敏感数据，或者简化序列化过程。下面将介绍若干影响序列化的方法。
9.1 transient关键字
当某个字段被声明为transient后，默认序列化机制就会忽略该字段
在这里插入图片描述
结果：id字段没有被序列化

9.2 writeObject()方法与readObject()方法
对于上述已被声明为transitive的字段age，除了将transitive关键字去掉之外，是否还有其它方法能使它再次可被序列化？方法之一就是在Person类中添加两个方法：writeObject()与readObject()，如下所示：
main方法不用动

package com.example.demo.test;

import lombok.Data;

import java.io.*;

/**
 * @author:Shuoshi.Yan
 * @description: 
 * @date: 2020/4/21 10:51
 */
@Data
public class Test04 implements Serializable {
    transient private String id;
    private String uuid;

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        out.writeBytes(id);
    }
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        id = in.readLine();
    }
}

在这里使用了transient关键字，应该是忽略id的，但是我们加了两个方法，结果是id依然会进行序列化
在这里插入图片描述
在writeObject()方法中会先调用ObjectOutputStream中的defaultWriteObject()方法，该方法会执行默认的序列化机制，此时会忽略id字段，然后再调用writeBytes()方法将id写入到ObjectOutputStreeam中，readObject方法的作用是针对对象进行读取。这两个方法都是private，使用的是反射进行调用的，可以看一下ObjectOutputStream中的writeSerialData方法，以及ObjectInputStream中的readSerialData方法，里面有一个getClass()方法

9.3 Externalizable接口
实现这个接口的类，之前基于Serializable接口的序列化机制就将失效

package com.example.demo.test;

import lombok.Data;

import java.io.*;

/**
 * @author:Shuoshi.Yan
 * @description: 
 * @date: 2020/4/21 10:51
 */
@Data
public class Test04 implements Externalizable {
    transient private String id;
    private String uuid;

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        out.writeBytes(id);
    }
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        id = in.readLine();
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {

    }

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

    }
}

结果：
在这里插入图片描述
我们将它改一下，使得可以序列化，操作一下writeExternal和readExternal方法

10. readResolve()方法
当我们使用单例模式时，目的是希望某个类是唯一的，但是若这个类是可序列化的，那么就不一定是唯一的，举例一下：

package com.example.demo.test;

import lombok.Data;

import java.io.*;

/**
 * @author:Shuoshi.Yan
 * @description: 
 * @date: 2020/4/21 10:51
 */
@Data
public class Test041 implements Serializable {

    private static class InstanceHolder{
        private static final Test041 instance = new Test041("1","2");
    }
    public static Test041 getInstance(){
        return InstanceHolder.instance;
    }
    private String id;
    private String uuid;

    private Test041(String id, String uuid) {
        this.id = id;
        this.uuid = uuid;
    }
}

main:

package com.example.demo.test;

import lombok.Cleanup;

import java.io.*;

/**
 * @author:Shuoshi.Yan
 * @description: 
 * @date: 2020/4/21 10:52
 */

public class Test04Main {
    public static void main(String[] args) {
        try {
            @Cleanup FileOutputStream fileOutputStream = new FileOutputStream("test041.text");
            @Cleanup ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutputStream);
            objectOutput.writeObject(Test041.getInstance());//保存单例对象
            @Cleanup ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test041.text"));
            Test041 test041 = (Test041) objectInputStream.readObject();
            System.out.println(test041.getId() + ";" + test041.getUuid());
            System.out.println(test041 == Test041.getInstance());//对比地址及内容
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

result:
在这里插入图片描述
false说明这俩对象不是同一个，这个时候就需要readResolve()方法出马了

package com.example.demo.test;

import lombok.Data;

import java.io.*;

/**
 * @author:Shuoshi.Yan
 * @description: 
 * @date: 2020/4/21 10:51
 */
@Data
public class Test041 implements Serializable {

    private static class InstanceHolder{
        private static final Test041 instance = new Test041("1","2");
    }
    public static Test041 getInstance(){
        return InstanceHolder.instance;
    }
    private String id;
    private String uuid;

    private Test041(String id, String uuid) {
        this.id = id;
        this.uuid = uuid;
    }
    private Object readResolve(){
        return InstanceHolder.instance;
    }
}

在这里插入图片描述
无论是Serializable还是Exterilizable接口，当从流中读取对象的时候，readReasolve()方法都会被调用，实际上是用readReasolve方法中返回到对象替换再反序列化过程中创建的对象，而被创建的对象则被回收掉

serialVersionUID

serialVersionUID的作用：
类似于标识的作用，序列化的时候根据serialVersionUID来验证版本是否一致，序列化操作的时候系统会把当前类的serialVersionUID写入到序列化文件中，当反序列化时系统会去检测文件中的serialVersionUID，判断它是否与当前类的serialVersionUID一致，如果一致就说明序列化类的版本与当前类版本是一样的，可以反序列化成功，否则失败，即是InvalidCastException。
serialVersionUID有两种显示的生成方式：
一是默认的1L，比如：private static final long serialVersionUID = 1L;
二是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段
一般使用第一种就行

序列化的方法

实现Serializavle接口

 简单，会自动序列化所有非static和 transient关键字修饰的成员变量，但不可控

实现Exterializable接口

 继承自Serializable，必须实现writeExternal()和readExternal()方法，需手动配置序列化字段，可控的

实现Serializable接口+添加writeObject()和readObject()方法
```
 结合第一和第二的优点
```

shuos_yan

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java Serializable（序列化）

本片文章转载于https://blog.csdn.net/dreamtdp/article/details/15378329 并加上了自己的理解1、序列化是干什么的？简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机...
复制链接

扫一扫