Maison  >  Article  >  Java  >  Que sont la sérialisation et la désérialisation Java ? Méthodes d'implémentation de la sérialisation et de la désérialisation Java

Que sont la sérialisation et la désérialisation Java ? Méthodes d'implémentation de la sérialisation et de la désérialisation Java

不言
不言avant
2018-10-13 14:55:573302parcourir

Cet article vous explique qu'est-ce que la sérialisation et la désérialisation Java ? Les méthodes d'implémentation de la sérialisation et de la désérialisation Java ont une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

La sérialisation et la désérialisation sont un point de connaissance relativement basique en Java, mais je pense que beaucoup de gens ne peuvent comprendre que quelques phrases, voire ne les comprennent pas si vous creusez plus profondément et demandez comment l'implémenter. La sérialisation et la désérialisation Java peuvent être écrasantes ! Je ne sais pas comment expliquer, qu'est-ce que la sérialisation, qu'est-ce que la désérialisation, dans quels scénarios sera-t-elle utilisée, etc. L'intervieweur a dit : Savez-vous comment la sérialisation et la désérialisation sous-jacentes sont mises en œuvre ? Discutons de quelques éléments concernant la sérialisation et la désérialisation.

Tout d'abord, nous devons clarifier les choses conceptuelles, que sont la sérialisation et la désérialisation :

Java est le processus de conversion d'objets Java en séquences d'octets, et la désérialisation Java fait référence au processus de restaurer une séquence d'octets dans un objet Java.

Sérialisation : La fonction principale de la sérialisation des objets est de garantir l'intégrité et la délivrabilité des objets lors du transfert et de la sauvegarde des objets. La sérialisation consiste à convertir un objet en un flux d'octets ordonné pour la transmission sur le réseau ou l'enregistrement dans un fichier local. Le flux d'octets sérialisé enregistre l'état de l'objet Java et les informations de description associées. La fonction principale du mécanisme de sérialisation est la préservation et la reconstruction de l'état de l'objet.

Désérialisation : une fois que le client a obtenu le flux d'octets de l'objet sérialisé à partir du fichier ou du réseau, il reconstruit l'objet par désérialisation en fonction de l'état de l'objet et des informations de description enregistrées dans le flux d'octets.

Essentiellement, la sérialisation consiste à écrire l'état de l'objet entité dans un flux d'octets ordonnés dans un certain format, et la désérialisation consiste à reconstruire l'objet à partir du flux d'octets ordonnés et à restaurer l'état de l'objet. C'est similaire au concept de compression et de décompression de fichiers.

Pourquoi la sérialisation et la désérialisation sont nécessaires : ​​

Nous savons que lorsque les processus communiquent à distance, ils peuvent s'envoyer différents types de données, notamment du texte, des images, de l'audio, de la vidéo, etc. , et ces données seront transmises sur le réseau sous forme de séquences binaires.

Alors, lorsque deux processus Java communiquent, le transfert d'objets entre processus peut-il être réalisé ? La réponse est oui, alors comment faire ? Cela nécessite une sérialisation et une désérialisation Java

En d'autres termes : l'expéditeur doit convertir cet objet Java en une séquence d'octets puis le transmettre sur le réseau, tandis que le destinataire doit convertir la séquence d'octets en ; une séquence d'octets. Récupérez des objets Java à partir d'une séquence de sections.

Après avoir compris pourquoi la sérialisation et la désérialisation Java sont nécessaires, nous réfléchissons naturellement aux avantages de la sérialisation Java.

Tout d'abord, la persistance des données est obtenue. Les données peuvent être enregistrées de manière permanente sur le disque dur via la sérialisation (généralement stockée dans un fichier).

La seconde consiste à utiliser la sérialisation pour réaliser une communication à distance, c'est-à-dire pour transmettre la séquence d'octets des objets sur le réseau.

En général, cela peut être résumé comme suit :

(1) Enregistrez définitivement l'objet et enregistrez la séquence d'octets de l'objet dans un fichier local ou une base de données
( 2) Les objets sont transmis et reçus dans le réseau sous forme de flux d'octets via la sérialisation
(3) Les objets sont transférés entre les processus via la sérialisation

L'algorithme de sérialisation effectue généralement les choses suivantes étape par étape ; :

(1) Afficher les métadonnées de classe liées à l'instance d'objet.
(2) Afficher récursivement la description de la superclasse de la classe jusqu'à ce qu'il n'y ait plus de superclasses.
(3) Une fois les métadonnées de classe terminées, les valeurs de données réelles de l'instance d'objet sont sorties à partir de la superclasse de niveau supérieur.
(4) Générer de manière récursive les données d'instance de haut en bas

Alors, comment implémenter la sérialisation et la désérialisation en Java ?

1 : API de sérialisation et de désérialisation dans la bibliothèque de classes JDK

