Page d'accueil>Tutoriel de programmation réseau>Tutoriel Java

Analyse approfondie du mécanisme et des principes de sérialisation Java

Auteur：Eve Cole Date de mise à jour：2024-11-24 10:48:02

Analyse de l'algorithme de sérialisation Java

La sérialisation est un processus de description d'un objet comme une série d'octets ; la désérialisation est un processus de reconstruction de ces octets en un objet. L'API Java Serialization fournit un mécanisme standard pour gérer la sérialisation des objets. Ici, vous pouvez apprendre comment sérialiser un objet, lorsque la sérialisation est requise, et l'algorithme de sérialisation Java. Nous utilisons un exemple pour démontrer comment les octets après la sérialisation décrivent les informations d'un objet.
Le besoin de sérialisation

En Java, tout est objet. Dans un environnement distribué, il est souvent nécessaire de transférer des objets d'un réseau ou d'un appareil à l'autre. Cela nécessite un protocole capable de transmettre des données aux deux extrémités. Le mécanisme de sérialisation Java a été créé pour résoudre ce problème.
Comment sérialiser un objet

La condition préalable pour qu'un objet soit sérialisable est d'implémenter l'interface Serialisable. L'interface Serialisable n'a pas de méthodes et ressemble plus à un marqueur. Les classes avec cette balise peuvent être traitées par le mécanisme de sérialisation.

Copiez le code comme suit :

importer java.io.Serialisisable ;
la classe TestSerial implémente Serialisable {
version d'octet public = 100 ;
nombre d'octets publics = 0 ;
}

Ensuite, nous écrivons un programme pour sérialiser l'objet et le sortir. ObjectOutputStream peut générer un objet dans un flux d'octets. Nous stockons temporairement le flux d'octets dans le fichier temp.out.
Copiez le code comme suit :

