Java序列化

最新推荐文章于 2024-09-04 22:32:50 发布
最新推荐文章于 2024-09-04 22:32:50 发布
阅读量206 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzypiper/article/details/106794404
版权

Java序列化

1 概述

1.1 序列化和反序列化

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

1.2 为什么序列化

  • 持久化对象：把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中。
  • 网络传输对象：在网络上传送对象的字节序列。

2 序列化原理

2.1 demo

public class Employee implements Serializable {
    public String name;
    public String address;
    public transient int SSN;
    public int number;
    public transient String password;

    public void mailCheck() {
        System.out.println("Mailing a check to " + name
                + " " + address);
    }
}

序列化

public class SerializeDemo {
    public static void main(String[] args) {
        String path = "employee.ser";

        Employee e = new Employee();
        e.name = "Reyan Ali";
        e.address = "Phokka Kuan, Ambehta Peer";
        e.SSN = 11122333;
        e.number = 101;
        e.password = "123";
        try {
            FileOutputStream fileOut = new FileOutputStream(path);
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            out.writeObject(e);
            out.close();
            fileOut.close();
            System.out.printf("Serialized data is saved in " + path);
        } catch (IOException i) {
            i.printStackTrace();
        }
    }
}

反序列化

public class DeserializeDemo {
    public static void main(String[] args) {
        String path = "F:/IdeaProjects/Workstation/jdk1.8SourceLearning/test/employee.ser";
        Employee e = null;
        try {
            FileInputStream fileIn = new FileInputStream(path);
            ObjectInputStream in = new ObjectInputStream(fileIn);
            e = (Employee) in.readObject();
            in.close();
            fileIn.close();
        } catch (IOException i) {
            i.printStackTrace();
            return;
        } catch (ClassNotFoundException c) {
            System.out.println("Employee class not found");
            c.printStackTrace();
            return;
        }
        System.out.println("Deserialized Employee...");
        System.out.println("Name: " + e.name);
        System.out.println("Address: " + e.address);
        System.out.println("SSN: " + e.SSN);
        System.out.println("Number: " + e.number);
        System.out.println("Password: " + e.password);
    }
}

2.2 源码分析

writeObject()

    public final void writeObject(Object obj) throws IOException {
        if (enableOverride) {
            writeObjectOverride(obj);
            return;
        }
        try {
        	// 调用writeObject0()方法进行具体的序列化操作
            writeObject0(obj, false);
        } catch (IOException ex) {
            if (depth == 0) {
                writeFatalException(ex);
            }
            throw ex;
        }
    }

writeObject0()

    /**
     * Underlying writeObject/writeUnshared implementation.
     */
    private void writeObject0(Object obj, boolean unshared)
        throws IOException
    {
        boolean oldMode = bout.setBlockDataMode(false);
        depth++;
        try {
            // handle previously written and non-replaceable objects
            int h;
            if ((obj = subs.lookup(obj)) == null) {
                writeNull();
                return;
            } else if (!unshared && (h = handles.lookup(obj)) != -1) {
                writeHandle(h);
                return;
            } else if (obj instanceof Class) {
                writeClass((Class) obj, unshared);
                return;
            } else if (obj instanceof ObjectStreamClass) {
                writeClassDesc((ObjectStreamClass) obj, unshared);
                return;
            }

            // check for replacement object
            Object orig = obj;
            // 需要序列化的对象的Class对象
            Class<?> cl = obj.getClass();
            ObjectStreamClass desc;
            for (;;) {
                // REMIND: skip this check for strings/arrays?
                Class<?> repCl;
                // 创建描述c1的ObjectStreamClass对象
                desc = ObjectStreamClass.lookup(cl, true);
                if (!desc.hasWriteReplaceMethod() ||
                    (obj = desc.invokeWriteReplace(obj)) == null ||
                    (repCl = obj.getClass()) == cl)
                {
                    break;
                }
                cl = repCl;
            }
            if (enableReplace) {
                Object rep = replaceObject(obj);
                if (rep != obj && rep != null) {
                    cl = rep.getClass();
                    desc = ObjectStreamClass.lookup(cl, true);
                }
                obj = rep;
            }

            // if object replaced, run through original checks a second time
            if (obj != orig) {
                subs.assign(orig, obj);
                if (obj == null) {
                    writeNull();
                    return;
                } else if (!unshared && (h = handles.lookup(obj)) != -1) {
                    writeHandle(h);
                    return;
                } else if (obj instanceof Class) {
                    writeClass((Class) obj, unshared);
                    return;
                } else if (obj instanceof ObjectStreamClass) {
                    writeClassDesc((ObjectStreamClass) obj, unshared);
                    return;
                }
            }

            // remaining cases
            // 根据实际要写入的类型，进行不同的写入操作
            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) {
            	// 实现序列化接口的都会执行下面的方法
                // 从这里可以看出Serializable是一个标记接口，其本身并没有什么意义
                writeOrdinaryObject(obj, desc, unshared);
            } else {
                if (extendedDebugInfo) {
                    throw new NotSerializableException(
                        cl.getName() + "\n" + debugInfoStack.toString());
                } else {
                    throw new NotSerializableException(cl.getName());
                }
            }
        } finally {
            depth--;
            bout.setBlockDataMode(oldMode);
        }
    }

