Какие знаешь интерфейсы для сериализации в Java?

Интерфейсы для сериализации в Java

Сериализация — это процесс преобразования объектов в байтовый поток для сохранения или передачи. Десериализация — это обратный процесс восстановления объектов. В Java существует множество подходов и интерфейсов для сериализации.

1. Serializable (Java нативная сериализация)

Serializable — основной интерфейс для встроенной Java сериализации. Это маркерный интерфейс без методов.

import java.io.*;

// Класс, который можно сериализовать
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private Long id;
    private String name;
    private String email;
    private transient String password; // transient — не сериализуется
    
    public User(Long id, String name, String email, String password) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.password = password;
    }
    
    // getters and setters
}

// Сериализация
public class SerializationExample {
    
    // Запись объекта в файл
    public static void serializeUser(User user, String filename) 
            throws IOException {
        try (FileOutputStream fos = new FileOutputStream(filename);
             ObjectOutputStream oos = new ObjectOutputStream(fos)) {
            oos.writeObject(user);
            System.out.println("User serialized: " + filename);
        }
    }
    
    // Чтение объекта из файла
    public static User deserializeUser(String filename) 
            throws IOException, ClassNotFoundException {
        try (FileInputStream fis = new FileInputStream(filename);
             ObjectInputStream ois = new ObjectInputStream(fis)) {
            return (User) ois.readObject();
        }
    }
    
    public static void main(String[] args) throws Exception {
        // Создание и сериализация
        User user = new User(1L, "John Doe", "john@example.com", "secret123");
        serializeUser(user, "user.ser");
        
        // Десериализация
        User restored = deserializeUser("user.ser");
        System.out.println("Restored: " + restored.getName()); // John Doe
        System.out.println("Password: " + restored.getPassword()); // null (был transient)
    }
}

Особенности:

• Встроена в Java (java.io.Serializable)
• Платформо-зависимая (использует Java Binary Format)
• Медленнее, чем альтернативы
• Полиморфная
• Требует serialVersionUID
• Поддержка версионирования

2. Externalizable

Externalizable — интерфейс для более контролируемой сериализации.

import java.io.*;

public class Product implements Externalizable {
    private Long id;
    private String name;
    private BigDecimal price;
    
    public Product() { } // Требуется конструктор без аргументов
    
    public Product(Long id, String name, BigDecimal price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
    
    // Запись данных
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeLong(id);
        out.writeUTF(name);
        out.writeObject(price);
    }
    
    // Чтение данных
    @Override
    public void readExternal(ObjectInput in) 
            throws IOException, ClassNotFoundException {
        id = in.readLong();
        name = in.readUTF();
        price = (BigDecimal) in.readObject();
    }
    
    public Long getId() { return id; }
    public String getName() { return name; }
    public BigDecimal getPrice() { return price; }
}

// Использование
public class ExternalizableExample {
    
    public static void main(String[] args) throws Exception {
        Product product = new Product(1L, "Laptop", new BigDecimal("999.99"));
        
        // Сериализация
        try (FileOutputStream fos = new FileOutputStream("product.dat");
             ObjectOutputStream oos = new ObjectOutputStream(fos)) {
            oos.writeObject(product);
        }
        
        // Десериализация
        try (FileInputStream fis = new FileInputStream("product.dat");
             ObjectInputStream ois = new ObjectInputStream(fis)) {
            Product restored = (Product) ois.readObject();
            System.out.println(restored.getName());
        }
    }
}

Особенности:

• Полный контроль над процессом сериализации
• Требует пустого конструктора
• Более эффективна, чем Serializable
• Требует явной реализации методов

3. JSON Serialization (Jackson)

Jackson — самая популярная библиотека для JSON сериализации в Java.

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonIgnore;

public class UserDto {
    
    @JsonProperty("user_id")
    private Long id;
    
    private String name;
    private String email;
    
    @JsonIgnore // Не сериализуется в JSON
    private String password;
    
    public UserDto() { }
    
    public UserDto(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    
    // getters and setters
}

public class JacksonExample {
    
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        
        // Объект -> JSON
        UserDto user = new UserDto(1L, "John Doe", "john@example.com");
        String json = mapper.writeValueAsString(user);
        System.out.println(json);
        // Вывод: {"user_id":1,"name":"John Doe","email":"john@example.com"}
        
        // JSON -> Объект
        String jsonInput = "{\"user_id\":2,\"name\":\"Jane\",\"email\":\"jane@example.com\"}";
        UserDto deserialized = mapper.readValue(jsonInput, UserDto.class);
        System.out.println(deserialized.getName()); // Jane
        
        // Запись в файл
        mapper.writeValue(new File("user.json"), user);
        
        // Чтение из файла
        UserDto fromFile = mapper.readValue(new File("user.json"), UserDto.class);
        
        // Работа со списками
        List<UserDto> users = Arrays.asList(
            new UserDto(1L, "Alice", "alice@example.com"),
            new UserDto(2L, "Bob", "bob@example.com")
        );
        String jsonArray = mapper.writeValueAsString(users);
    }
}

Особенности:

• JSON формат (человекочитаемый)
• Очень популярна в веб-приложениях
• Поддержка аннотаций
• Гибкая конфигурация
• Работает с REST API

