java如何序列化

一、序列化與反序列化

序列化：指堆記憶體中的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

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類，並未實作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;
    }
}

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

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

以上是java如何序列化的詳細內容。更多資訊請關注PHP中文網其他相關文章！