(1) java.io.ObjectOutputStream : représente le flux de sortie de l'objet

sa méthode writeObject(Object obj) ; peut sérialiser l'objet obj spécifié par le paramètre et écrire la séquence d'octets obtenue dans un flux de sortie cible

(2) java.io.ObjectInputStream : représente le flux d'entrée de l'objet

Son readObject ; () lit les séquences d'octets du flux d'entrée source, les désérialise en un objet et le renvoie

2 : Conditions requises pour l'implémentation de la sérialisation

Uniquement les objets des classes qui implémentent le sérialisable ou l'externalisable ; l'interface peut être sérialisée, sinon une exception sera levée !

Trois : méthodes pour implémenter la sérialisation et la désérialisation des objets Java

Supposons qu'une classe User, dont les objets doivent être sérialisés, puisse avoir les trois méthodes suivantes :

(1) Si la classe User implémente uniquement l'interface Serialisable, elle peut être sérialisée et désérialisée des manières suivantes

ObjectOutputStream utilise la méthode de sérialisation par défaut pour sérialiser les variables d'instance non transitoires de l'objet User .
ObjcetInputStream utilise la méthode de désérialisation par défaut pour désérialiser les variables d'instance non transitoires de l'objet User.

(2) Si la classe User implémente uniquement l'interface Serialisable et définit également readObject (ObjectInputStream in) et writeObject (ObjectOutputSteam out), les méthodes suivantes sont utilisées pour la sérialisation et la désérialisation.

ObjectOutputStream调用User对象的writeObject(ObjectOutputStream out)的方法进行序列化。 
ObjectInputStream会调用User对象的readObject(ObjectInputStream in)的方法进行反序列化。

(3)若User类实现了Externalnalizable接口,且User类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法,则按照以下方式进行序列化与反序列化。

ObjectOutputStream调用User对象的writeExternal(ObjectOutput out))的方法进行序列化。 
ObjectInputStream会调用User对象的readExternal(ObjectInput in)的方法进行反序列化。

四 :JDK类库中序列化的步骤

1  . 创建一个对象输出流,可以包装一个其它类型的目标输出流,如文件输出流:

ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("D:\\os.out"));

2  . 通过对象输出流的writeObject()方法写对象:

os.writeObject(new User("zhangsan", "123456", "male"));

五  : JDK类库中反序列化的步骤

1  . 创建一个对象输入流,它可以包装一个其它类型输入流,如文件输入流:

ObjectInputStream ois= new ObjectInputStream(new FileInputStream("object.out"));

2  .通过对象输出流的readObject()方法读取对象:

User user = (User) ois.readObject();

为保证正确读取数据,完成反序列化,必须保证向对象输出流写对象的顺序与从对象输入流中读对象的顺序一致。

举个栗子:

public class SerialDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化
        FileOutputStream outputos = new FileOutputStream("object.out");
        ObjectOutputStream oos = new ObjectOutputStream(outputos );
        User user1 = new User("zhangsan", "123456", "male");
        oos.writeObject(user1);
        oos.flush();
        oos.close();
        //反序列化
        FileInputStream inputos= new FileInputStream("object.out");
        ObjectInputStream ois = new ObjectInputStream(inputos);
        User user2 = (User) ois.readObject();
        System.out.println(user2.getUserName()+ " " + 
            user2.getPassword() + " " + user2.getSex());
        //反序列化的输出结果为:zhangsan123456 male
    }
}

public class User implements Serializable {
    private String userName;
    private String password;
    private String sex;
    //全参构造方法、get和set方法
}

  

相关的注意事项:

1、序列化时,只对对象的状态进行保存,而不管对象的方法;

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

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

4、并非所有的对象都可以序列化,至于为什么不可以,有很多原因了,比如:

安全方面的原因,比如一个对象拥有private,public等field,对于一个要传输的对象,比如写到文件,或者进行RMI传输等等,在序列化进行传输的过程中,这个对象的private等域是不受保护的;

资源分配方面的原因,比如socket,thread类,如果可以序列化,进行传输或者保存,也无法对他们进行重新的资源分配,而且,也是没有必要这样实现;

5、声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态,transient代表对象的临时数据。

6、序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联,该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。为它赋予明确的值。显式地定义serialVersionUID有两种用途:

在某些场合,希望类的不同版本对序列化兼容,因此需要确保类的不同版本具有相同的serialVersionUID;

在某些场合,不希望类的不同版本对序列化兼容,因此需要确保类的不同版本具有不同的serialVersionUID。

7、Java有很多基础类已经实现了serializable接口,比如String,Vector等。但是也有一些没有实现serializable接口的;

8、如果一个对象的成员变量是一个对象,那么这个对象的数据成员也会被保存!这是能用序列化解决深拷贝的重要原因;

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration:
Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer