Sérialisation des objets JavaNIO NIO2Explication détaillée

Introduction détaillée et analyse de la sérialisation d'objets Java NIO NIO2

Résumé :

Sérialisation d'objets

Le mécanisme de sérialisation des objets permet de convertir les objets Java en mémoire en flux binaires indépendants de la plate-forme, qui peuvent être enregistrés sur disque ou transmis sur le réseau. D'autres programmes peuvent restaurer le flux binaire à son état d'origine après obtention. il. Le mécanisme de sérialisation permet aux objets d'exister indépendamment de l'exécution du programme

Le sens et la signification de la sérialisation

Sérialisation

Le mécanisme de sérialisation peut permettre l'objet doit exister indépendamment de l'exécution du programme

La sérialisation (Serialize) fait référence à l'écriture d'un objet Java dans le flux IO. De manière correspondante, la désérialisation (Deserialize) de l'objet fait référence à sa désérialisation à partir du flux IO. .Restaurez l'objet Java dans le flux

Si vous devez faire en sorte qu'un objet prenne en charge le mécanisme de sérialisation, sa classe doit être sérialisable. Afin de rendre une classe sérialisable, vous devez implémenter l'une des deux interfaces suivantes. :

• Sérialisable : L'implémentation de cette interface ne nécessite pas d'implémenter de méthodes, elle indique simplement que les instances de cette classe sont sérialisables

• Externalisable
  

Tous les objets transmis sur le réseau doivent être sérialisables, sinon une exception se produira ; tous les objets qui doivent être enregistrés sur le disque doivent être sérialisables pour chaque classe JavaBean ; créé par le programme implémente Serialisable ;

Utiliser le flux d'objets pour implémenter la sérialisation

Une classe qui implémente Serialisable pour implémenter la sérialisation, Le programme peut sérialiser l'objet via les deux éléments suivants étapes :

1. Créer un ObjectOutputStream. Ce flux de sortie est un flux de traitement, il doit donc être construit sur la base d'autres flux de nœuds

// 创建个ObjectOutputStream输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

2. Appelez la méthode writeObject de l'objet ObjectOutputStream pour générer l'objet sérialisable

// 将一个Person对象输出到输出流中
oos.writeObject(per);

Définition Une classe NbaPlayer qui implémente l'interface Serialisable. , qui identifie les objets de cette classe comme sérialisables

public class NbaPlayer implements java.io.Serializable
{
  private String name;
  private int number;
  // 注意此处没有提供无参数的构造器!
  public NbaPlayer(String name, int number)
  {
    System.out.println("有参数的构造器");
    this.name = name;
    this.number = number;
  }

  // name的setter和getter方法
  public void setName(String name)
  {
    this.name = name;
  }
  public String getName()
  {
    return this.name;
  }

  // number的setter和getter方法
  public void setNumber(int number)
  {
    this.number = number;
  }
  public int getNumber()
  {
    return this.number;
  }
}

Utilisez ObjectOutputStream pour écrire un objet NbaPlayer sur le fichier disque

import java.io.*;

public class WriteObject
{
  public static void main(String[] args)
  {
    try(
      // 创建一个ObjectOutputStream输出流
      ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("object.txt")))
    {
      NbaPlayer player = new NbaPlayer("维斯布鲁克", 0);
      // 将player对象写入输出流
      oos.writeObject(player);
    }
    catch (IOException ex)
    {
      ex.printStackTrace();
    }
  }
}

Désérialisation

Pour récupérer des objets Java à partir d'un flux binaire, vous devez utiliser la désérialisation, le programme peut sérialiser l'objet à travers les deux suivants étapes :

1. Créer un flux d'entrée ObjectInputStream. Ce flux d'entrée est un flux de traitement, il doit donc être construit sur la base d'autres flux de nœuds

// 创建个ObjectInputStream输出流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));

<🎜. >

2. Appelez la méthode readObject() de l'objet ObjectInputStream pour lire les objets dans le flux. Cette méthode renvoie un objet Java de type Object, qui peut être forcé à taper dans son vrai type<. 🎜>

// 从输入流中读取一个Java对象，并将其强制类型转换为Person类
Person p = (Person)ois.readObject();

Étapes pour lire l'objet NbaPlayer à partir du fichier object.txt