上述代码完成了

  1. 创建ObjectStreamClass对象。
  2. 根据实际要写入的类型，进行不同的写入操作。

writeOrdinaryObject()

    /**
     * Writes representation of a "ordinary" (i.e., not a String, Class,
     * ObjectStreamClass, array, or enum constant) serializable object to the
     * stream.
     */
    private void writeOrdinaryObject(Object obj,
                                     ObjectStreamClass desc,
                                     boolean unshared)
        throws IOException
    {
        if (extendedDebugInfo) {
            debugInfoStack.push(
                (depth == 1 ? "root " : "") + "object (class \"" +
                obj.getClass().getName() + "\", " + obj.toString() + ")");
        }
        try {
            desc.checkSerialize();
 			
 			// 写入Object的标记位符号,表示这是一个新的Object对象
            bout.writeByte(TC_OBJECT);
            // 写入类元数据
            writeClassDesc(desc, false);
            handles.assign(unshared ? null : obj);
            if (desc.isExternalizable() && !desc.isProxy()) {
                writeExternalData((Externalizable) obj);
            } else {
            	// 写入序列化对象具体的实例数据
                writeSerialData(obj, desc);
            }
        } finally {
            if (extendedDebugInfo) {
                debugInfoStack.pop();
            }
        }
    }

源码解读

2.3 transient

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

3 序列化与单例模式

序列化生成的对象是一个新的对象，破坏了单例模式。

3.1 demo

public class Singleton implements Serializable {
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

public class SerializableDemo1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String path = "singleton.ser";
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path));
        oos.writeObject(Singleton.getSingleton());
        //Read Obj from file
        File file = new File(path);
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();
        //判断是否是同一个对象
        System.out.println(newInstance == Singleton.getSingleton()); // false
    }
}

3.2 源码分析

ObjectInputStream.readObject() => ObjectInputStream.readObject() => ObjectInputStream.readObject0() => ObjectInputStream.readOrdinaryObject()

    private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {
        if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();

        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }
		
		// 这里的obj就是之后得到的对象
        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

        passHandle = handles.assign(unshared ? unsharedMarker : obj);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(passHandle, resolveEx);
        }

        if (desc.isExternalizable()) {
            readExternalData((Externalizable) obj, desc);
        } else {
            readSerialData(obj, desc);
        }

        handles.finish(passHandle);

        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                handles.setObject(passHandle, obj = rep);
            }
        }

        return obj;
    }

着重关注

Object obj;
try {
    obj = desc.isInstantiable() ? desc.newInstance() : null;
} catch (Exception ex) {
    throw (IOException) new InvalidClassException(
        desc.forClass().getName(),
        "unable to create instance").initCause(ex);
}
  • isInstantiable：如果一个serializable/externalizable的类可以在运行时被实例化，该方法就返回true。
  • desc.newInstance：该方法通过反射的方式调用无参构造方法新建一个对象。
  • 破坏单例模式的原因：序列化会通过反射调用无参数的构造方法创建一个新的对象。

3.3 解决方法

添加readResolve()方法

public class Singleton implements Serializable {
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
    private Object readResolve() {
        return singleton;
    }
}

3.4 源码分析

if (obj != null &&
    handles.lookupException(passHandle) == null &&
    desc.hasReadResolveMethod())
{
    Object rep = desc.invokeReadResolve(obj);
    if (unshared && rep.getClass().isArray()) {
        rep = cloneArray(rep);
    }
    if (rep != obj) {
        handles.setObject(passHandle, obj = rep);
    }
}
  • invokeReadResolve:通过反射的方式调用要被反序列化的类的readResolve方法。

序列化对单例模式的破坏

4 protobuf

Protobuf是一种平台无关、语言无关、可扩展且轻便高效的序列化数据结构的协议，可以用于网络通信和数据存储。

to do

5 安全性

序列化与反序列化是一对可逆的过程。若以明文方式进行网络传输，容易被截获。

解决方案

  1. 序列化Hook化（移位和复位）
  2. 序列数据加密和签名
  3. 利用transient的特性解决
  4. 打包和解包代理

Java序列化高级进阶

6 参考

Java中序列化实现原理研究

zzypiper
关注
专栏目录
深度详解Java序列化
weixin_43178406的博客
09-24 6万+
 对象序列化是将对象转换为字节序列的过程，使其可以在网络上进行传输或者保存到磁盘上。本文将详细介绍Java对象序列化的实现机制、工作原理和注意事项。希望能对学习Java的同学们有所帮助。 文章目录 1. Java对象序列化的作用 2. Java对象序列化实现机制 3. 序列化的注意事项 4. 常用的序列化协议 4.1 Java标准序列化 4.2 JSON 4.3 Protobuf 4.4 Thrift 5. 总结
Java序列化与反序列化三种格式存取
12-22
　Java中的序列化（serialization）机制能够将一个实例对象的状态信息写入到一个字节流中，使其可以通过socket进行传输、或者持久化存储到数据库或文件系统中；然后在需要的时候，可以根据字节流中的信息来重构一个...
认识Serializable和重写读写方法
ddxxii的博客
04-15 3171
简述 需要将对象持久化到我们的存储设备上或者通过网络传输到其他客户端，那么我们就需要序列化。 Serializable为Java中带的一种序列化方式，使用起来非常简单。只需要让类实现一个Serializable接口就可以进行序列化了。 使用 先讲初步使用，后面会讲到serialVersionUID。 定义一个User类，实现Serializable接口 public class...
明晰 | Java序列化与反序列化
mySoul
08-19 205
小小开始写作，这是本周的第三篇这是小小本周的第三篇 最近事情有点多，多的让人有点受不了本篇将会分为实战和理论两部分，依次进行讲解。实战含义序列化：对象写入IO流中，实现对象变成文件。反序...
深入理解Java序列化
start_mao的博客
05-31 666
一、概念 序列化：把Java对象转化为二进制字节码的过程。 反序列化：将在序列化过程中所生成的二进制字节码转换成Java对象的过程。 为什么需要序列化呢？ 主要有两个作用： 持久化，通过序列化把Java对象转化为二进制字节码，然后可以将其保存在文件中，在合适的时候再反序列化恢复为一个对象。 传输，网络上传输的数据都是二进制的形式，再网络上传输一个Java对象需要先序列化为二进制数据，然后在网络的另一端通过反序列化将接收到的二进制数据转为Java对象。 二、Serializable接口 public in
java 序列化保存到磁盘的相关问题
sammor
01-09 299
package com.taskManager.connectionStation; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.Obje...
详解JAVA序列化
Joker_ZJN的博客
06-27 8137
进来，一文给你讲明白“序列化”。
java序列化
栋幺栋幺-的博客
11-17 1764
含义、意义使用场景 序列化：将对象写入到IO流中 反序列化：从IO流中恢复对象 意义：序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。 使用场景：所有可在网络上传输的对象都必须是可序列化的，比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保存到磁盘的java对象都必须是可序列化的。通常建议：
JAVA序列化
jx的博客
11-26 1507
java序列化就是将java对象转换为二进制编码的过程。反序列化就是将二进制编码转换为java对象的过程。
Java序列化详解
码灵的博客
02-08 1640
序列化是指将对象转化为字节流的过程，以便于存储或传输。在序列化过程中，对象的状态被保存为一连串的字节，可以将这些字节保存到文件中或通过网络传输。序列化后的字节流可以在需要时进行反序列化，将字节流重新转化为对象，并恢复对象的状态。在Java中，对象的序列化是通过实现接口来实现的。Serializable接口是一个标记接口，没有任何方法，只是用于标识一个类可以被序列化。当一个类实现了Serializable接口，它的对象就可以被序列化为字节流。
一文搞懂JAVA序列化机制
yang_brother的博客
09-04 1877
序列化：把Java对象转换为字节序列的过程。反序列化：把字节序列恢复为Java对象的过程。
Java序列化_Java序列化结构_
09-29
Java序列化是Java平台中的一种持久化机制，它允许对象的状态被转换成字节流，以便存储、网络传输或在不同时间点恢复。这个过程被称为序列化，而反向操作称为反序列化。序列化在许多场景下都非常有用，比如在分布式...
Protocol Buffer序列化对比Java序列化.
06-19
【Protocol Buffer序列化对比Java序列化】 Protocol Buffer（简称PB）是Google开发的一种高效的数据序列化协议，而Java序列化是Java平台内置的一种序列化机制。两者的主要目标都是将对象转化为字节数组，便于在网络...
java 序列化与反序列化的实例详解
08-29
Java 序列化与反序列化是 Java 编程语言中的一种机制，允许将 Java 对象转换为字节序列，并将其反序列化回 Java 对象。序列化是指将 Java 对象转换为字节序列的过程，而反序列化是指将字节序列恢复为 Java 对象的...
java 序列化时排除指定属性
08-09
Java序列化是Java平台提供的一种持久化机制，它允许我们将一个Java对象转换为字节流，以便存储到磁盘上，或者通过网络进行传输。这使得我们可以保存和恢复对象的状态。实现序列化的类需要实现`Serializable`接口，...
VB程序实例-图像的打印.zip
11-03
VB程序实例-图像的打印.zip
VB程序实例-字形窗口.zip
最新发布
11-03
VB程序实例-字形窗口.zip
VB程序实例36_动态控制_增减控件.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享CC2530非常好的技术资料.zip
11-03
技术资料分享CC2530非常好的技术资料.zip
Java序列化详解与应用
"关于Java序列化的详细解析" Java序列化是Java平台提供的一种持久化机制，它允许将对象的状态转换为字节流，以便可以存储或在网络上传输。这个过程对于实现数据持久化、跨网络通信（如RMI和EJB）以及对象在分布式...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值