CKTIS / Java
Een Java-object serialiseren naar een byte-array
Schrijf een object naar een `byte[]` en herstel het uit vertrouwde bytes die hetzelfde programma heeft gemaakt. Zie waarom standaardserialisatie `transient`-velden weglaat.
Versie: Java SE 21
Syntax
Java SE 21 — java.io
ByteArrayOutputStream()
ObjectOutputStream(OutputStream out) throws IOException
void ObjectOutputStream.writeObject(Object obj) throws IOException
void ObjectOutputStream.flush() throws IOException
byte[] ByteArrayOutputStream.toByteArray()
ByteArrayInputStream(byte[] buf)
ObjectInputStream(InputStream in) throws IOException
Object ObjectInputStream.readObject() throws IOException, ClassNotFoundExceptionIn Java SE 21 kun je met de klassen uit java.io een object volledig in het geheugen schrijven en herstellen. De constructor van ObjectOutputStream schrijft de streamheader. writeObject(Object) serialiseert het object en de objectgraaf die bereikbaar is via de referenties die worden weggeschreven. Een parameter van het type Object garandeert niet dat dit lukt: als een te serialiseren object Serializable niet implementeert, kan NotSerializableException optreden.
Roep na writeObject(Object) de methode flush() aan om gebufferde bytes door te geven aan de onderliggende stream zonder die te sluiten. Daarna retourneert ByteArrayOutputStream.toByteArray() een nieuwe byte[] met een kopie van alleen de geschreven bytes. De aanroep geeft geen toegang tot de interne buffer en leegt de buffer van de objectstream niet. ByteArrayInputStream(byte[]) gebruikt die array zonder deze te kopiëren.
De constructor van ObjectInputStream leest de header. readObject() herstelt het object en retourneert het als Object; de cast naar Profile controleert het verwachte type pas na deserialisatie. Lees opeenvolgende waarden in de volgorde waarin ze zijn geschreven en met de bijbehorende typen. Streambewerkingen kunnen IOException opleveren; bij het lezen kan ook ClassNotFoundException optreden als een vereiste klasse ontbreekt. De try-with-resources-blokken sluiten de objectstreams.
Standaardserialisatie laat static- en transient-velden weg. Bij het herstellen van een gewone serialiseerbare klasse worden de constructor en veldinitialisaties niet uitgevoerd. Daardoor krijgt cache de standaardwaarde null in plaats van warm. Als de waarden van serialVersionUID gelijk moeten zijn, leidt een verschil tot InvalidClassException. Die eis geldt niet voor array- en recordklassen. Een gelijke ID maakt niet elke klassewijziging compatibel. Dit is geen taalonafhankelijk uitwisselingsformaat. Deserialiseer geen onvertrouwde gegevens: het voorbeeld leest alleen bytes die hetzelfde programma lokaal heeft aangemaakt.
Voorbeelden
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serial;
import java.io.Serializable;
public class SerializationRoundTrip {
private static final class Profile implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
private final String name;
private transient String cache = "warm";
private Profile(String name) {
this.name = name;
}
}
public static void main(String[] args)
throws IOException, ClassNotFoundException {
Profile original = new Profile("Ada");
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
byte[] bytes;
try (ObjectOutputStream out = new ObjectOutputStream(buffer)) {
out.writeObject(original);
out.flush();
bytes = buffer.toByteArray();
}
Profile restored;
try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
restored = (Profile) in.readObject();
}
System.out.println("before: " + original.name + ", cache=" + original.cache);
System.out.println("after: " + restored.name + ", cache=" + restored.cache);
}
}Resultaat
before: Ada, cache=warm after: Ada, cache=null
Vergelijk `before` en `after`: `name` blijft `Ada`, maar `cache` is `warm` in het origineel en `null` in het herstelde object.
Gerelateerde lessen
- Java · Les 52 · Gevorderd · Versie: 2
Bronnen
- ObjectOutputStream (Java SE 21 & JDK 21)
- ByteArrayOutputStream (Java SE 21 & JDK 21)
- ByteArrayInputStream (Java SE 21 & JDK 21)
- ObjectInputStream (Java SE 21 & JDK 21)
- Serializable (Java SE 21 & JDK 21)
- Java Object Serialization Specification: 3 - Object Input Classes
- Java Object Serialization Specification: 5 - Versioning of Serializable Objects