Java einfach erklärt

Plain Java

Serialisierung von Objekten in Java

Die Serialisierung ist ein essenzielles Konzept in der Java-Programmierung, das die Umwandlung von Objekten in ein übertragbares oder speicherbares Format ermöglicht. Dies ist insbesondere für verteilte Systeme, Datenbankpersistenz und Caching von Bedeutung. In diesem Artikel werden verschiedene Methoden zur Serialisierung in Java untersucht, darunter die Bordmittel des JDK sowie populäre Drittanbieter-Bibliotheken. Zudem werden deren Vor- und Nachteile sowie Unterschiede detailliert betrachtet.

1. Native Serialisierung mit Java

1.1 Java Serializable-Schnittstelle

Java bietet mit der Serializable-Schnittstelle eine einfache Möglichkeit, Objekte zu serialisieren. Ein Objekt einer Klasse kann serialisiert werden, wenn die Klasse java.io.Serializable implementiert:

import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}
Code-Sprache: PHP (php)

Die Serialisierung erfolgt dann über ObjectOutputStream:

try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
    out.writeObject(new Person("Alice", 30));
} catch (IOException e) {
    e.printStackTrace();
}
Code-Sprache: JavaScript (javascript)

Zum Deserialisieren wird ObjectInputStream verwendet:

try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.ser"))) {
    Person person = (Person) in.readObject();
    System.out.println(person);
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}
Code-Sprache: JavaScript (javascript)

1.2 Vorteile und Nachteile der nativen Java-Serialisierung

Vorteile:

  • Einfache Nutzung: Keine zusätzliche Bibliothek erforderlich.
  • Automatische Speicherung der Objekthierarchie: Vererbte Felder werden mitserialisiert.

Nachteile:

  • Langsame Performance: Java-Serializable ist langsamer als moderne Serialisierungsmethoden.
  • Hoher Speicherverbrauch: Die serialisierten Objekte sind oft unnötig groß.
  • Inkompatibilität bei Änderungen: Änderungen an der Klassenstruktur können zu InvalidClassException führen.
  • Sicherheitsrisiken: Serialisierte Objekte sind anfällig für Deserialisierungsangriffe.

2. Alternative Serialisierungsansätze

2.1 JSON-Serialisierung mit Jackson

Jackson ist eine weit verbreitete Bibliothek zur JSON-Verarbeitung in Java. Sie ist einfach zu verwenden und effizient:

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper objectMapper = new ObjectMapper();
Person person = new Person("Alice", 30);
String json = objectMapper.writeValueAsString(person);
System.out.println(json);
Code-Sprache: JavaScript (javascript)

Deserialisierung:

Person deserializedPerson = objectMapper.readValue(json, Person.class);
System.out.println(deserializedPerson);

Vorteile:

  • Lesbares Format: JSON kann problemlos von Menschen und Systemen verarbeitet werden.
  • Plattformunabhängigkeit: JSON kann in verschiedenen Programmiersprachen genutzt werden.
  • Flexible Struktur: Es gibt keine feste Schema-Vorgabe.

Nachteile:

  • Größer als binäre Formate: JSON benötigt mehr Speicherplatz als binäre Serialisierungsformate wie Protobuf oder Kryo.
  • Langsamer als binäre Formate: Das Parsen von JSON ist langsamer als die Verarbeitung von binären Formaten.

2.2 Gson

Gson ist eine alternative Bibliothek von Google zur JSON-Serialisierung und -Deserialisierung:

import com.google.gson.Gson;

Gson gson = new Gson();
String json = gson.toJson(person);
Person personFromJson = gson.fromJson(json, Person.class);
Code-Sprache: JavaScript (javascript)

Unterschiede zu Jackson:

  • Einfachere API: Gson ist oft einfacher zu verwenden als Jackson.
  • Weniger flexibel: Jackson bietet mehr Anpassungsmöglichkeiten und schnellere Verarbeitung.

2.3 Protobuf (Protocol Buffers)

Google’s Protocol Buffers (Protobuf) ist ein binäres Serialisierungsformat, das besonders für Hochleistungsanwendungen geeignet ist. Es erfordert eine spezielle .proto-Datei zur Definition der Datenstrukturen:

syntax = "proto3";
message Person {
  string name = 1;
  int32 age = 2;
}
Code-Sprache: JavaScript (javascript)

Nach der Codegenerierung kann ein Protobuf-Objekt serialisiert werden:

PersonProto.Person person = PersonProto.Person.newBuilder().setName("Alice").setAge(30).build();
byte[] serializedData = person.toByteArray();
PersonProto.Person deserializedPerson = PersonProto.Person.parseFrom(serializedData);
Code-Sprache: JavaScript (javascript)

Vorteile:

  • Hocheffizient: Kompaktes binäres Format mit schneller Verarbeitung.
  • Versionskompatibel: Änderungen an der Struktur sind möglich, solange neue Felder optional sind.
  • Plattformübergreifend: Kann in verschiedenen Programmiersprachen verwendet werden.

Nachteile:

  • Zusätzlicher Code-Generator erforderlich: .proto-Dateien müssen vor der Nutzung kompiliert werden.
  • Nicht menschenlesbar: Erschwert Debugging im Vergleich zu JSON.

2.4 Kryo

Kryo ist eine leistungsfähige Bibliothek für binäre Serialisierung mit hoher Performance und geringerem Speicherverbrauch:

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import java.io.*;

Kryo kryo = new Kryo();
kryo.register(Person.class);

try (Output output = new Output(new FileOutputStream("person.kryo"))) {
    kryo.writeObject(output, new Person("Alice", 30));
}

try (Input input = new Input(new FileInputStream("person.kryo"))) {
    Person person = kryo.readObject(input, Person.class);
    System.out.println(person);
}
Code-Sprache: JavaScript (javascript)

Vorteile:

  • Sehr hohe Geschwindigkeit: Schneller als die native Java-Serialisierung und JSON.
  • Geringe Dateigröße: Kompaktes binäres Format.

Nachteile:

  • Nicht standardisiert: Kein plattformübergreifendes Standardformat.
  • Nicht menschenlesbar: Debugging schwieriger als bei JSON.

3. Fazit

Die Wahl der richtigen Serialisierung hängt von den Anforderungen ab:

  • Java-Serializable: Einfach, aber ineffizient und unsicher.
  • JSON (Jackson, Gson): Menschlich lesbar, aber größer und langsamer als binäre Formate.
  • Protobuf: Sehr effizient, aber erfordert zusätzliche Code-Generierung.
  • Kryo: Extrem schnell, aber nicht standardisiert und nicht plattformunabhängig.

Für produktive Systeme ist es ratsam, von der nativen Java-Serialisierung auf eine effizientere Lösung wie Protobuf oder Kryo umzusteigen.