4. JSON Serialization (GSON)

GSON — альтернативная библиотека для JSON сериализации от Google.

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class Article {
    
    @SerializedName("article_id")
    @Expose
    private Long id;
    
    @Expose
    private String title;
    
    @Expose
    private String content;
    
    private String internalNotes; // Не будет сериализован
    
    public Article(Long id, String title, String content) {
        this.id = id;
        this.title = title;
        this.content = content;
    }
    
    // getters and setters
}

public class GsonExample {
    
    public static void main(String[] args) {
        Gson gson = new GsonBuilder()
            .excludeFieldsWithoutExposeAnnotation()
            .setPrettyPrinting()
            .create();
        
        // Объект -> JSON
        Article article = new Article(1L, "Java Serialization", "...");
        String json = gson.toJson(article);
        System.out.println(json);
        
        // JSON -> Объект
        String jsonInput = "{\"article_id\":1,\"title\":\"Test\",\"content\":\"...\"}";
        Article deserialized = gson.fromJson(jsonInput, Article.class);
    }
}

5. Protocol Buffers (Protobuf)

Protocol Buffers — эффективный формат сериализации от Google.

// file.proto
syntax = "proto3";

package example;

message User {
    int64 id = 1;
    string name = 2;
    string email = 3;
}

message UserList {
    repeated User users = 1;
}

// Использование сгенерированных классов
import example.User;
import example.UserList;

public class ProtobufExample {
    
    public static void main(String[] args) throws Exception {
        // Создание
        User user = User.newBuilder()
            .setId(1)
            .setName("John")
            .setEmail("john@example.com")
            .build();
        
        // Сериализация в байты
        byte[] bytes = user.toByteArray();
        
        // Десериализация
        User restored = User.parseFrom(bytes);
        System.out.println(restored.getName());
    }
}

Особенности:

• Очень компактный (меньше JSON и XML)
• Быстрый
• Требует .proto схему
• Поддержка множества языков
• Идеален для микросервисов

6. XML Serialization (JAXB)

JAXB (Java Architecture for XML Binding) — стандарт для XML сериализации.

import jakarta.xml.bind.annotation.*;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.Marshaller;
import jakarta.xml.bind.Unmarshaller;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Book {
    
    @XmlElement
    private Long id;
    
    @XmlElement
    private String title;
    
    @XmlElement
    private String author;
    
    @XmlTransient // Не включится в XML
    private String internalId;
    
    // getters and setters
}

public class JaxbExample {
    
    public static void main(String[] args) throws Exception {
        JAXBContext context = JAXBContext.newInstance(Book.class);
        
        // Сериализация (Object -> XML)
        Book book = new Book();
        book.setId(1L);
        book.setTitle("Clean Code");
        book.setAuthor("Robert Martin");
        
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(book, new File("book.xml"));
        
        // Десериализация (XML -> Object)
        Unmarshaller unmarshaller = context.createUnmarshaller();
        Book restored = (Book) unmarshaller.unmarshal(new File("book.xml"));
    }
}

7. MessagePack

MessagePack — компактный бинарный формат, более эффективный чем JSON.

import org.msgpack.core.MessagePack;
import org.msgpack.core.MessageBufferPacker;
import org.msgpack.core.MessageUnpacker;

public class MessagePackExample {
    
    public static void main(String[] args) throws Exception {
        // Пакерование
        MessageBufferPacker packer = MessagePack.newDefaultBufferPacker();
        packer.packString("Alice")
               .packInt(30)
               .packString("alice@example.com")
               .close();
        
        byte[] bytes = packer.toByteArray();
        
        // Распакерование
        MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes);
        String name = unpacker.unpackString();
        int age = unpacker.unpackInt();
        String email = unpacker.unpackString();
        
        System.out.println(name + ", " + age + ", " + email);
    }
}

8. Custom Serialization

Можно реализовать собственный механизм сериализации.

public interface CustomSerializer {
    void serialize(Object obj, OutputStream out);
    Object deserialize(InputStream in);
}

public class CsvSerializer implements CustomSerializer {
    
    @Override
    public void serialize(Object obj, OutputStream out) {
        // CSV сериализация
    }
    
    @Override
    public Object deserialize(InputStream in) {
        // CSV десериализация
        return null;
    }
}

Сравнительная таблица

Рекомендации

// Для веб-приложений: Jackson
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(object);

// Для микросервисов: Protocol Buffers
// Определить .proto файл и использовать сгенерированные классы

// Для быстрой сериализации: MessagePack
// Когда размер и скорость критичны

// Для enterprise систем: JAXB (XML)
// Когда требуется XML с валидацией

// Для простого сохранения состояния: Serializable
// Когда нужно сохранить объект в файл

Заключение

Выбор интерфейса сериализации зависит от:

• Формата: JSON (веб), Binary (производительность), XML (enterprise)
• Производительности: MessagePack > Protobuf > Externalizable > JSON > Serializable
• Платформы: для Java native, для интеграции — язык-независимые форматы
• Удобства: Jackson/GSON для JSON, Protobuf для бинарного

В современных Java приложениях Jackson для JSON и Protocol Buffers для высокопроизводительных систем являются наиболее распространённым выбором.