Java - Serialisatie

Java biedt een mechanisme, objectserialisatie genaamd, waarbij een object kan worden weergegeven als een reeks bytes die de gegevens van het object bevat, evenals informatie over het type object en de typen gegevens die in het object zijn opgeslagen.

Nadat een geserialiseerd object in een bestand is geschreven, kan het uit het bestand worden gelezen en gedeserialiseerd, dat wil zeggen dat de type-informatie en bytes die het object vertegenwoordigen en de gegevens ervan kunnen worden gebruikt om het object in het geheugen opnieuw te creëren.

Het meest indrukwekkend is dat het hele proces JVM-onafhankelijk is, wat betekent dat een object op één platform kan worden geserialiseerd en op een geheel ander platform kan worden gedeserialiseerd.

Klassen ObjectInputStream en ObjectOutputStream zijn streams op hoog niveau die de methoden bevatten voor het serialiseren en deserialiseren van een object.

De klasse ObjectOutputStream bevat veel schrijfmethoden voor het schrijven van verschillende gegevenstypen, maar één methode in het bijzonder springt eruit −

public final void writeObject(Object x) throws IOException

De bovenstaande methode serialiseert een object en stuurt het naar de uitvoerstroom. Evenzo bevat de klasse ObjectInputStream de volgende methode voor het deserialiseren van een object −

public final Object readObject() throws IOException, ClassNotFoundException

Deze methode haalt het volgende object uit de stream en deserialiseert het. De geretourneerde waarde is Object, dus u moet deze naar het juiste gegevenstype casten.

Om te demonstreren hoe serialisatie werkt in Java, ga ik de klasse Employee gebruiken die we eerder in het boek hebben besproken. Stel dat we de volgende klasse Employee hebben, die de Serializable-interface implementeert −

Voorbeeld

public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + name + " " + address);
   }
}

Merk op dat om een ​​klasse met succes te serialiseren, aan twee voorwaarden moet worden voldaan −

• De klasse moet de java.io.Serializable-interface implementeren.

• Alle velden in de klasse moeten serialiseerbaar zijn. Als een veld niet serialiseerbaar is, moet het worden gemarkeerd als transient .

Als je benieuwd bent of een Java Standard Class serializeerbaar is of niet, bekijk dan de documentatie bij de class. De test is eenvoudig:als de klasse java.io.Serializable implementeert, is het serializable; anders is het dat niet.

Serialiseren van een object

De klasse ObjectOutputStream wordt gebruikt om een ​​object te serialiseren. Het volgende SerializeDemo-programma start een Employee-object en serialiseert het naar een bestand.

Wanneer het programma klaar is met uitvoeren, wordt een bestand met de naam employee.ser gemaakt. Het programma genereert geen output, maar bestudeer de code en probeer te bepalen wat het programma doet.

Opmerking − Bij het serialiseren van een object naar een bestand, is de standaardconventie in Java om het bestand een .ser te geven extensie.

Voorbeeld

import java.io.*;
public class SerializeDemo {

   public static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

Deserialiseren van een object

Het volgende DeserializeDemo-programma deserialiseert het Employee-object dat in het SerializeDemo-programma is gemaakt. Bestudeer het programma en probeer de output te bepalen −

Voorbeeld

import java.io.*;
public class DeserializeDemo {

   public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i) {
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

Dit levert het volgende resultaat op −

Uitvoer

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

Hier volgen de volgende belangrijke punten om op te letten −

• Het try/catch-blok probeert een ClassNotFoundException te vangen, die wordt gedeclareerd door de methode readObject(). Om ervoor te zorgen dat een JVM een object kan deserialiseren, moet het de bytecode voor de klasse kunnen vinden. Als de JVM geen klasse kan vinden tijdens de deserialisatie van een object, genereert het een ClassNotFoundException.

• Merk op dat de retourwaarde van readObject() naar een werknemerreferentie wordt gegoten.

• De waarde van het SSN-veld was 11122333 toen het object werd geserialiseerd, maar omdat het veld van voorbijgaande aard is, is deze waarde niet naar de uitvoerstroom verzonden. Het BSN-veld van het gedeserialiseerde Employee-object is 0.