How to serialize in java-Javagetting Started-php.cn

1. Serialization and Deserialization

Serialization: refers to the java object data in the heap memory. Store the pair in a disk file in some way, or pass it to other network nodes (network transmission). This process is called serialization, which usually refers to the process of converting a data structure or object into binary.

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

Copy after login

Deserialization: The process of restoring the object data in the disk file or the object data on the network node to the Java object model. That is, the process of converting the binary string generated during the serialization process into a data structure or object

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

Copy after login

2. The role of serialization

① Want to store memory When the objects in are saved to a file or database;

② When you want to use sockets to transmit objects on the network;

③ When you want to transmit objects through RMI

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

Copy after login

3. Java serialization implementation

To achieve serialization of objects, the most direct operation is to implement the Serializable interface

Use objects in the IO stream Streams can implement serialization operations, save objects to files, and then read them out.

First create an object and implement the Serializable interface:

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 + "]";
    }
}

Copy after login

Use object stream to write a tool class for saving and reading objects:

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();
        }
    }
}

Copy after login

Test:

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());
        }
    }
}

Copy after login

Test results:

How to serialize in java

Here we successfully saved the object to a file and then read it out. If we do not implement the serialization interface at this time, an exception will occur. We cancel the implemented Serialiable interface code:

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 + "]";
    }
}

Copy after login

Test the Main method again:

How to serialize in java

You can see that an error is reported at this time, use e.printStackTrace( );View the details of the exception:

How to serialize in java

You can see the Unknown Source. Because it is not serialized, it cannot be saved and read.

4. The role of serialization ID

As you can see, when we serialize, we add a serialVersionUID field, which is the serialization ID

private static final long serialVersionUID = 1L;

Copy after login

This serialization ID plays a key role, it determines whether deserialization can be successful! Java's serialization mechanism verifies version consistency by judging the serialVersionUID of the runtime class. During deserialization, the JVM will compare the serialVersionUID in the incoming byte stream with the serialVersionUID in the local entity class. If If they are the same, they are considered consistent and can be deserialized. Otherwise, an exception of inconsistent serialized versions will be reported.

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

Copy after login

5. Default serialization ID

When we do not explicitly define a variable named "serialVersionUID" and type long in an entity class , the Java serialization mechanism will automatically generate a serialVersionUID based on the compiled class as a serialization version comparison. In this case, only the classes generated by the same compilation will generate the same serialVersionUID. For example, when we write a class, as time goes by, we need to add other fields to the local class due to changes in requirements. At this time, serialVersionUID will be inconsistent during deserialization, causing deserialization to fail. So how to solve it? Just add a "serialVersionUID" variable to the local class, the value remains unchanged, and serialization and deserialization can be performed.

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

Copy after login

6. Other issues with serialization

1. Static variables will not be serialized (static, transient)

2. When a The parent class implements serialization, and the subclass automatically implements serialization. There is no need to explicitly implement the Serializable interface.

3. When the instance variables of an object refer to other objects, when the object is serialized, the referenced object is also serialized.

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

Copy after login

7. Use a more efficient serialization framework—Protostuff

In fact, Java’s native serialization method (by implementing the Serialiable interface) is not as efficient as Not the highest.

There is a project on github to analyze serialization efficiency: https://github.com/eishay/jvm-serializers/wiki

How to serialize in java

Watch it The one with the best performance is colfer developed by Google, but because colfer is too difficult to use, most people use the protostuff serialization framework. To apply the framework, two libraries (core and runtime) need to be introduced.

①github address: https://github.com/protostuff/protostuff

③If you use Maven, add dependencies:

<dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-core</artifactId>
  <version>1.5.9</version>
</dependency>

Copy after login

<dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-core</artifactId>
  <version>1.5.9</version>
</dependency>

Copy after login

Modify Main code

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);
    }
}

Copy after login

User class does not implement the Serializable interface

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 + "]";
    }
}

Copy after login

Test results:

How to serialize in java

若要要整合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;
    }
}

Copy after login

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

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

The above is the detailed content of How to serialize in java. For more information, please follow other related articles on the PHP Chinese website!