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.

即將對象轉(zhuǎn)化為二進(jìn)制，用于保存，或者網(wǎng)絡(luò)傳輸。

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

與序列化相反，將二進(jìn)制轉(zhuǎn)化成對象。

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

一些應(yīng)用場景，涉及到將對象轉(zhuǎn)化成二進(jìn)制，序列化保證了能夠成功讀取到保存的對象。

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

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

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

Test results:

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

Test the Main method again:

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

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;

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是為了保證成功進(jìn)行反序列化

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。
但是如果出現(xiàn)需求變動，Bean類發(fā)生改變，則會導(dǎo)致反序列化失敗。為了不出現(xiàn)這類的問題，所以我們最好還是顯式的指定一個
serialVersionUID。

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.

子類序列化時：
如果父類沒有實現(xiàn)Serializable接口，沒有提供默認(rèn)構(gòu)造函數(shù)，那么子類的序列化會出錯；
如果父類沒有實現(xiàn)Serializable接口，提供了默認(rèn)的構(gòu)造函數(shù)，那么子類可以序列化，父類的成員變量不會被序列化。如果父類
實現(xiàn)了Serializable接口，則父類和子類都可以序列化。

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

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>

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

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);
        // 保存對象，序列化，轉(zhuǎn)化二進(jìn)制數(shù)據(jù)
        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 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 + "]";
    }
}

Test results:

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

這樣即使我們的User類就不用再實現(xiàn)Serialiable接口了，同樣可以進(jìn)行序列化，效率也更高。

php中文網(wǎng)，大量的免費(fèi)Java入門教程，歡迎在線學(xué)習(xí)！

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!