import java.io.*;
public class ReadObject
{
  public static void main(String[] args)
  {
    try(
      // 创建一个ObjectInputStream输入流
      ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("object.txt")))
    {
      // 从输入流中读取一个Java对象，并将其强制类型转换为NbaPlayer类
      NbaPlayer player = (NbaPlayer)ois.readObject();
      System.out.println("名字为：" + player.getName()
        + "\n号码为：" + player.getNumber());
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

La désérialisation lit uniquement les données des objets Java, pas les classes Java. Par conséquent, lorsque vous utilisez la désérialisation pour restaurer des objets Java, vous devez fournir le fichier de classe auquel l'objet Java appartient, sinon cela provoquera une exception ClassNotFoundException ; pour initialiser l'objet Java via le constructeur

Si plusieurs objets Java sont écrits dans le fichier à l'aide du mécanisme de sérialisation, le mécanisme de désérialisation doit être utilisé pour restaurer l'objet en fonction de la lecture réelle écrite de manière séquentielle. Lorsqu'une classe sérialisable a plusieurs classes parentes (y compris des classes parentes directes et des classes parentes indirectes), ces classes parentes ont soit des constructeurs sans argument, soit sont également sérialisables - sinon la désérialisation lèvera une InvalidClassException . Si la classe parent n'est pas sérialisable et n'a qu'un constructeur sans paramètre, la valeur Field définie par la classe parent ne sera pas sérialisée dans le flux binaire

Sérialisation de la référence d'objet

Si le type Field d'une classe n'est pas un type basique ou un type String, mais un autre type référence, alors ce type référence doit être sérialisable, sinon la classe qui utilise Field de ce type ne peut pas être sérialisée

public class AllStar implements java.io.Serializable
{
  private String name;
  private NbaPlayer player;
  public AllStar(String name, NbaPlayer player)
  {
    this.name = name;
    this.player = player;
  }
  // 此处省略了name和player的setter和getter方法

  // name的setter和getter方法
  public String getName()
  {
    return this.name;
  }

  public void setName(String name)
  {
    this.name = name;
  }

  // player的setter和getter方法
  public NbaPlayer getPlayer() 
  {
    return player;
  }

  public void setPlayer(NbaPlayer player) 
  {
    this.player = player;
  }
}

Algorithme de sérialisation spécial Java

Tous les objets enregistrés sur le disque ont un numéro de sérialisation
Lorsque le programme tente de sérialiser un objet, le programme vérifiera d'abord si l'objet a été sérialisé, seulement si l'objet n'a jamais été sérialisé (dans cette machine virtuelle) a été sérialisé, le système convertira le objet dans une séquence d'octets et en sortie
Si un objet a été sérialisé, le programme affichera simplement directement un numéro de sérialisation au lieu de resérialiser à nouveau l'objet

• 
  

import java.io.*;
public class WriteAllStar
{
  public static void main(String[] args)
  {
    try(
      // 创建一个ObjectOutputStream输出流
      ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("allStar.txt")))
    {
      NbaPlayer player = new NbaPlayer("詹姆斯哈登", 13);
      AllStar allStar1 = new AllStar("西部全明星", player);
      AllStar allStar2 = new AllStar("首发后卫", player);
      // 依次将四个对象写入输出流
      oos.writeObject(allStar1);
      oos.writeObject(allStar2);
      oos.writeObject(player);
      oos.writeObject(allStar2);
    }
    catch (IOException ex)
    {
      ex.printStackTrace();
    }
  }
}

4 sorties d'écriture Il n'y a en fait que trois objets de flux sérialisés, et les références de joueur des deux objets AllStar dans la séquence sont en fait les mêmes NbaPlayer objet. Le programme suivant lit les objets dans un fichier sérialisé

import java.io.*;
public class ReadAllStar
{
  public static void main(String[] args)
  {
    try(
      // 创建一个ObjectInputStream输出流
      ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("allStar.txt")))
    {
      // 依次读取ObjectInputStream输入流中的四个对象
      AllStar star1 = (AllStar)ois.readObject();
      AllStar star2 = (AllStar)ois.readObject();
      NbaPlayer player = (NbaPlayer)ois.readObject();
      AllStar star3 = (AllStar)ois.readObject();
      // 输出true
      System.out.println("star1的player引用和player是否相同："
        + (star1.getPlayer() == player));
      // 输出true
      System.out.println("star2的player引用和player是否相同："
        + (star2.getPlayer() == player));
      // 输出true
      System.out.println("star2和star3是否是同一个对象："
        + (star2 == star3));
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

Si le même objet Java mutable est sérialisé plusieurs fois, seule la première fois est sérialisée. l'objet Java soit converti en une séquence d'octets et affiché

当使用Java序列化机制序列化可变对象时，只有第一次调用WriteObject()方法来输出对象时才会将对象转换成字节序列，并写入到ObjectOutputStream；即使在后面程序中，该对象的实例变量发生了改变，再次调用WriteObject()方法输出该对象时，改变后的实例变量也不会被输出

import java.io.*;

public class SerializeMutable
{
  public static void main(String[] args)
  {

    try(
      // 创建一个ObjectOutputStream输入流
      ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("mutable.txt"));
      // 创建一个ObjectInputStream输入流
      ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("mutable.txt")))
    {
      NbaPlayer player = new NbaPlayer("斯蒂芬库里", 30);
      // 系统会player对象转换字节序列并输出
      oos.writeObject(player);
      // 改变per对象的name实例变量
      player.setName("塞斯库里");
      // 系统只是输出序列化编号，所以改变后的name不会被序列化
      oos.writeObject(player);
      NbaPlayer player1 = (NbaPlayer)ois.readObject();  //①
      NbaPlayer player2 = (NbaPlayer)ois.readObject();  //②
      // 下面输出true，即反序列化后player1等于player2
      System.out.println(player1 == player2);
      // 下面依然看到输出"斯蒂芬库里"，即改变后的实例变量没有被序列化
      System.out.println(player2.getName());
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

更多Java 对象序列化 NIO NIO2详解相关文章请关注PHP中文网！