java如何序列化-Java入门-PHP中文网

一、序列化与反序列化

序列化：指堆内存中的java对象数据，通过某种方式把对存储到磁盘文件中，或者传递给其他网络节点（网络传输）。这个过程称为序列化，通常是指将数据结构或对象转化成二进制的过程。

即将对象转化为二进制，用于保存，或者网络传输。

反序列化：把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。也就是将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程

与序列化相反，将二进制转化成对象。

二、序列化的作用

① 想把内存中的对象保存到一个文件中或者数据库中时候；

② 想用套接字在网络上传送对象的时候；

③ 想通过RMI传输对象的时候

一些应用场景，涉及到将对象转化成二进制，序列化保证了能够成功读取到保存的对象。

三、java的序列化实现

要实现对象的序列化，最直接的操作就是实现Serializable接口

使用IO流中的对象流可以实现序列化操作，将对象保存到文件，再读取出来。

首先创建一个对象，并实现Serializable接口：

import java.io.Serializable;
public class User implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private int 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 "User [name=" + name + ", age=" + age + "]";
    }
}

用对象流写一个保存对象与读取对象的工具类：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializeUtil {
    // 保存对象，序列化
    public static void saveObject(Object object) throws Exception {
        ObjectOutputStream out = null;
        FileOutputStream fout = null;
        try {
            fout = new FileOutputStream("D:/1.txt");
            out = new ObjectOutputStream(fout);
            out.writeObject(object);
        } finally {
            fout.close();
            out.close();
        }
    }
    // 读取对象，反序列化
    public static Object readObject() throws Exception {
        ObjectInputStream in = null;
        FileInputStream fin = null;
        try {
            fin = new FileInputStream("D:/1.txt");
            in = new ObjectInputStream(fin);
            Object object = in.readObject();
            return object;
        } finally {
            fin.close();
            in.close();
        }
    }
}

测试：

public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setName("旭旭宝宝");
        user.setAge(33);
        // 保存
        try {
            SerializeUtil.saveObject(user);
        } catch (Exception e) {
            System.out.println("保存时异常：" + e.getMessage());
        }
        // 读取
        User userObject;
        try {
            userObject = (User) SerializeUtil.readObject();
            System.out.println(userObject);
        } catch (Exception e) {
            System.out.println("读取时异常：" + e.getMessage());
        }
    }
}

测试结果：

这里我们成功的进行了一次将对象保存到文件中，再读取了出来。如果此时，我们不实现序列化接口，就会出现异常了。我们取消实现的Serialiable接口代码：

public class User {
    private String name;
    private int 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 "User [name=" + name + ", age=" + age + "]";
    }
}

再测试Main方法：

可以看到此时报错了，此时使用 e.printStackTrace();查看异常的详细信息：

可以看到Unknown Source，因为没有进行序列化，所以无法进行保存与读取。

四、序列化ID的作用

可以看到，我们在进行序列化时，加了一个serialVersionUID字段，这便是序列化ID

java-api-doc-generator

分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。

下载

private static final long serialVersionUID = 1L;

这个序列化ID起着关键的作用，它决定着是否能够成功反序列化！java的序列化机制是通过判断运行时类的serialVersionUID来验证版本一致性的，在进行反序列化时，JVM会把传进来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。

即序列化ID是为了保证成功进行反序列化

五、默认的序列化ID

当我们一个实体类中没有显式的定义一个名为“serialVersionUID”、类型为long的变量时，Java序列化机制会根据编译时的class自动生成一个serialVersionUID作为序列化版本比较，这种情况下，只有同一次编译生成的class才会生成相同的serialVersionUID。譬如，当我们编写一个类时，随着时间的推移，我们因为需求改动，需要在本地类中添加其他的字段，这个时候再反序列化时便会出现serialVersionUID不一致，导致反序列化失败。那么如何解决呢？便是在本地类中添加一个“serialVersionUID”变量，值保持不变，便可以进行序列化和反序列化。

如果没有显示指定serialVersionUID，会自动生成一个。
只有同一次编译生成的class才会生成相同的serialVersionUID。
但是如果出现需求变动，Bean类发生改变，则会导致反序列化失败。为了不出现这类的问题，所以我们最好还是显式的指定一个
serialVersionUID。

六、序列化的其他问题

1、静态变量不会被序列化（ static,transient）

2、当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。

3、当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化。

子类序列化时：
如果父类没有实现Serializable接口，没有提供默认构造函数，那么子类的序列化会出错；
如果父类没有实现Serializable接口，提供了默认的构造函数，那么子类可以序列化，父类的成员变量不会被序列化。如果父类
实现了Serializable接口，则父类和子类都可以序列化。

七、使用效率更高的序列化框架—Protostuff

其实java的原生序列化方式（通过实现Serialiable接口），效率并不是最高的。

github上有一个分析序列化效率的项目：https://github.com/eishay/jvm-serializers/wiki

其中看的出来性能最优的为google开发的colfer ，但是由于colfer的使用难度太大，而更多的都是使用protostuff序列化框架。适用改框架要引入两个库（core与runtime）。

①github地址：https://github.com/protostuff/protostuff

③如果用Maven，则添加依赖：

<dependency>
  <groupid>io.protostuff</groupid>
  <artifactid>protostuff-core</artifactid>
  <version>1.5.9</version></dependency>

<dependency>
  <groupid>io.protostuff</groupid>
  <artifactid>protostuff-core</artifactid>
  <version>1.5.9</version></dependency>

修改Main代码

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setName("旭旭宝宝");
        user.setAge(33);
        Schema<user> schema = RuntimeSchema.getSchema(User.class);
        // 保存对象，序列化，转化二进制数据
        LinkedBuffer buffer = LinkedBuffer.allocate(512);
        final byte[] protostuff;
        try {
            protostuff = ProtobufIOUtil.toByteArray(user, schema, buffer);
        } finally {
            buffer.clear();
        }
        // 读取对象，反序列化
        User userObject = schema.newMessage();
        ProtostuffIOUtil.mergeFrom(protostuff, userObject, schema);
        System.out.println(userObject);
    }
}</user>

User类，并未实现Serializable接口

public class User {
    private String name;
    private int 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 "User [name=" + name + ", age=" + age + "]";
    }
}

测试结果：

若要要整合Redis使用，也可以写成一个工具类：

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
public class SerializeUtil {
    private static Map<class>, Schema>> cachedSchema = new ConcurrentHashMap();
    @SuppressWarnings("unchecked")
    public static <t> byte[] serializer(T obj) {
        Class<t> clazz = (Class<t>) obj.getClass();
        Schema<t> schema = getSchema(clazz);
        return ProtobufIOUtil.toByteArray(obj, schema, LinkedBuffer.allocate(256));
    }
    public static <t> T deSerializer(byte[] bytes, Class<t> clazz) {
        T message;
        try {
            message = clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        Schema<t> schema = getSchema(clazz);
        ProtobufIOUtil.mergeFrom(bytes, message, schema);
        return message;
    }
    @SuppressWarnings("unchecked")
    public static <t> Schema<t> getSchema(Class<t> clazz) {
        Schema<t> schema = (Schema<t>) cachedSchema.get(clazz);
        if (schema == null) {
            schema = RuntimeSchema.createFrom(clazz);
            if (schema != null) {
                cachedSchema.put(clazz, schema);
            }
        }
        return schema;
    }
}</t></t></t></t></t></t></t></t></t></t></t></t></class>

这样即使我们的User类就不用再实现Serialiable接口了，同样可以进行序列化，效率也更高。

php中文网，大量的免费Java入门教程，欢迎在线学习！