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"));
    }
}

import java.util.Objects;

public class Person implements Comparable<Person> {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //Нарушение: compareTo не согласован с equals
    // @Override
    // public int compareTo(Person o) {
    //     return this.age - o.age; // Только по возрасту
    // }
    // // equals по имени и возрасту
    // public boolean equals(Object o) {
    //     if (!(o instanceof Person)) return false;
    //     Person p = (Person) o;
    //     return name.equals(p.name) && age == p.age;
    // }

    //Корректно: compareTo использует те же поля, что и equals
    @Override
    public int compareTo(Person o) {
        int nameComp = this.name.compareTo(o.name);
        if (nameComp != 0) return nameComp;
        return Integer.compare(this.age, o.age);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person p = (Person) o;
        return age == p.age && name.equals(p.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return name + "(" + age + ")";
    }

    public static void main(String[] args) {
        // Демонстрация нарушения
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Bob", 30);

        // Если compareTo только по возрасту, то p1.compareTo(p2) == 0,
        // хотя equals вернет false (имена разные).
        // TreeSet считает их одинаковыми
        TreeSet<Person> set = new TreeSet<>();
        set.add(p1);
        set.add(p2);
        System.out.println("Size: " + set.size()); // Должно быть 1, если compareTo=0
        System.out.println("Contains Alice? " + set.contains(p1)); // true
        System.out.println("Contains Bob? " + set.contains(p2));   // true? Зависит от реализации
        // На самом деле, если compareTo=0, то при добавлении второго он будет считаться дубликатом
        // и не будет добавлен, но contains для Bob вернет true, потому что TreeSet использует compareTo
        // для поиска, а не equals. Это делает поведение непредсказуемым.
    }
}