public static void main (String args []) lance IOException {
FileOutputStream fos = new FileOutputStream("temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
TestSerial ts = new TestSerial();
oos.writeObject(ts);
oos.flush();
oos.close();
}

Si vous souhaitez lire les octets d'un fichier persistant pour reconstruire l'objet, nous pouvons utiliser ObjectInputStream.
Copiez le code comme suit :

public static void main (String args []) lance IOException {
FileInputStream fis = new FileInputStream("temp.out");
ObjectInputStream oin = new ObjectInputStream(fis);
TestSerial ts = (TestSerial) oin.readObject();
System.out.println("version="+ts.version);
}

Le résultat de l'exécution est

100.
Le format de sérialisation de l'objet

À quoi ressemble un objet une fois sérialisé ? Ouvrez le fichier temp.out que nous venons de sérialiser et de sortir l'objet, et affichez-le en hexadécimal. Le contenu doit être le suivant :

Copiez le code comme suit :

CA ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 65

73 74 A0 0C 34 00 FE B1 DD F9 02 00 02 42 00 05

63 6F 75 6E 74 42 00 07 76 65 72 73 69 6F 6E 78

70 00 64


Ce tas d'octets est utilisé pour décrire l'objet TestSerial après sérialisation. Nous avons remarqué qu'il n'y a que deux champs dans la classe TestSerial :

version d'octet public = 100 ;

nombre d'octets publics = 0 ;

Les deux sont de type octet. En théorie, seuls 2 octets sont nécessaires pour stocker ces deux champs, mais en réalité temp.out occupe 51 octets, ce qui signifie qu'en plus des données, il inclut également d'autres descriptions de l'objet sérialisé.
Algorithme de sérialisation Java

L'algorithme de sérialisation effectue généralement les étapes suivantes :

◆Métadonnées de classe de sortie liées aux instances d'objet.

◆Affiche de manière récursive la description de la classe jusqu'à ce qu'il n'y ait plus de superclasses.

◆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.

◆ Afficher de manière récursive les données d'instance de haut en bas

Illustrons avec un autre exemple qui couvre plus complètement toutes les situations possibles :

Copiez le code comme suit :

le parent de classe implémente Serialisable {
int parentVersion = 10 ;
}

la classe contient des implémentations sérialisables{
int contientVersion = 11;
}

la classe publique SerialTest étend les implémentations parentes Serialisable {
version entière = 66 ;
contenir con = nouveau contenir();
public int getVersion() {
version de retour ;
}
public static void main (String args []) lance IOException {
FileOutputStream fos = new FileOutputStream("temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
SerialTest st = new SerialTest();
oos.writeObject(st);
oos.flush();
oos.close();
}
}


Cet exemple est assez simple. La classe SerialTest implémente la superclasse Parent et contient également un objet Container en interne.

Le format sérialisé est le suivant :

CA ED 00 05 7372 00 0A 53 65 72 69 61 6C 54 65

73 74 05 52 81 5A CA 66 02 F6 02 00 0249 00 07

76 65 72 73 69 6F 6E4C00 03 63 6F 6E74 00 09

4C63 6F 6E 74 61 69 6E 3B 7872 00 06 70 61 72

65 6E 74 0E DB D2 BD 85 EE 63 7A 02 00 0149 00

0D 70 61 72 65 6E 74 56 65 72 73 69 6F 6E 78 70

0000000A 0000004273 72 00 07 63 6F 6E 74

61 69 6E FC BB E6 0E FB CB 60 C7 02 00 0149 00

0E 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E 78

700000000B

Examinons de plus près ce que représentent ces octets. Pour commencer, voir couleur :

  1. AC ED : STREAM_MAGIC. Déclare que le protocole de sérialisation est utilisé.
  2. 00 05 : STREAM_VERSION version du protocole de sérialisation.
  3. 0x73 : TC_OBJECT. Déclarez qu'il s'agit d'un nouvel objet.

La première étape de l'algorithme de sérialisation consiste à générer une description de la classe associée à l'objet. L'objet affiché dans l'exemple est une instance de la classe SerialTest, donc la description de la classe SerialTest est affichée ensuite. Voir les couleurs :

  1. 0x72 : TC_CLASSDESC. Déclarez une nouvelle classe pour commencer ici.
  2. 00 0A : La longueur du nom de la classe.
  3. 53 65 72 69 61 6c 54 65 73 74 : SerialTest, nom de classe.
  4. 05 52 81 5A AC 66 02 F6 : SerialVersionUID, ID de sérialisation S'il n'est pas spécifié, un ID de 8 octets sera généré aléatoirement par l'algorithme.
  5. 0x02 : numéro de balise. Cette valeur déclare que l'objet prend en charge la sérialisation.
  6. 00 02 : Le nombre de domaines inclus dans cette classe.

Ensuite, l'algorithme génère l'un des champs, inversion=66, voir couleur :

  1. 0x49 : le type de champ 49 représente "I", qui est Int.
  2. 00 07 : La longueur du nom de domaine.
  3. 76 65 72 73 69 6F 6E : version, description du nom de domaine.

Ensuite, l'algorithme génère le domaine suivant, contain con = new contain(); c'est un peu spécial, c'est un objet. Lors de la description des références de type d'objet, vous devez utiliser la notation de signature d'objet standard de la JVM, voir couleur :

  1. 0x4C : Type de domaine.
  2. 00 03 : Longueur du nom de domaine.
  3. 63 6F 6E : Description du nom de domaine, con
  4. 0x74 : TC_STRING Représente une nouvelle chaîne. Utilisez String pour référencer l'objet.
  5. 00 09 : La longueur de la chaîne.
  6. 4C 63 6F 6E 74 61 69 6E 3B:Lcontain;, la notation de signature d'objet standard de la JVM.
  7. 0x78 : TC_ENDBLOCKDATA, signe de fin du bloc de données objet

.Ensuite, l'algorithme affichera la description de la super classe, qui est la classe Parent. Voir la couleur :

  1. 0x72 : TC_CLASSDESC. Déclarez qu'il s'agit d'une nouvelle classe.
  2. 00 06 : longueur du nom de classe.
  3. 70 61 72 65 6E 74 : parent, description du nom de classe.
  4. 0E DB D2 BD 85 EE 63 7A:SerialVersionUID, ID de sérialisation.
  5. 0x02 : numéro de balise. Cette valeur déclare que l'objet prend en charge la sérialisation.
  6. 00 01 : Le nombre de champs dans la classe.

Ensuite, affichez la description du domaine de la classe parent, intparentVersion=100, voir aussi color :

  1. 0x49 : le type de champ 49 représente "I", qui est Int.
  2. 00 0D : Longueur du nom de domaine.
  3. 70 61 72 65 6E 74 56 65 72 73 69 6F 6E : parentVersion, description du nom de domaine.
  4. 0x78 : TC_ENDBLOCKDATA, signe de fin du bloc objet.
  5. 0x70 : TC_NULL, indiquant qu'il n'y a pas d'autre indicateur de super classe. .

Jusqu’à présent, l’algorithme a généré les descriptions de toutes les classes. L'étape suivante consiste à afficher la valeur réelle de l'objet instance. À ce stade, il part du domaine de la classe parent, voir couleur :

  1. 0000000A : 10, la valeur du champ parentVersion.

Il existe également des champs de la classe SerialTest :

  1. 00000042 : 66, la valeur du champ version.

Les octets qui suivent sont plus intéressants. L'algorithme doit décrire les informations de la classe contain. N'oubliez pas que la classe contain n'a pas encore été décrite.

  1. 0x73 : TC_OBJECT, déclare qu'il s'agit d'un nouvel objet.
  2. 0x72 : TC_CLASSDESC déclare une nouvelle classe à commencer ici.
  3. 00 07 : la longueur du nom de la classe.
  4. 63 6F 6E 74 61 69 6E : contient, description du nom de classe.
  5. FC BB E6 0E FB CB 60 C7:SerialVersionUID, ID de sérialisation.
  6. 0x02 : Divers indicateurs. Numéro de balise. Cette valeur déclare que l'objet prend en charge la sérialisation.
  7. 00 01 : Nombre de domaines au sein de la classe.

.Affichez la description de domaine unique de contain, intcontainVersion=11 ;

  1. 0x49 : le type de domaine 49 représente "I", qui est Int.
  2. 00 0E : Longueur du nom de domaine.
  3. 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E : containVersion, description du nom de domaine.
  4. 0x78 : indicateur de fin de bloc d'objet TC_ENDBLOCKDATA.

À ce stade, l'algorithme de sérialisation vérifiera si contain a une superclasse, et si c'est le cas, il la générera.

  1. 0x70 : TC_NULL, il n'y a pas de super classe.

Enfin, la valeur de domaine réelle de la classe contain est affichée.

  1. 0000000B : 11, la valeur de containVersion.

OK, nous avons discuté du mécanisme et des principes de la sérialisation Java, et nous espérons que cela sera utile aux étudiants.

Articles connexes