Java Object Serialisatie: Objecten Persisteren en Herstellen

Wat is Object Serialisatie?

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

Nadat een geserialiseerd object in een bestand is geschreven, kan het uit het bestand worden gelezen en gedeserialiseerd; dat wil zeggen, de type-informatie en bytes die het object en zijn data vertegenwoordigen, kunnen worden gebruikt om het object in het geheugen te herstellen.

Het meest indrukwekkende is dat het hele proces JVM-onafhankelijk is, wat betekent dat een object op het ene platform geserialiseerd kan worden en op een volledig ander platform gedeserialiseerd.

De klassen ObjectInputStream en ObjectOutputStream zijn high-level streams die de methodes bevatten voor het serialiseren en deserialiseren van een object.

De ObjectOutputStream-klasse bevat veel write-methodes voor het schrijven van diverse datatypen, maar één methode springt eruit:

public final void writeObject(Object x) throws IOException

Deze methode serialiseert een Object en stuurt het naar de output stream. Op dezelfde manier bevat de ObjectInputStream-klasse 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 retourwaarde is Object, dus je moet het casten naar het juiste datatype.

Voorwaarden voor Serialisatie

Om een klasse succesvol te serialiseren, moeten twee voorwaarden vervuld zijn:

• 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 gemarkeerd worden als transient.

Als je benieuwd bent of een Java Standard Class serialiseerbaar is, check de documentatie. De test is simpel: als de klasse java.io.Serializable implementeert, is het serialiseerbaar; anders niet.

Voorbeeld: Employee klasse

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

Een Object Serialiseren

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

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

Let op: Bij het serialiseren van een object naar een bestand, is de standaardconventie in Java om het bestand een .ser-extensie te geven.

Voorbeeld: SerializeDemo

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("Geserialiseerde data is opgeslagen in /tmp/employee.ser");
        } catch (IOException i) {
            i.printStackTrace();
        }
    }
}

Een Object Deserialiseren

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

Voorbeeld: DeserializeDemo

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("Gedeserialiseerd Employee...");
        System.out.println("Naam: " + e.name);
        System.out.println("Adres: " + e.address);
        System.out.println("SSN: " + e.SSN);
        System.out.println("Nummer: " + e.number);
    }
}

Resultaat:

Gedeserialiseerd Employee...
Naam: Reyan Ali
Adres: Phokka Kuan, Ambehta Peer
SSN: 0
Nummer: 101

Belangrijke Punten

• De try/catch-blok probeert een ClassNotFoundException te vangen, die gedeclareerd wordt door de readObject()-methode. Voor een JVM om een object te deserialiseren, moet het de bytecode voor de klasse kunnen vinden. Als de JVM geen klasse kan vinden tijdens deserialisatie, gooit het een ClassNotFoundException.
• Let op dat de retourwaarde van readObject() gecast wordt naar een Employee-referentie.
• De waarde van het SSN-veld was 11122333 toen het object geserialiseerd werd, maar omdat het veld transient is, werd deze waarde niet naar de output stream gestuurd. Het SSN-veld van het gedeserialiseerde Employee-object is 0.