CodeGym /Kursy /JAVA 25 SELF /Standardowe formaty serializacji: binarny, tekstowy

Standardowe formaty serializacji: binarny, tekstowy

JAVA 25 SELF
Poziom 42, Lekcja 2
Dostępny

1. Serializacja binarna w Java

Serializacja binarna — to standardowy mechanizm Java, w którym obiekt zamienia się w strumień bajtów maksymalnie zwarto i szybko. Do tego służą klasy ObjectOutputStream i ObjectInputStream. Powstały plik to zestaw bajtów, który nie jest przeznaczony do czytania przez człowieka.

Nazywa się binarną, ponieważ wszystko jest serializowane w „surowym” stanie: liczby, napisy, tablice, a nawet referencje między obiektami zamieniają się w bajty. To jak ciasno spakowana walizka: wydajnie i szybko, ale bez instrukcji nie jest oczywiste, gdzie co leży.

Jak to działa w Java?

Załóżmy, że mamy klasę User:

import java.io.Serializable;

public class User implements Serializable {
    private String name;
    private int age;

    // Konstruktor, gettery i settery
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
}

Serializacja do pliku binarnego

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

User user = new User("John", 30);

try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("user.bin"))) {
    out.writeObject(user);
    System.out.println("Obiekt User został zserializowany do pliku user.bin");
} catch (Exception e) {
    e.printStackTrace();
}

Deserializacja z pliku binarnego

import java.io.FileInputStream;
import java.io.ObjectInputStream;

try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("user.bin"))) {
    User loadedUser = (User) in.readObject();
    System.out.println("Przeczytano z pliku: " + loadedUser.getName() + ", " + loadedUser.getAge());
} catch (Exception e) {
    e.printStackTrace();
}

Uwaga: jeśli otworzysz plik user.bin w edytorze tekstowym, zobaczysz coś w rodzaju: ¬í sr ... — to normalne, tak to zostało zaprojektowane!

Zalety serializacji binarnej

  • Zwartość i szybkość. Zapisywanie i odczyt odbywają się maksymalnie szybko, bez zbędnych „upiększeń”.
  • Zapisywane są wszystkie pola obiektu, łącznie z obiektami zagnieżdżonymi (jeśli również są serializowalne przez Serializable).
  • Łatwa w użyciu do wewnętrznego cache’a lub przekazywania między programami Java.

Wady

  • Nieczytelność. Człowiek nie będzie w stanie „podejrzeć” zawartości i zrozumieć, co tam jest.
  • Ścisłe powiązanie z wersją klasy. Zmiana struktury (dodanie/usunięcie pól) może „zepsuć” odczyt starych plików.
  • Problemy ze zgodnością między różnymi wersjami Java i JVM.
  • Nie nadaje się do wymiany z innymi językami programowania.
  • Bezpieczeństwo: deserializacja danych z niezweryfikowanych źródeł to prosta droga do podatności.

2. Tekstowe formaty serializacji: JSON, XML i inne

Serializacja binarna jest dobra do użytku wewnętrznego, ale często trzeba przekazywać dane między różnymi językami (Java, JavaScript, Python) lub przechowywać je w czytelnej formie — wygodnej dla konfiguracji, logów, API. Do tego używa się formatów tekstowych: JSON, XML, YAML, CSV itp.

JSON — najpopularniejszy

JSON (JavaScript Object Notation) — format zwarty i czytelny. Przykład zserializowanego obiektu User:

{
  "name": "John",
  "age": 30
}

W Java do pracy z JSON najczęściej używa się bibliotek: Jackson (najpopularniejsza), Gson, a także Moshi, JSON-B itp.

XML — stary przyjaciel programisty

XML (Extensible Markup Language) — bardziej „rozwlekły”, ale formalny i ścisły.

<User>
  <name>John</name>
  <age>30</age>
</User>

Dla XML w Java często stosuje się standardową bibliotekę JAXB (albo starszą XStream).

YAML, CSV i inne

  • YAML — podobny do JSON, ale bardziej zwięzły; częściej używany do konfiguracji niż do serializacji złożonych obiektów.
  • CSV — dobry do „płaskich” tabel, ale słabo nadaje się do zagnieżdżonych struktur.
  • Inne formaty istnieją na każdy gust, ale w Java najczęściej używa się JSON i XML.

3. Porównanie formatów: kiedy czego używać?

Format Czytelność Zwartość Szybkość Zgodność Kiedy używać
Binarny Nie ++ ++ Tylko Java Wewnętrzny cache, szybkie zapisywanie między JVM
JSON Tak + + Dowolne języki REST API, wymiana z zewnętrznymi usługami, konfiguracje
XML Tak - - Dowolne języki Integracja, ścisłe schematy, stare systemy
  • Binarny — wybieraj do użytku wewnętrznego, gdy nie jest wymagana wymiana z systemami zewnętrznymi i liczy się maksymalna wydajność.
  • JSON — najlepszy wybór do wymiany z aplikacjami webowymi, klientami mobilnymi i REST API, a także do przechowywania ustawień.
  • XML — potrzebny przy ścisłych schematach i integracji z „korporacyjnymi” rozwiązaniami.

Ważne! Serializacja binarna nadaje się tylko do przekazywania danych między programami Java i nawet w tym przypadku bezpieczniej używać jej między programami tej samej wersji. Formatów tekstowych, takich jak JSON i XML, można używać bardziej uniwersalnie: nadają się do wymiany danych między różnymi językami i platformami, czyniąc informacje czytelnymi i przenośnymi.

4. Praktyka: serializacja do formatu binarnego i tekstowego

Serializacja binarna (ObjectOutputStream/ObjectInputStream)

Widzieliśmy to już wyżej, ale powtórzmy dla utrwalenia:

// Serializacja
try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("user.bin"))) {
    out.writeObject(user);
}

// Deserializacja
try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("user.bin"))) {
    User loadedUser = (User) in.readObject();
}

Serializacja do JSON za pomocą Jackson (krótko)

Aby pracować z Jackson, trzeba dodać jego biblioteki do projektu. Później poznamy Maven i Gradle, a na razie można dołączyć pliki JAR ręcznie. Przykładowa zależność dla Maven:

<!-- Maven -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.17.0</version>
</dependency>

Przykład serializacji/deserializacji:

import com.fasterxml.jackson.databind.ObjectMapper;

User user = new User("John", 30);
ObjectMapper mapper = new ObjectMapper();

try {
    // Serializacja do łańcucha znaków
    String json = mapper.writeValueAsString(user);
    System.out.println(json); // {"name":"John","age":30}

    // Serializacja do pliku
    mapper.writeValue(new File("user.json"), user);

    // Deserializacja ze łańcucha
    User loadedUser = mapper.readValue(json, User.class);

    // Deserializacja z pliku
    User loadedFromFile = mapper.readValue(new File("user.json"), User.class);

} catch (Exception e) {
    e.printStackTrace();
}

Plik JSON można otworzyć w dowolnym edytorze tekstu, co sprawia, że dane są łatwo czytelne i przenoszalne między różnymi aplikacjami i językami.

5. Kiedy używać którego formatu: praktyczne wskazówki

  • Wewnętrzne cache’owanie, pliki tymczasowe, szybki zapis/odczyt między programami Java: używaj standardowej serializacji binarnej. Pamiętaj jednak o zgodności wersji!
  • Wymiana z zewnętrznymi usługami, przechowywanie ustawień, integracja z frontendem: używaj JSON (Jackson, Gson).
  • Integracja z „korporacyjnymi” systemami, gdzie wymagana jest ścisła schema: XML (JAXB).
  • Trzeba, aby człowiek mógł otworzyć i przeczytać plik: JSON lub XML, ale nie format binarny.

6. Typowe błędy przy pracy z formatami serializacji

Błąd nr 1: Próba serializacji obiektu z nieserializowalnymi polami. Jeśli klasa ma pole, które nie implementuje Serializable (np. strumień lub połączenie z bazą danych), serializacja binarna zakończy się błędem. Dla JSON nie jest to aż tak krytyczne, ale z „niestandardowymi” typami również bywają problemy.

Błąd nr 2: Otwieranie pliku binarnego w edytorze tekstowym i niepokojenie się. To normalne! Pliki binarne nie są przeznaczone do czytania przez człowieka.

Błąd nr 3: Zmiana struktury klasy, a stare pliki binarne przestają się dawać odczytać. Serializacja binarna jest wrażliwa na zmianę struktury klasy — często pojawia się InvalidClassException. W JSON/XML jest to mniej krytyczne: nieznane pola zwykle są ignorowane lub otrzymują wartości domyślne.

Błąd nr 4: Używanie serializacji binarnej do wymiany z systemami zewnętrznymi. To nie zadziała: format binarny rozumie tylko Java, i to przy zgodności wersji.

Błąd nr 5: Dla JSON/XML zapominanie o dodaniu wymaganych adnotacji. Niektóre biblioteki wymagają adnotacji takich jak @JsonProperty, @XmlElement, w przeciwnym razie serializacja/deserializacja może działać niezgodnie z oczekiwaniami.

Błąd nr 6: Brak weryfikacji, że wszystkie obiekty zagnieżdżone są serializowalne. Dla serializacji binarnej to częsty problem; dla JSON również, jeśli w modelu występują złożone typy.

1
Zadanie
JAVA 25 SELF, poziom 42, lekcja 2
Niedostępne
Serializacja obiektu do pliku binarnego
Serializacja obiektu do pliku binarnego
1
Zadanie
JAVA 25 SELF, poziom 42, lekcja 2
Niedostępne
Deserializacja obiektu z pliku binarnego
Deserializacja obiektu z pliku binarnego
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION