Сериализация — это процесс преобразования структуры данных или объекта в формат, который можно сохранить на диск, передать по сети или записать в базу данных, с возможностью последующего восстановления (десериализации) в исходную структуру.

RFC (Request for Comments) — серия документов Интернет-инженерного совета (IETF), описывающих стандарты, протоколы и технологии Интернета. RFC 8259 является официальной спецификацией формата JSON.

Парсинг — это процесс анализа строки или потока данных в соответствии с правилами формального языка (грамматикой) с целью построения структурированного представления, обычно дерева разбора или абстрактного синтаксического дерева (AST).

REST (Representational State Transfer) — это архитектурный стиль проектирования распределённых систем, введённый Роем Филдингом в его докторской диссертации 2000 года. REST не является протоколом или стандартом в строгом смысле; это набор ограничений и принципов.

Ключевое ограничение — statelessness (отсутствие состояния): каждый запрос от клиента к серверу должен содержать всю информацию, необходимую для его обработки, и сервер не хранит контекст клиента между запросами.

DTD (Document Type Definition) и XSD (XML Schema Definition) — это механизмы определения структуры и допустимых элементов XML-документа. JSON изначально не имел встроенного механизма схем, хотя позже появились JSON Schema и OpenAPI.

{
  "user": {
    "id": 42,
    "name": "Alice",
    "active": true
  }
}

{
  "orders": [
    { "id": 1, "total": 99.99 },
    { "id": 2, "total": 150.00 }
  ]
}

{
  "description": "Line 1\nLine 2\tTabbed",
  "emoji": "\uD83D\uDE00"
}

UTF-8 (Unicode Transformation Format, 8-bit) — это кодировка переменной длины, которая кодирует символы Unicode от 1 до 4 байтами. Символы ASCII (0–127) занимают 1 байт, что делает UTF-8 эффективной для англоязычных текстов.

{
  "integer": 42,
  "negative": -17,
  "float": 3.14159,
  "exponential": 6.022e23,
  "small": 1e-10
}

IEEE 754 — это стандарт представления чисел с плавающей точкой в компьютерах. Double-precision использует 64 бита: 1 бит знака, 11 бит экспоненты и 52 бита мантиссы. Не все десятичные дроби точно представимы в двоичной системе, отсюда ошибки округления.

{
  "enabled": true,
  "debug": false
}

{
  "middleName": null
}

{
  "users": [
    { "id": 1, "name": "Alice" },
    { "id": 2, "name": "Bob" }
  ]
}

Protocol Buffers (protobuf) — бинарный формат сериализации, разработанный Google. В отличие от JSON, protobuf требует предварительного определения схемы (proto-файл), но обеспечивает компактное бинарное представление и строгую типизацию.

JSON Schema — это спецификация (draft 2020-12) для описания структуры JSON-документов. Она позволяет определять типы полей, обязательность, диапазоны значений, регулярные выражения для строк и другие ограничения.

Base64 — это схема кодирования бинарных данных в текстовый формат с использованием 64 символов ASCII (A–Z, a–z, 0–9, +, /). Каждые 3 байта (24 бита) кодируются 4 символами Base64 (по 6 бит каждый), отсюда overhead в 33%.

Bottleneck — это узкое место в системе, которое ограничивает общую производительность. В контексте JSON-парсинга bottleneck часто возникает из-за аллокации объектов в куче и работы GC при обработке больших JSON-документов.

Kernel space и user space — это два режима работы процессора. Kernel space — привилегированный режим, в котором работает код операционной системы и драйверов. User space — непривилегированный режим, в котором работают обычные приложения, включая JVM. Переход между режимами (context switch) — дорогая операция.

Compact strings — оптимизация, введённая в Java 9 (JEP 254). Строки, содержащие только символы Latin-1 (коды 0–255), хранятся в массиве 

 по одному байту на символ. Если встречается символ вне Latin-1, массив переключается на UTF-16 (2 байта на символ).

{
  "users": [
    { "id": 1, "name": "Alice" },
    { "id": 2, "name": "Bob" }
  ]
}

// Потоковый парсинг Jackson — минимум аллокаций
public void processLargeJson(InputStream in) throws IOException {
    // JsonFactory — лёгкий фабричный объект для создания парсеров
    JsonFactory factory = new JsonFactory();
    
    // JsonParser — потоковый парсер, читает JSON без построения дерева
    try (JsonParser parser = factory.createParser(in)) {
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String fieldName = parser.getCurrentName();
            if ("users".equals(fieldName)) {
                parser.nextToken(); // переходим к массиву
                while (parser.nextToken() == JsonToken.START_OBJECT) {
                    // Обрабатываем каждый объект пользователя
                    int id = 0;
                    String name = null;
                    while (parser.nextToken() != JsonToken.END_OBJECT) {
                        String key = parser.getCurrentName();
                        parser.nextToken();
                        if ("id".equals(key)) {
                            id = parser.getIntValue();
                        } else if ("name".equals(key)) {
                            name = parser.getValueAsString();
                        }
                    }
                    // Обрабатываем пользователя без создания промежуточных объектов
                    processUser(id, name);
                }
            }
        }
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Date;

public class Task040826 {
    static class Event {
        
        public String name;

        public Date date;

        Event(String name, Date date) {
            this.name = name; this.date = date;
        }
    }

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        Event event = new Event("Party", new Date(0));
        System.out.println(mapper.writeValueAsString(event));
    }
}

import java.util.*;

public class NullInCollections {
    
    public static void main(String[] args) {
        //Антипаттерн: Set.of() с null
        try {
            Set<String> set = Set.of("a", null, "b"); // NullPointerException
        } catch (NullPointerException e) {
            System.err.println("Set.of() не допускает null");
        }
        
        //Map.of() с null ключом или значением
        try {
            Map<String, String> map = Map.of("key", null); // NullPointerException
        } catch (NullPointerException e) {
            System.err.println("Map.of() не допускает null-значений");
        }
        
        //Решение: использовать HashMap для поддержки null
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put("key1", "value1");
        hashMap.put("key2", null); // допустимо
        hashMap.put(null, "value3"); // допустим null-ключ
        System.out.println("HashMap with nulls: " + hashMap);
        
        //Если нужна неизменяемость с null, используйте unmodifiable обертку
        Map<String, String> unmodifiableWithNull = Collections.unmodifiableMap(hashMap);
        // unmodifiableWithNull нельзя изменить, но null сохраняются
        System.out.println("Unmodifiable with null: " + unmodifiableWithNull);
        // Однако это не иммутабельная коллекция — исходный hashMap можно изменить, и view отразит
        
        //Для безопасной работы с неизменяемыми коллекциями и null — избегайте null
        // Используйте Optional или значения-заглушки
        Map<String, Optional<String>> safeMap = Map.of(
            "key1", Optional.of("value"),
            "key2", Optional.empty() // представляет null
        );
        // При чтении: safeMap.get("key2").orElse("default");
        
        //Использование checkedMap для типизированной проверки (не решает проблему null)
        Map<String, String> checked = Collections.checkedMap(
            new HashMap<>(), String.class, String.class);
        checked.put("a", null); // допустимо, проверка типов не касается null
    }
}

import java.util.Map;

public class Task050826 {
    public static void main(String[] args) {
        try {
            Map<String, String> map = Map.of(
                "key1", "value1",
                "key2", null
            );
            System.out.println("size=" + map.size());
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}

Сериализация — это процесс преобразования структуры данных или объекта в формат, пригодный для хранения или передачи, с возможностью обратного восстановления (десериализации).

Граф данных — это абстрактная структура, состоящая из узлов (данных) и рёбер (связей между данными). В YAML узел может быть скаляром (строка, число, булево, null), последовательностью (упорядоченный список) или отображением (ассоциативный массив, пары ключ-значение).

RCE (Remote Code Execution) — это класс уязвимостей, позволяющий атакующему выполнить произвольный код на целевой системе удалённо. В контексте десериализации RCE возникает, когда формат данных позволяет указать класс для инстанцирования, и этот класс имеет опасный конструктор или сеттер.

import org.yaml.snakeyaml.Yaml;
import java.io.InputStream;
import java.util.Map;
import java.util.List;

public class YamlReader {
    
    public Map<String, Object> loadConfig(InputStream input) {
        // Yaml — лёгкий объект, но не thread-safe
        // Для многопоточного использования создавайте Yaml на каждый поток
        Yaml yaml = new Yaml();
        
        // load возвращает Object, который для корневого отображения
        // приводится к Map<String, Object>
        return yaml.load(input);
    }
    
    public void printNestedValue(Map<String, Object> config) {
        // YAML-отображения маппятся на LinkedHashMap (сохраняет порядок ключей)
        // YAML-последовательности маппятся на ArrayList
        Map<String, Object> server = (Map<String, Object>) config.get("server");
        Integer port = (Integer) server.get("port");
        System.out.println("Port: " + port);
    }
}

LinkedHashMap — это реализация интерфейса Map в Java, которая, в отличие от обычного HashMap, сохраняет порядок вставки элементов. Это важно для YAML, так как порядок ключей в конфигурации часто семантически значим.

// Многоуровневое извлечение значения без типобезопасности
Map<String, Object> db = (Map<String, Object>) config.get("database");
Map<String, Object> pool = (Map<String, Object>) db.get("connectionPool");
Integer maxSize = (Integer) pool.get("maxSize");  // ClassCastException, если тип другой

JavaBeans — это соглашение в Java, согласно которому класс должен иметь конструктор без параметров, публичные геттеры и сеттеры для свойств, и реализовывать интерфейс Serializable (опционально). SnakeYAML использует рефлексию для вызова сеттеров по именам ключей YAML.

import org.yaml.snakeyaml.Yaml;

public class LibraryConfig {
    
    private String storagePath;
    private int maxBooks;
    private DatabaseConfig database;
    private List<String> allowedFormats;
    
    // Конструктор по умолчанию обязателен для SnakeYAML
    public LibraryConfig() {}
    
    // Геттеры и сеттеры — SnakeYAML вызывает сеттеры по имени ключа
    public String getStoragePath() { return storagePath; }
    public void setStoragePath(String storagePath) { this.storagePath = storagePath; }
    
    public int getMaxBooks() { return maxBooks; }
    public void setMaxBooks(int maxBooks) { this.maxBooks = maxBooks; }
    
    public DatabaseConfig getDatabase() { return database; }
    public void setDatabase(DatabaseConfig database) { this.database = database; }
    
    public List<String> getAllowedFormats() { return allowedFormats; }
    public void setAllowedFormats(List<String> allowedFormats) { this.allowedFormats = allowedFormats; }
    
    // Вложенный класс конфигурации
    public static class DatabaseConfig {
        private String url;
        private String username;
        private String password;
        private int connectionTimeout;
        
        public DatabaseConfig() {}
        
        public String getUrl() { return url; }
        public void setUrl(String url) { this.url = url; }
        
        public String getUsername() { return username; }
        public void setUsername(String username) { this.username = username; }
        
        public String getPassword() { return password; }
        public void setPassword(String password) { this.password = password; }
        
        public int getConnectionTimeout() { return connectionTimeout; }
        public void setConnectionTimeout(int connectionTimeout) { this.connectionTimeout = connectionTimeout; }
    }
}

storagePath: /var/lib/library
maxBooks: 10000
allowedFormats:
  - pdf
  - epub
  - mobi
database:
  url: jdbc:postgresql://localhost:5432/library
  username: lib_admin
  password: secret
  connectionTimeout: 30

public class ConfigLoader {
    
    public LibraryConfig loadLibraryConfig(InputStream input) {
        Yaml yaml = new Yaml();
        // loadAs маппит YAML на объект указанного класса через JavaBeans
        return yaml.loadAs(input, LibraryConfig.class);
    }
}

public class CustomDurationConstructor extends Constructor {
    
    public CustomDurationConstructor(Class<?> theRoot) {
        super(theRoot);
        // Регистрируем кастомный конструктор для тега !duration
        this.yamlConstructors.put(new Tag("!duration"), new DurationConstruct());
    }
    
    // AbstractConstruct — базовый класс для пользовательских конструкторов узлов YAML
    private class DurationConstruct extends AbstractConstruct {
        
        @Override
        public Object construct(Node node) {
            // ScalarNode представляет скалярное значение (строка, число и т.д.)
            String value = ((ScalarNode) node).getValue();
            try {
                // ISO-8601 формат: PT30S — 30 секунд, PT5M — 5 минут
                return Duration.parse(value);
            } catch (DateTimeParseException e) {
                throw new YAMLException("Невалидный формат Duration: " + value, e);
            }
        }
    }
}

storagePath: /var/lib/library
maxBooks: 10000
sessionTimeout: !duration PT30M

public class AdvancedConfig {
    private Duration sessionTimeout;
    
    public Duration getSessionTimeout() { return sessionTimeout; }
    public void setSessionTimeout(Duration sessionTimeout) { this.sessionTimeout = sessionTimeout; }
}

// Загрузка с кастомным конструктором
Yaml yaml = new Yaml(new CustomDurationConstructor(AdvancedConfig.class));
AdvancedConfig config = yaml.load(input);

Тег (tag) в YAML — это метка, явно указывающая тип узла. Стандартные теги: !!str , !!int, !!float, !!bool, !!null, !!map, !!seq. Пользовательские теги начинаются с ! (локальные) или !! (глобальные). Теги позволяют YAML-документу нести информацию о типах, необходимую для корректной десериализации.

public class YamlWriter {
    
    public String writeConfig(LibraryConfig config) {
        // DumperOptions — настройки форматирования вывода
        DumperOptions options = new DumperOptions();
        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);  // блочный стиль вместо inline
        options.setPrettyFlow(true);  // красивые отступы
        options.setIndent(2);  // отступ в 2 пробела
        
        Yaml yaml = new Yaml(options);
        StringWriter writer = new StringWriter();
        yaml.dump(config, writer);
        return writer.toString();
    }
}

Flow style и block style — это два способа записи коллекций в YAML. Block style использует отступы (как Python), flow style использует JSON-подобный синтаксис со скобками. Для конфигураций block style предпочтителен из-за читаемости.

allowedFormats:
  - pdf
  - epub
  - mobi
  
# Альтернативный flow-style (менее читаемый)
allowedFormats: [pdf, epub, mobi]

database:
  url: jdbc:postgresql://localhost:5432/library
  pool:
    min: 5
    max: 20

description: |
  Это многострочный текст.
  Каждая строка сохраняет свой перевод.
  Итоговая строка содержит \n между строками.

license: >
  Это текст, который в исходном YAML
  разбит на строки для читаемости,
  но в результирующей строке будет
  представлен одним абзацем с пробелами
  вместо переводов строк.

Block scalar — это способ записи скалярных значений (строк), занимающих несколько строк, в YAML. Оператор (pipe) используется для verbatim (дословного) сохранения строк, оператор > (greater-than) — для сворачивания строк в один абзац.

{
  "server": {
    "port": 8080,
    "ssl": {
      "enabled": true,
      "certificate": "/etc/ssl/cert.pem"
    }
  },
  "features": ["auth", "logging", "metrics"]
}

server:
  port: 8080
  ssl:
    enabled: true
    certificate: /etc/ssl/cert.pem
features:
  - auth
  - logging
  - metrics

Якорь (anchor) и алиас (alias) — это механизм YAML для повторного использования узлов. &name создаёт якорь для узла, *name создаёт ссылку (алиас) на этот узел. Это позволяет избежать дублирования, но усложняет документ.

Node graph — это промежуточное представление YAML-документа в памяти парсера перед маппингом на Java-объекты. Оно отражает структуру документа независимо от целевого типа данных.

Introspection (интроспекция) — это механизм Java, позволяющий во время выполнения анализировать структуру классов: получать список методов, полей, конструкторов, аннотаций. java.beans.Introspector — стандартный класс для JavaBeans-интроспекции.

Singleton — это паттерн проектирования, гарантирующий, что у класса есть только один экземпляр, и предоставляющий глобальную точку доступа к нему. В Spring Boot все бины по умолчанию — singleton.

Heap dump — это снимок всей кучи JVM в определённый момент времени. Он содержит все объекты, их размеры, ссылки между ними и классы. Анализ heap dump позволяет находить утечки памяти и понимать распределение объектов по поколениям.

import org.yaml.snakeyaml.Yaml;
import java.util.Map;

public class Task060826 {
    public static void main(String[] args) {
        String yaml = "enabled: on\nvalue: 010";
        Yaml yamlParser = new Yaml();
        Map<String, Object> data = yamlParser.load(yaml);
        System.out.println(data.get("enabled") + ", " + data.get("value"));
    }
}