Java Serializable序列化高级

最新推荐文章于 2021-02-16 09:46:55 发布

qq_34341338

最新推荐文章于 2021-02-16 09:46:55 发布

阅读量157

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： Java 序列化 Serializable

本文链接：https://blog.youkuaiyun.com/qq_34341338/article/details/86638911

java 专栏收录该内容

19 篇文章

订阅专栏

之前的文章中有介绍Android种的序列化的相关知识，但是对于一些深入的知识没有说明并且学习到，这篇文章记录一下。Android序列化相关知识.

1.Serializable使用的几个注意点

客户端A与客户端B通过网络传输数据C，客户端A将C序列化后传给B，B在反序列化得到数据。
C类在客户端A/B中所处的包以及包名必须完全一致，且实现Serializable接口，同时serialVersionUID必须一致，否则获取不到数据。虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）
序列化对象时，类的静态变量不会被保存；即序列化保存的是对象的状态，而静态变量属于类的状态。
结合案例：

import java.io.*;

public class SerializableTest implements Serializable {
    private static final long serialVersionUID = 1L;
    public static int count = 5;

    //序列化时不保存静态变量
    //即序列化保存的是对象的状态，而静态变量是属于类的状态
    public static void main(String[] args) {
        try {
            //写入SerializableTest类
            ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("test.obj"));
            obs.writeObject(new SerializableTest());
            obs.close();

            //修改静态变量的值
            SerializableTest.count = 26;
            //读序列化文件
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.obj"));
            SerializableTest test = (SerializableTest) ois.readObject();
            ois.close();

            //输出静态变量，输出的是修改后的值
            System.out.printf(String.valueOf(test.count));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出的结果是26而不是5.

子类实现Serializable接口，而它的父类没有实现Serializable接口，序列化子对象后，反序列化输出父类定义的某变量的值，输出结果不同。

import java.io.*;

public class SerializableTest implements Serializable {

    public static int count = 5;

    //序列化时不保存静态变量
    //即序列化保存的是对象的状态，而静态变量是属于类的状态
    public static void main(String[] args) {
        try {
            //写入SerializableTest类
            ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("test.obj"));
            obs.writeObject(new Student("tet"));
            obs.close();

            //修改静态变量的值
            SerializableTest.count = 26;
            //读序列化文件
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.obj"));
            Student test = (Student) ois.readObject();
            ois.close();

            //输出静态变量，输出的是修改后的值
            System.out.printf(String.valueOf(test.name));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Student extends Person implements Serializable{
    private static final long serialVersionUID = 1L;
    public Student(String name) {
        this.name = name;
    }
}

class Person{
    protected String name = "wdl";

    public String getName() {
        return name;
    }

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

输出结果为wdl.

解决：
要想将父类对象也序列化，就需要让父类也实现Serializable 接口。如果父类不实现的话的，就需要有默认的无参的构造函数。

一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。如果你考虑到这种序列化的情况，在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。

Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
对敏感字段进行自定义加解密过程。序列化过程中虚拟机会试图调用对象类里的readObject()以及writeObject()方法，假如未定义，则默认调用 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。
例子：

import java.io.*;

public class SerializableTest implements Serializable {
    private static final long serialVersionUID = 1L;
    public static int count = 5;
    private String password;

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    private void writeObject(ObjectOutputStream oos){
        try {
            ObjectOutputStream.PutField putField = oos.putFields();
            System.out.println("原始密码："+password);
            putField.put("password","password+md5");
            System.out.println("加密后的密码：password+md5");
            oos.writeFields();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    private void readObject(ObjectInputStream ois){
        try {
            ObjectInputStream.GetField getField = ois.readFields();
            Object psd = getField.get("password","");
            System.out.println("要解密的串："+psd.toString());
            password = "解密过程--获取密钥";
            System.out.println("解密后的密码："+password);

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

    //序列化时不保存静态变量
    //即序列化保存的是对象的状态，而静态变量是属于类的状态
    public static void main(String[] args) {
        try {
            //写入SerializableTest类
            ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("test.obj"));
            SerializableTest t = new SerializableTest();
            t.setPassword("123456");
            obs.writeObject(t);
            obs.close();

            //修改静态变量的值
            SerializableTest.count = 26;
            //读序列化文件
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.obj"));
            SerializableTest test = (SerializableTest) ois.readObject();
            ois.close();

            //输出静态变量，输出的是修改后的值
            //System.out.printf(String.valueOf(test.name));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

**序列化的存储规则问题。

import java.io.*;

public class SerializableTest implements Serializable {
    private static final long serialVersionUID = 1L;
    public static int count = 5;
    private String password;

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

//    private void writeObject(ObjectOutputStream oos){
//        try {
//            ObjectOutputStream.PutField putField = oos.putFields();
//            System.out.println("原始密码："+password);
//            putField.put("password","password+md5");
//            System.out.println("加密后的密码：password+md5");
//            oos.writeFields();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//    }
//
//
//    private void readObject(ObjectInputStream ois){
//        try {
//            ObjectInputStream.GetField getField = ois.readFields();
//            Object psd = getField.get("password","");
//            System.out.println("要解密的串："+psd.toString());
//            password = "解密过程--获取密钥";
//            System.out.println("解密后的密码："+password);
//
//        } catch (IOException e) {
//            e.printStackTrace();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
//    }

    //序列化时不保存静态变量
    //即序列化保存的是对象的状态，而静态变量是属于类的状态
    public static void main(String[] args) {
        try {
            //写入一次
            File file = new File("test.obj");
            ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream(file));
            SerializableTest t = new SerializableTest();
            obs.writeObject(t);
            obs.flush();
            System.out.println(file.length());

            //写入第二次
            obs.writeObject(t);
            System.out.println(file.length());
            obs.close();

            //读序列化文件
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
            SerializableTest test1 = (SerializableTest) ois.readObject();
            SerializableTest test2 = (SerializableTest) ois.readObject();
            System.out.println(test1 == test2);
            ois.close();

            //输出静态变量，输出的是修改后的值
            //System.out.printf(String.valueOf(test.name));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

在这里插入图片描述

从输出结果可以看出：

Java
序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，增加的5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得的 test1 和 test2 指向唯一的对象，二者相等，输出 true。

参考自：
https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html