Продвинутое программирование на Java

Рабочий код решает один известный пример. Профессиональный код сохраняет понятное поведение при неверных данных, изменениях требований и работе другого разработчика.

Четыре уровня готовности

Начинаем не с класса, а с контракта

Операция: зарегистрировать платеж

        Вход:
        - orderId — существующий положительный ID
        - amount — положительная сумма в валюте заказа

        Результат:
        - создан уникальный paymentId
        - заказ получает статус PAID

        Ошибки:
        - заказ не найден
        - валюта не совпадает
        - заказ уже оплачен

        Инвариант:
        - один заказ нельзя успешно оплатить дважды

Такой список не является бюрократией. Он заранее показывает места, где понадобятся проверки, типы ошибок, идемпотентность и тесты.

Пакет выражает ответственность

ru.nerosky.payments
        ├── api          // публичные команды и результаты
        ├── domain       // правила предметной области
        ├── application  // сценарии использования
        └── infrastructure
            ├── file     // файловая реализация
            └── http     // интеграция по HTTP

Минимальный публичный API

package ru.nerosky.payments.api;

        public interface PaymentService {
            PaymentReceipt pay(PaymentCommand command);
        }

package ru.nerosky.payments.api;

        import java.math.BigDecimal;
        import java.util.Currency;

        public record PaymentCommand(
            long orderId,
            BigDecimal amount,
            Currency currency
        ) {
        }

Клиенту не нужно видеть внутренние репозитории и вспомогательные классы. Чем меньше публичная поверхность, тем меньше обещаний придется поддерживать.

Definition of Done для учебной задачи

IDE умеет запустить почти любой набор файлов. Команда и CI должны получать тот же результат без ручных настроек разработчика — для этого нужна описанная сборка.

Стандартная структура

advanced-app/
        ├── pom.xml
        ├── src/
        │   ├── main/
        │   │   ├── java/ru/nerosky/app/
        │   │   └── resources/
        │   └── test/
        │       ├── java/ru/nerosky/app/
        │       └── resources/
        └── target/       ← результат сборки, не хранится в Git

Минимальный pom.xml

<?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                                     https://maven.apache.org/xsd/maven-4.0.0.xsd">
            <modelVersion>4.0.0</modelVersion>

            <groupId>ru.nerosky.training</groupId>
            <artifactId>advanced-app</artifactId>
            <version>1.0.0-SNAPSHOT</version>

            <properties>
                <maven.compiler.release>25</maven.compiler.release>
                <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                <junit.version>6.1.0</junit.version>
            </properties>

            <dependencies>
                <dependency>
                    <groupId>org.junit.jupiter</groupId>
                    <artifactId>junit-jupiter</artifactId>
                    <version>${junit.version}</version>
                    <scope>test</scope>
                </dependency>
            </dependencies>

        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.14.1</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                        <version>3.6.0</version>
                    </plugin>
                </plugins>
            </build>
        </project>

Свойство maven.compiler.release задает одновременно синтаксис, формат class-файлов и доступный публичный API выбранного релиза.

Главные команды

mvn clean test       # чистая компиляция и тесты
        mvn clean package    # создать JAR в target/
        mvn dependency:tree # показать дерево зависимостей
        mvn help:effective-pom # итоговая конфигурация после наследования

Scopes зависимостей

JPMS: явная граница модуля

module ru.nerosky.monitor {
            requires java.net.http;

            exports ru.nerosky.monitor.api;
        }

requires объявляет зависимость, exports открывает пакет другим модулям. Не каждый проект обязан немедленно переходить на JPMS, но продвинутый разработчик должен понимать разницу между classpath и module path.

Объект может компилироваться и при этом быть опасным ключом HashMap, отдавать наружу изменяемое состояние или считать одинаковые деньги разными.

Равенство значений и идентичность ссылок

String first = new String("java");
        String second = new String("java");

        System.out.println(first == second);      // false
        System.out.println(first.equals(second)); // true

== для объектов проверяет одну и ту же ссылку. equals отвечает на доменный вопрос «считаются ли значения одинаковыми?».

Контракт equals

• рефлексивность: x.equals(x) всегда true;
• симметричность: если x равен y, то y равен x;
• транзитивность: x = y и y = z означает x = z;
• стабильность: результат не меняется без изменения участвующих данных;
• null: x.equals(null) возвращает false;
• равные объекты обязаны иметь одинаковый hashCode.

Value object для денег

import java.math.BigDecimal;
        import java.math.RoundingMode;
        import java.util.Currency;
        import java.util.Objects;

        public record Money(BigDecimal amount, Currency currency) {
            public Money {
                Objects.requireNonNull(amount, "amount");
                Objects.requireNonNull(currency, "currency");

                int scale = currency.getDefaultFractionDigits();
                if (scale < 0) {
                    throw new IllegalArgumentException("Валюта без стандартной точности");
                }

                amount = amount.setScale(scale, RoundingMode.HALF_EVEN);
            }

            public Money add(Money other) {
                requireSameCurrency(other);
                return new Money(amount.add(other.amount), currency);
            }

            private void requireSameCurrency(Money other) {
                if (!currency.equals(other.currency)) {
                    throw new IllegalArgumentException("Валюты не совпадают");
                }
            }
        }

Record создает корректные equals, hashCode и toString по компонентам. Операция add не меняет объект, а возвращает новое значение.

Защитная копия коллекции

import java.util.List;
        import java.util.Objects;

        public final class Order {
            private final long id;
            private final List<OrderLine> lines;

            public Order(long id, List<OrderLine> lines) {
                if (id <= 0) {
                    throw new IllegalArgumentException("id");
                }
                Objects.requireNonNull(lines, "lines");
                if (lines.isEmpty()) {
                    throw new IllegalArgumentException("Заказ не может быть пустым");
                }

                this.id = id;
                this.lines = List.copyOf(lines);
            }

            public List<OrderLine> lines() {
                return lines;
            }
        }

Если сохранить входной ArrayList напрямую, вызывающий код сможет изменить заказ после конструктора. List.copyOf разрывает этот канал изменения. Элементы списка при этом тоже должны быть неизменяемыми или копироваться отдельно.

BigDecimal.equals и compareTo

var a = new BigDecimal("10.0");
        var b = new BigDecimal("10.00");

        System.out.println(a.equals(b));        // false: разный scale
        System.out.println(a.compareTo(b) == 0); // true: численно равны

import java.time.Instant;
        import java.util.Objects;

        public record TimeRange(Instant start, Instant end) {
            public TimeRange {
                Objects.requireNonNull(start, "start");
                Objects.requireNonNull(end, "end");

                if (end.isBefore(start)) {
                    throw new IllegalArgumentException("Конец раньше начала");
                }
            }

            public boolean contains(Instant moment) {
                Objects.requireNonNull(moment, "moment");
                return !moment.isBefore(start) && !moment.isAfter(end);
            }
        }

Generics — не украшение коллекций. Это способ выразить связь между входами и выходами API так, чтобы ошибку обнаружил компилятор, а не пользователь в production.

Два параметра типа

import java.util.Optional;

        public interface Repository<ID, T> {
            Optional<T> findById(ID id);
            void save(T entity);
            boolean deleteById(ID id);
        }

Repository<Long, User> users = ...;
        Repository<String, Session> sessions = ...;

Один контракт сохраняет связь между типом идентификатора и сущностью. Возврат Object заставил бы клиента выполнять небезопасные приведения.

Ограниченный параметр

static <T extends Comparable<? super T>> T max(
                List<? extends T> values) {
            if (values.isEmpty()) {
                throw new IllegalArgumentException("Пустой список");
            }

            T max = values.getFirst();
            for (T value : values) {
                if (value.compareTo(max) > 0) {
                    max = value;
                }
            }
            return max;
        }

Сигнатура говорит: T можно сравнивать с T или его родительским типом, а входной список может содержать T или его подтип.

Почему List<Integer> не является List<Number>

List<Integer> integers = new ArrayList<>();
        // List<Number> numbers = integers;
        // Иначе сюда можно было бы добавить Double:
        // numbers.add(3.14);

Generics в Java инвариантны. Связь задается wildcard-типами.

PECS: Producer Extends, Consumer Super

static <T> void copy(
                List<? extends T> source,
                List<? super T> target) {
            for (T value : source) {
                target.add(value);
            }
        }

        List<Integer> source = List.of(1, 2, 3);
        List<Number> target = new ArrayList<>();
        copy(source, target);

Type erasure

Большая часть информации о параметрах типа стирается при компиляции. Поэтому ограничения существуют не случайно:

// Нельзя:
        // new T()
        // new T[10]
        // value instanceof List<String>
        // static T shared;

        // Можно:
        if (value instanceof List<?> list) {
            System.out.println(list.size());
        }

Фабрика вместо new T()

import java.util.function.Supplier;

        public final class BoxFactory<T> {
            private final Supplier<T> creator;

            public BoxFactory(Supplier<T> creator) {
                this.creator = creator;
            }

            public T create() {
                return creator.get();
            }
        }

        BoxFactory<ArrayList<String>> factory =
            new BoxFactory<>(ArrayList::new);

static <T> List<T> filter(
                List<? extends T> source,
                Predicate<? super T> predicate) {
            List<T> result = new ArrayList<>();
            for (T value : source) {
                if (predicate.test(value)) {
                    result.add(value);
                }
            }
            return List.copyOf(result);
        }

«Работает на десяти элементах» ничего не говорит о миллионе. Выбор коллекции — это выбор гарантий: порядка, уникальности, поиска и стоимости операций.

Big O — скорость роста, а не секундомер

Практическая карта коллекций

Почему LinkedList редко ускоряет приложение

Теоретически вставка по известному узлу O(1), но сначала узел обычно нужно найти за O(n). Узлы занимают больше памяти и хуже используют процессорный кэш. Для очереди чаще выбирают ArrayDeque, для списка — ArrayList.

Атомарные операции над Map

Map<String, Long> frequency = new HashMap<>();

        for (String word : words) {
            frequency.merge(word, 1L, Long::sum);
        }

Map<String, List<Order>> byCustomer = new HashMap<>();

        for (Order order : orders) {
            byCustomer
                .computeIfAbsent(order.customerId(), ignored -> new ArrayList<>())
                .add(order);
        }

Comparator должен быть предсказуемым

Comparator<User> byNameThenId =
            Comparator.comparing(User::name)
                .thenComparingLong(User::id);

        List<User> sorted = users.stream()
            .sorted(byNameThenId)
            .toList();

Простой ограниченный LRU-кэш

import java.util.LinkedHashMap;
        import java.util.Map;

        public final class LruCache<K, V> extends LinkedHashMap<K, V> {
            private final int capacity;

            public LruCache(int capacity) {
                super(capacity, 0.75f, true);
                if (capacity <= 0) {
                    throw new IllegalArgumentException("capacity");
                }
                this.capacity = capacity;
            }

            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > capacity;
            }
        }

Третий аргумент true включает порядок по обращениям. Это учебный однопоточный кэш: для production нужны политика истечения, метрики и потокобезопасность.

static <T> Set<T> intersection(
                Collection<T> left,
                Collection<T> right) {
            Set<T> index = new HashSet<>(left);
            index.retainAll(right);
            return Set.copyOf(index);
        }

Продвинутый Stream API — это не самая длинная цепочка методов. Это прозрачный pipeline без скрытых изменений, с правильно выбранной терминальной операцией.

Pipeline выполняется только по запросу результата

Stream<String> pipeline = names.stream()
            .filter(name -> {
                System.out.println("Проверяем " + name);
                return name.length() > 4;
            });

        // Пока ничего не напечатано.
        long count = pipeline.count(); // здесь начинается обход

Stream одноразовый. После terminal operation повторно использовать его нельзя. Храните коллекцию или фабрику stream, а не stream в поле.

Группировка с последующей агрегацией

Map<OrderStatus, BigDecimal> totals = orders.stream()
            .collect(Collectors.groupingBy(
                Order::status,
                () -> new EnumMap<>(OrderStatus.class),
                Collectors.reducing(
                    BigDecimal.ZERO,
                    Order::total,
                    BigDecimal::add
                )
            ));

Здесь явно выбрана EnumMap, а downstream collector суммирует значения внутри каждой группы, не создавая промежуточные списки заказов.

flatMap: один объект содержит несколько значений

Set<String> uniqueProductIds = orders.stream()
            .flatMap(order -> order.lines().stream())
            .map(OrderLine::productId)
            .collect(Collectors.toUnmodifiableSet());

Два результата за один проход

record Summary(long count, BigDecimal total) {}

        Summary summary = orders.stream().collect(Collectors.teeing(
            Collectors.counting(),
            Collectors.reducing(
                BigDecimal.ZERO,
                Order::total,
                BigDecimal::add
            ),
            Summary::new
        ));

Optional описывает возможное отсутствие

Optional<User> user = repository.findById(id);

        String displayName = user
            .filter(User::active)
            .map(User::displayName)
            .orElse("Гость");

orElse и orElseGet

User first = optional.orElse(loadExpensiveFallback());
        // fallback вычисляется всегда

        User second = optional.orElseGet(this::loadExpensiveFallback);
        // fallback вычислится только при пустом Optional

Почему parallelStream() не кнопка ускорения

• работа должна быть достаточно крупной, иначе накладные расходы выше пользы;
• операции должны быть независимыми и без общего изменяемого состояния;
• общий ForkJoinPool делится с другим кодом процесса;
• блокирующий I/O обычно не является хорошей задачей для parallel stream;
• ускорение нужно измерять на реалистичных данных.

Map<Department, Optional<Employee>> highestPaid =
            employees.stream().collect(Collectors.groupingBy(
                Employee::department,
                Collectors.maxBy(
                    Comparator.comparing(Employee::salary)
                )
            ));

Современная Java позволяет моделировать закрытый набор состояний так, чтобы компилятор проверял полноту обработки и не допускал невозможных комбинаций.

Команда как закрытый набор вариантов

public sealed interface Command
                permits AddTask, CompleteTask, DeleteTask {
        }

        record AddTask(String title) implements Command {
            AddTask {
                if (title == null || title.isBlank()) {
                    throw new IllegalArgumentException("title");
                }
            }
        }

        record CompleteTask(long id) implements Command {
        }

        record DeleteTask(long id) implements Command {
        }

Исчерпывающая обработка

public final class CommandHandler {
            public String handle(Command command) {
                return switch (command) {
                    case AddTask(var title) ->
                        "Добавить: " + title;
                    case CompleteTask(var id) ->
                        "Завершить #" + id;
                    case DeleteTask(var id) ->
                        "Удалить #" + id;
                };
            }
        }

default не нужен: компилятор знает все разрешенные реализации. Если позже добавить RenameTask, он покажет все switch, которые нужно обновить.

Модель результата операции

public sealed interface PaymentResult {
            record Success(String paymentId) implements PaymentResult {}

            record Rejected(String reason) implements PaymentResult {}

            record TemporaryFailure(
                String reason,
                Duration retryAfter
            ) implements PaymentResult {}
        }

String message = switch (result) {
            case PaymentResult.Success(var id) ->
                "Платеж " + id + " принят";
            case PaymentResult.Rejected(var reason) ->
                "Отклонено: " + reason;
            case PaymentResult.TemporaryFailure(var reason, var retryAfter) ->
                "Повтор через " + retryAfter + ": " + reason;
        };

Когда record не подходит

• объект имеет сложный изменяемый жизненный цикл;
• нужно скрыть представление и предоставить другой публичный API;
• идентичность важнее равенства всех полей;
• требуется наследование от другого класса;
• компоненты record не являются настоящим контрактом модели.

Sealed и расширяемость

Sealed-иерархия хороша, когда владелец модели контролирует все варианты. Для plugin API, куда сторонние команды должны добавлять реализации, обычный открытый интерфейс подходит лучше.

public sealed interface Validation<T> {
            record Valid<T>(T value) implements Validation<T> {}

            record Invalid<T>(List<String> errors)
                    implements Validation<T> {
                public Invalid {
                    errors = List.copyOf(errors);
                    if (errors.isEmpty()) {
                        throw new IllegalArgumentException("Нужна хотя бы одна ошибка");
                    }
                }
            }
        }

Исключение — часть контракта. Клиент должен понимать, можно ли исправить вход, повторить операцию, показать сообщение пользователю или остановить процесс.

Таксономия ошибок

Перевод инфраструктурной ошибки

public final class FileUserRepository implements UserRepository {
            @Override
            public User findRequired(long id) {
                try {
                    return readUser(id);
                } catch (NoSuchFileException error) {
                    throw new UserNotFoundException(id, error);
                } catch (IOException error) {
                    throw new RepositoryException(
                        "Не удалось прочитать пользователя " + id,
                        error
                    );
                }
            }
        }

Верхний слой не обязан знать детали NIO. При этом исходная причина сохраняется через cause, поэтому диагностика не теряется.

Checked или unchecked

Универсального правила нет. Важно не количество throws, а понятный сценарий восстановления. Не оборачивайте все подряд в один безымянный RuntimeException.

Идемпотентность

public record PaymentCommand(
            UUID idempotencyKey,
            long orderId,
            Money amount
        ) {
        }

Повтор одной команды с тем же ключом должен вернуть прежний результат, а не создать второй платеж. Это особенно важно, когда timeout не сообщает, успел ли удаленный сервис выполнить операцию.

Проверка аргументов на границе

public record RegisterUser(String email, String displayName) {
            public RegisterUser {
                email = requireText(email, "email").toLowerCase(Locale.ROOT);
                displayName = requireText(displayName, "displayName");
            }

            private static String requireText(String value, String field) {
                if (value == null || value.isBlank()) {
                    throw new IllegalArgumentException(field + " обязателен");
                }
                return value.trim();
            }
        }

Прерывание потока нужно сохранять

try {
            return client.send(request, BodyHandlers.ofString());
        } catch (InterruptedException error) {
            Thread.currentThread().interrupt();
            throw new ServiceInterruptedException(error);
        }

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

Пять принципов в практической формулировке

Класс, который трудно тестировать

public final class RegistrationService {
            public User register(String email) {
                var repository = new PostgresUserRepository();
                var mailer = new SmtpMailer();
                var user = new User(UUID.randomUUID(), email, Instant.now());

                repository.save(user);
                mailer.sendWelcome(user);
                return user;
            }
        }

Создание конкретных зависимостей, случайность и текущее время спрятаны внутри. Unit-тесту придется подключать PostgreSQL и SMTP, а результат меняется при каждом запуске.

Явные зависимости

public final class RegistrationService {
            private final UserRepository users;
            private final Mailer mailer;
            private final Clock clock;
            private final Supplier<UUID> idGenerator;

            public RegistrationService(
                    UserRepository users,
                    Mailer mailer,
                    Clock clock,
                    Supplier<UUID> idGenerator) {
                this.users = Objects.requireNonNull(users);
                this.mailer = Objects.requireNonNull(mailer);
                this.clock = Objects.requireNonNull(clock);
                this.idGenerator = Objects.requireNonNull(idGenerator);
            }

            public User register(String email) {
                User user = new User(
                    idGenerator.get(),
                    new EmailAddress(email),
                    Instant.now(clock)
                );

                users.save(user);
                mailer.sendWelcome(user);
                return user;
            }
        }

Production-композиция передает PostgreSQL, SMTP, системные часы и UUID. Тест передает in-memory repository, fake mailer, фиксированные часы и известный ID.

Interface Segregation

interface UserReader {
            Optional<User> findByEmail(EmailAddress email);
        }

        interface UserWriter {
            void save(User user);
        }

        final class RegistrationService {
            private final UserReader reader;
            private final UserWriter writer;
            // ...
        }

Разделение оправдано, если клиенты действительно имеют разные потребности. Делить интерфейс механически по одному методу без причины не нужно.

Liskov: реализация не должна удивлять

Если контракт Repository.save обещает сохранение, реализация ReadOnlyRepository, бросающая UnsupportedOperationException, нарушает ожидание. Лучше отдельный интерфейс чтения, чем «реализация», не способная выполнить контракт.

public static void main(String[] args) {
            DataSource dataSource = createDataSource();
            UserRepository users = new JdbcUserRepository(dataSource);
            Mailer mailer = new SmtpMailer(loadMailSettings());

            RegistrationService service = new RegistrationService(
                users,
                mailer,
                Clock.systemUTC(),
                UUID::randomUUID
            );

            new ConsoleApplication(service).run();
        }

Паттерн — имя повторяющегося решения и его компромиссов. Он полезен, когда проблема уже существует, а не когда хочется усложнить три строки кода.

Strategy: заменяемый алгоритм

@FunctionalInterface
        public interface DiscountPolicy {
            Money discountFor(Order order);
        }

DiscountPolicy noDiscount =
            order -> new Money(BigDecimal.ZERO, order.currency());

        DiscountPolicy loyaltyDiscount = order ->
            order.total().multiply(new BigDecimal("0.05"));

Контекст вызывает единый контракт и не содержит растущий switch по типам скидки.

Decorator: добавляем поведение вокруг контракта

public final class CachingUserReader implements UserReader {
            private final UserReader delegate;
            private final Map<Long, User> cache = new HashMap<>();

            public CachingUserReader(UserReader delegate) {
                this.delegate = delegate;
            }

            @Override
            public Optional<User> findById(long id) {
                User cached = cache.get(id);
                if (cached != null) {
                    return Optional.of(cached);
                }

                Optional<User> loaded = delegate.findById(id);
                loaded.ifPresent(user -> cache.put(id, user));
                return loaded;
            }
        }

Тот же прием добавляет метрики, retry, tracing или авторизацию. Клиент продолжает зависеть от UserReader.

Factory: выбор и создание реализации

public final class ReportWriterFactory {
            public ReportWriter create(ReportFormat format) {
                return switch (format) {
                    case CSV -> new CsvReportWriter();
                    case JSON -> new JsonReportWriter();
                };
            }
        }

Factory полезна, когда создание имеет правила, зависимости или несколько вариантов. Для простого new User() отдельная фабрика обычно не нужна.

Adapter: перевод чужого интерфейса

public final class LegacySmsAdapter implements NotificationSender {
            private final LegacySmsClient client;

            public LegacySmsAdapter(LegacySmsClient client) {
                this.client = client;
            }

            @Override
            public void send(Notification notification) {
                client.sendText(
                    notification.recipient().phone(),
                    notification.message()
                );
            }
        }

Как выбрать паттерн

public final class MeasuredUserReader implements UserReader {
            private final UserReader delegate;
            private final Metrics metrics;

            public MeasuredUserReader(UserReader delegate, Metrics metrics) {
                this.delegate = delegate;
                this.metrics = metrics;
            }

            @Override
            public Optional<User> findById(long id) {
                long started = System.nanoTime();
                try {
                    return delegate.findById(id);
                } finally {
                    metrics.record(
                        "users.find",
                        System.nanoTime() - started
                    );
                }
            }
        }

Framework видит @Test, @Entity или @Inject потому, что читает метаданные и строит поведение. Создадим маленький механизм сами.

Собственная аннотация

import java.lang.annotation.ElementType;
        import java.lang.annotation.Retention;
        import java.lang.annotation.RetentionPolicy;
        import java.lang.annotation.Target;

        @Retention(RetentionPolicy.RUNTIME)
        @Target(ElementType.METHOD)
        public @interface Command {
            String value();
            String description() default "";
        }

• RUNTIME сохраняет аннотацию для Reflection API;
• METHOD ограничивает допустимое место применения;
• элементы аннотации имеют ограниченный набор типов и могут иметь default.

Аннотированные методы

public final class AdminCommands {
            @Command(value = "status", description = "Состояние системы")
            public void status() {
                System.out.println("Система работает");
            }

            @Command("cleanup")
            public void cleanup() {
                System.out.println("Очистка завершена");
            }
        }

Сканируем известный объект

import java.lang.reflect.Method;
        import java.util.HashMap;
        import java.util.Map;

        public final class CommandRegistry {
            private final Map<String, Runnable> commands = new HashMap<>();

            public void register(Object handler) {
                for (Method method : handler.getClass().getDeclaredMethods()) {
                    Command annotation = method.getAnnotation(Command.class);
                    if (annotation == null) {
                        continue;
                    }
                    validate(method);

                    Runnable action = () -> invoke(method, handler);
                    Runnable previous = commands.putIfAbsent(
                        annotation.value(),
                        action
                    );
                    if (previous != null) {
                        throw new IllegalStateException(
                            "Команда уже зарегистрирована: " + annotation.value()
                        );
                    }
                }
            }

            private static void validate(Method method) {
                if (method.getParameterCount() != 0
                        || method.getReturnType() != void.class) {
                    throw new IllegalArgumentException(
                        "Команда должна быть void-методом без параметров: " + method
                    );
                }
            }

            private static void invoke(Method method, Object target) {
                try {
                    method.invoke(target);
                } catch (ReflectiveOperationException error) {
                    throw new CommandExecutionException(method.getName(), error);
                }
            }
        }

Dynamic Proxy для интерфейса

import java.lang.reflect.Proxy;

        public final class TimingProxy {
            @SuppressWarnings("unchecked")
            public static <T> T wrap(
                    Class<T> contract,
                    T target,
                    Metrics metrics) {
                return (T) Proxy.newProxyInstance(
                    contract.getClassLoader(),
                    new Class<?>[]{contract},
                    (proxy, method, args) -> {
                        long started = System.nanoTime();
                        try {
                            return method.invoke(target, args);
                        } finally {
                            metrics.record(
                                method.getName(),
                                System.nanoTime() - started
                            );
                        }
                    }
                );
            }
        }

JDK Proxy работает только с интерфейсами. Вызов через reflection оборачивает исключение целевого метода в InvocationTargetException; production-код должен аккуратно извлекать и переводить исходную причину.

Reflection или annotation processing

@Retention(RetentionPolicy.RUNTIME)
        @Target(ElementType.METHOD)
        public @interface Retry {
            int attempts() default 3;
        }

Retry retry = method.getAnnotation(Retry.class);
        int attempts = retry == null ? 1 : retry.attempts();

        if (attempts < 1) {
            throw new IllegalArgumentException("attempts должен быть положительным");
        }

Запись напрямую в основной файл может оставить половину данных после сбоя. Продвинутый код явно выбирает кодировку, закрывает ресурсы и публикует результат атомарно.

Path вместо склеивания строк

Path base = Path.of("data").toAbsolutePath().normalize();
        Path report = base.resolve("reports").resolve("daily.csv");

        if (!report.startsWith(base)) {
            throw new SecurityException("Выход за разрешенную папку");
        }

Нормализация и проверка базового каталога особенно важны, если часть пути приходит от пользователя.

Ленивый обход обязательно закрывается

try (Stream<Path> paths = Files.walk(base)) {
            List<Path> javaFiles = paths
                .filter(Files::isRegularFile)
                .filter(path -> path.toString().endsWith(".java"))
                .toList();
        }

Атомарная публикация файла

import java.io.IOException;
        import java.nio.charset.StandardCharsets;
        import java.nio.file.AtomicMoveNotSupportedException;
        import java.nio.file.Files;
        import java.nio.file.Path;
        import java.nio.file.StandardCopyOption;

        public final class AtomicTextFile {
            public static void write(Path target, String content)
                    throws IOException {
                Path absolute = target.toAbsolutePath();
                Path directory = absolute.getParent();
                Files.createDirectories(directory);

                Path temporary = Files.createTempFile(
                    directory,
                    absolute.getFileName().toString(),
                    ".tmp"
                );

                boolean published = false;
                try {
                    Files.writeString(
                        temporary,
                        content,
                        StandardCharsets.UTF_8
                    );
                    moveIntoPlace(temporary, absolute);
                    published = true;
                } finally {
                    if (!published) {
                        Files.deleteIfExists(temporary);
                    }
                }
            }

            private static void moveIntoPlace(Path source, Path target)
                    throws IOException {
                try {
                    Files.move(
                        source,
                        target,
                        StandardCopyOption.ATOMIC_MOVE,
                        StandardCopyOption.REPLACE_EXISTING
                    );
                } catch (AtomicMoveNotSupportedException error) {
                    Files.move(
                        source,
                        target,
                        StandardCopyOption.REPLACE_EXISTING
                    );
                }
            }
        }

Temporary-файл создается в том же каталоге: так выше шанс поддержки атомарного move в пределах одной файловой системы. Fallback честно признает, что гарантия зависит от платформы.

Потоковое чтение больших данных

long errors;
        try (Stream<String> lines = Files.lines(log, StandardCharsets.UTF_8)) {
            errors = lines
                .filter(line -> line.contains(" ERROR "))
                .count();
        }

Формат данных — отдельный контракт

• зафиксируйте версию формата;
• определите escaping разделителей и переводов строк;
• решите, как читать старую версию;
• не смешивайте доменную модель с деталями CSV/JSON;
• проверяйте размер и структуру недоверенного файла.

Channels и ByteBuffer

Для высокопроизводительного или неблокирующего I/O изучайте FileChannel, SocketChannel и ByteBuffer. Но не заменяйте простой Files.writeString сложным буферным кодом без измеренной причины.

static Path safeResolve(Path root, String userName) {
            Path normalizedRoot = root.toAbsolutePath().normalize();
            Path candidate = normalizedRoot
                .resolve(userName)
                .normalize();

            if (!candidate.startsWith(normalizedRoot)) {
                throw new IllegalArgumentException("Недопустимый путь");
            }
            return candidate;
        }

HTTP-разговор простыми словами

Клиент отправляет request: метод, адрес, заголовки и иногда тело. Сервер возвращает response: статус, заголовки и тело. Статус 404 — это успешно доставленный HTTP-ответ, а не исключение Java. Исключение возникает, например, когда не удалось установить соединение.

Один клиент — много запросов

import java.net.URI;
        import java.net.http.HttpClient;
        import java.net.http.HttpRequest;
        import java.net.http.HttpResponse;
        import java.time.Duration;

        public final class HealthClient {
            private final HttpClient client;

            public HealthClient() {
                this.client = HttpClient.newBuilder()
                    .connectTimeout(Duration.ofSeconds(3))
                    .followRedirects(HttpClient.Redirect.NORMAL)
                    .build();
            }

            public int status(URI uri)
                    throws java.io.IOException, InterruptedException {
                HttpRequest request = HttpRequest.newBuilder(uri)
                    .timeout(Duration.ofSeconds(5))
                    .header("Accept", "application/json")
                    .GET()
                    .build();

                HttpResponse<Void> response = client.send(
                    request,
                    HttpResponse.BodyHandlers.discarding()
                );
                return response.statusCode();
            }
        }

HttpClient безопасен для совместного использования. Создавайте его на уровень приложения или компонента: так клиент сможет повторно использовать соединения. Отдельный клиент на каждый запрос теряет эту пользу и усложняет управление ресурсами.

Синхронно и асинхронно

var future = client.sendAsync(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        future
            .thenApply(HttpResponse::statusCode)
            .thenAccept(code -> System.out.println("Статус: " + code))
            .exceptionally(error -> {
                System.err.println("Сеть недоступна: " + error.getMessage());
                return null;
            });

send проще читать и отлично сочетается с virtual threads. sendAsync полезен, когда приложение уже строит неблокирующую цепочку CompletableFuture. Не выбирайте асинхронный API только ради слова «производительность»: сначала определите модель выполнения.

Retry: повторять можно не всё

GET обычно идемпотентен: повтор не меняет смысл операции. Повторный POST может создать второй заказ или второй платеж. Для изменяющих операций нужны идемпотентные ключи и договоренность с сервером.

static Duration retryDelay(int attempt) {
            long baseMillis = 200L * (1L << Math.min(attempt - 1, 5));
            long jitterMillis = java.util.concurrent.ThreadLocalRandom
                .current()
                .nextLong(100);
            return Duration.ofMillis(baseMillis + jitterMillis);
        }

Экспоненциальная задержка не дает клиентам атаковать восстанавливающийся сервер частыми повторами, а небольшой jitter разводит одновременные попытки разных клиентов. Всегда задавайте предел попыток и общий бюджет времени.

Защитный пояс интеграции

• Rate limit ограничивает частоту обращений.
• Bulkhead не дает одной интеграции занять все ресурсы.
• Circuit breaker временно прекращает заведомо бесполезные запросы.
• Валидация не доверяет внешнему JSON, даже если сервер «наш».
• Наблюдаемость записывает длительность, статус и имя операции без секретов.

public sealed interface HttpResult {
            record Ok(int statusCode) implements HttpResult {}
            record Rejected(int statusCode) implements HttpResult {}
            record Unavailable(String reason) implements HttpResult {}
        }

static HttpResult classify(int statusCode) {
            if (statusCode >= 200 && statusCode < 300) {
                return new HttpResult.Ok(statusCode);
            }
            return new HttpResult.Rejected(statusCode);
        }

Три разные проблемы

counter++ — не одна операция

final class BrokenCounter {
            private long value;

            void increment() {
                value++; // прочитать → прибавить → записать
            }

            long value() {
                return value;
            }
        }

Два потока могут прочитать одно значение и оба записать одинаковый результат. Одно увеличение потеряется. volatile long value улучшит видимость, но не сделает составную операцию атомарной.

import java.util.concurrent.atomic.AtomicLong;

        final class AtomicCounter {
            private final AtomicLong value = new AtomicLong();

            void increment() {
                value.incrementAndGet();
            }

            long value() {
                return value.get();
            }
        }

Happens-before — гарантия видимости

Если действие A happens-before действия B, то эффекты A гарантированно видны B. Это отношение порядка, а не измерение времени по часам.

• выход из synchronized happens-before следующим входом в тот же монитор;
• запись в volatile поле happens-before последующему чтению этого поля;
• вызов Thread.start() публикует ранее подготовленные данные новому потоку;
• завершение потока happens-before успешному возврату из join();
• отношение транзитивно: A → B и B → C означают A → C.

Когда подходит volatile

final class Worker {
            private volatile boolean running = true;

            void stop() {
                running = false;
            }

            void runLoop() {
                while (running) {
                    doOneSmallStep();
                }
            }

            private void doOneSmallStep() {
                // Короткая единица работы.
            }
        }

Здесь одно поле хранит независимое состояние-флаг. Но условие if (balance >= amount) balance -= amount уже состоит из нескольких связанных действий: ему нужен общий lock или другая атомарная модель.

Инвариант определяет границу lock

final class Inventory {
            private int available;
            private int reserved;

            Inventory(int available) {
                this.available = available;
            }

            synchronized boolean reserveOne() {
                if (available == 0) {
                    return false;
                }
                available--;
                reserved++;
                return true;
            }

            synchronized int total() {
                return available + reserved;
            }
        }

Инвариант «общее количество не меняется» связывает два поля, поэтому они защищены одним монитором. Два разных lock сделали бы снимок состояния несогласованным.

Concurrent collections

var counters =
            new java.util.concurrent.ConcurrentHashMap<String, AtomicLong>();

        counters
            .computeIfAbsent("http.200", ignored -> new AtomicLong())
            .incrementAndGet();

ConcurrentHashMap безопасна для конкурентных операций, но не превращает произвольную цепочку get → вычислить → put в одну транзакцию. Используйте ее атомарные методы и держите функцию compute… короткой: не выполняйте внутри медленный I/O и не пытайтесь рекурсивно обновлять тот же ключ.

Deadlock: два замка, два ожидания

Если поток A держит lock X и ждет Y, а поток B держит Y и ждет X, никто не продолжит. Базовая защита — единый порядок захвата: например, всегда сначала lock с меньшим id. Еще лучше — уменьшить число одновременно удерживаемых замков.

final class Limit {
            private long remaining;

            Limit(long remaining) {
                if (remaining < 0) {
                    throw new IllegalArgumentException("Лимит меньше нуля");
                }
                this.remaining = remaining;
            }

            synchronized boolean tryAcquire(long amount) {
                if (amount <= 0) {
                    throw new IllegalArgumentException("Сумма должна быть положительной");
                }
                if (remaining < amount) {
                    return false;
                }
                remaining -= amount;
                return true;
            }

            synchronized long remaining() {
                return remaining;
            }
        }

Structured lifetime без preview API

import java.util.ArrayList;
        import java.util.concurrent.Executors;
        import java.util.concurrent.Future;

        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            var futures = new ArrayList<Future<Integer>>();

            for (var uri : uris) {
                futures.add(executor.submit(() -> client.status(uri)));
            }

            for (var future : futures) {
                System.out.println(future.get());
            }
        }

На каждую задачу создается легкий virtual thread. Блокирующий код остается прямым и читаемым. Закрытие executor прекращает прием новых задач, инициирует штатное завершение и ждет выполнения уже отправленных задач.

Virtual threads не нужно объединять в маленький pool

Их создают по одной на задачу. Если внешний ресурс выдерживает только 20 одновременных запросов, ограничивайте ресурс через Semaphore, пул соединений или rate limiter — не количество virtual threads.

import java.util.concurrent.Semaphore;

        final class LimitedProbe {
            private final Semaphore permits = new Semaphore(20);

            ProbeResult check(Endpoint endpoint) throws InterruptedException {
                permits.acquire();
                try {
                    return performRequest(endpoint);
                } finally {
                    permits.release();
                }
            }

            private ProbeResult performRequest(Endpoint endpoint) {
                // HTTP-вызов.
                throw new UnsupportedOperationException("пример");
            }
        }

Future: результат, timeout, отмена

try {
            var result = future.get(6, java.util.concurrent.TimeUnit.SECONDS);
            consume(result);
        } catch (java.util.concurrent.TimeoutException e) {
            future.cancel(true); // просьба прервать задачу
            reportTimeout();
        } catch (InterruptedException e) {
            future.cancel(true);
            Thread.currentThread().interrupt();
            return;
        } catch (java.util.concurrent.ExecutionException e) {
            throw new IllegalStateException("Задача завершилась с ошибкой", e.getCause());
        }

cancel(true) не уничтожает поток: это кооперативный сигнал. Задача обязана не игнорировать interruption и регулярно доходить до прерываемых операций или проверять флаг.

CompletableFuture для графа зависимостей

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            var profile = java.util.concurrent.CompletableFuture.supplyAsync(
                () -> loadProfile(userId),
                executor
            );
            var orders = java.util.concurrent.CompletableFuture.supplyAsync(
                () -> loadOrders(userId),
                executor
            );

            var page = profile.thenCombine(orders, UserPage::new).join();
        }

Передавайте executor явно, особенно для блокирующей работы. Иначе async-операция часто попадет в общий ForkJoinPool, который вы не контролируете. Длинные цепочки обрабатывайте с единой политикой ошибок и timeout.

Что может пойти не так

• неограниченная очередь быстрее принимает работу, чем система успевает выполнять;
• один потерянный timeout удерживает задачу бесконечно;
• общий изменяемый объект создает race между тысячами легких потоков;
• тяжелые ThreadLocal-объекты умножаются на число virtual threads;
• долгий I/O внутри широкой критической секции блокирует остальных владельцев lock.

Structured Concurrency в Java 25 остается preview-возможностью, поэтому курс намеренно не делает ее основой production-кода. Сначала уверенно освойте стабильные ExecutorService, Future и отмену.

import java.time.Duration;
        import java.time.Instant;
        import java.util.concurrent.Executors;
        import java.util.concurrent.Future;
        import java.util.stream.IntStream;

        public class VirtualThreadLab {
            public static void main(String[] args) throws Exception {
                Instant started = Instant.now();

                try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
                    var tasks = IntStream.range(0, 1_000)
                        .mapToObj(i -> executor.submit(() -> {
                            Thread.sleep(Duration.ofMillis(100));
                            return i;
                        }))
                        .toList();

                    for (Future<Integer> task : tasks) {
                        task.get();
                    }
                }

                System.out.println(Duration.between(started, Instant.now()));
            }
        }

Аранжировка из трех частей

import static org.junit.jupiter.api.Assertions.assertEquals;

        import java.math.BigDecimal;
        import org.junit.jupiter.api.Test;

        class PriceCalculatorTest {
            @Test
            void appliesTenPercentDiscountForPremiumCustomer() {
                // Arrange
                var calculator = new PriceCalculator();
                var price = new BigDecimal("100.00");

                // Act
                var result = calculator.discounted(price, CustomerType.PREMIUM);

                // Assert
                assertEquals(new BigDecimal("90.00"), result);
            }
        }

Название отвечает на вопрос: какое правило проверяется и при каком условии? Комментарии Arrange–Act–Assert полезны в начале; в коротком очевидном тесте их можно убрать.

Проверяйте границы таблицей примеров

import static org.junit.jupiter.api.Assertions.assertEquals;

        import org.junit.jupiter.params.ParameterizedTest;
        import org.junit.jupiter.params.provider.CsvSource;

        class PasswordPolicyTest {
            private final PasswordPolicy policy = new PasswordPolicy(8);

            @ParameterizedTest(name = "[{index}] «{0}» → {1}")
            @CsvSource({
                "'', false",
                "1234567, false",
                "12345678, true",
                "strong-pass, true"
            })
            void validatesMinimumLength(String password, boolean expected) {
                assertEquals(expected, policy.isValid(password));
            }
        }

Для числовой границы нужны примеры граница − 1, граница и граница + 1. Для коллекции — пустая, один элемент, несколько элементов и повторения. Таблица делает пропуски заметными.

Исключение — тоже часть контракта

var error = org.junit.jupiter.api.Assertions.assertThrows(
            IllegalArgumentException.class,
            () -> new Endpoint("", java.net.URI.create("https://example.com"))
        );

        org.junit.jupiter.api.Assertions.assertEquals(
            "Имя не должно быть пустым",
            error.getMessage()
        );

Проверяйте тип и полезную часть сообщения, если сообщение является частью пользовательского или интеграционного контракта. Не привязывайте тест к служебным деталям, которые разрешено менять.

Файловый тест без мусора на машине

import static org.junit.jupiter.api.Assertions.assertEquals;

        import java.nio.file.Files;
        import java.nio.file.Path;
        import org.junit.jupiter.api.Test;
        import org.junit.jupiter.api.io.TempDir;

        class EndpointLoaderTest {
            @TempDir
            Path directory;

            @Test
            void ignoresCommentsAndBlankLines() throws Exception {
                Path config = directory.resolve("endpoints.txt");
                Files.writeString(config, """
                    # production

                    Site|https://example.com
                    """);

                var endpoints = new EndpointLoader().load(config);

                assertEquals(1, endpoints.size());
                assertEquals("Site", endpoints.getFirst().name());
            }
        }

Fake вместо настоящей сети

final class FakeProbe implements Probe {
            private final ProbeResult answer;
            private int calls;

            FakeProbe(ProbeResult answer) {
                this.answer = answer;
            }

            @Override
            public ProbeResult check(Endpoint endpoint) {
                calls++;
                return answer;
            }

            int calls() {
                return calls;
            }
        }

Fake — маленькая рабочая реализация интерфейса для теста. Она часто понятнее сложной конфигурации mock-фреймворка. Mock полезен, когда важно проверить конкретное взаимодействие, но злоупотребление делает тест копией внутренней реализации.

Пирамида проверок

Детерминизм: время и случайность должны приходить снаружи

import java.time.Clock;
        import java.time.Duration;
        import java.time.Instant;

        final class TokenService {
            private final Clock clock;
            private final Duration lifetime;

            TokenService(Clock clock, Duration lifetime) {
                this.clock = clock;
                this.lifetime = lifetime;
            }

            Instant expiresAt() {
                return clock.instant().plus(lifetime);
            }
        }

@org.junit.jupiter.api.Test
        void calculatesExpirationFromInjectedClock() {
            var now = java.time.Instant.parse("2026-07-27T10:00:00Z");
            var clock = java.time.Clock.fixed(now, java.time.ZoneOffset.UTC);
            var service = new TokenService(clock, java.time.Duration.ofMinutes(15));

            org.junit.jupiter.api.Assertions.assertEquals(
                java.time.Instant.parse("2026-07-27T10:15:00Z"),
                service.expiresAt()
            );
        }

Что тестировать в первую очередь

• денежные, доступные и юридически важные правила;
• границы ввода, пустые значения и дубликаты;
• ветви восстановления после ошибок;
• форматы, которыми обмениваются разные компоненты;
• баг, который уже случился: сначала воспроизводящий тест, затем исправление.

import static org.junit.jupiter.api.Assertions.assertEquals;
        import static org.junit.jupiter.api.Assertions.assertInstanceOf;

        import java.net.URI;
        import java.time.Clock;
        import java.time.Duration;
        import java.time.Instant;
        import org.junit.jupiter.api.Test;

        class RetryingProbeTest {
            @Test
            void stopsImmediatelyAfterSuccess() {
                var endpoint = new Endpoint(
                    "NeroSky",
                    URI.create("https://nerosky.ru")
                );
                var success = new ProbeResult.Success(
                    endpoint,
                    200,
                    Instant.EPOCH,
                    Duration.ZERO
                );
                var fake = new FakeProbe(success);
                var probe = new RetryingProbe(
                    fake,
                    3,
                    Duration.ofMillis(100),
                    duration -> {},
                    Clock.systemUTC()
                );

                var result = probe.check(endpoint);

                assertInstanceOf(ProbeResult.Success.class, result);
                assertEquals(1, fake.calls());
            }
        }

Путь кода внутри JVM

1. Class loader находит и загружает bytecode классов.
2. Verifier проверяет структурную корректность и безопасность bytecode.
3. Interpreter начинает выполнять инструкции без долгого разогрева.
4. JIT compiler замечает горячие участки и компилирует их в машинный код.
5. Deoptimization позволяет JVM отказаться от предположения, если оно перестало быть верным.

Поэтому первые вызовы и прогретая система могут иметь разную скорость. Бенчмарк без warmup часто измеряет компиляцию, загрузку классов или работу, которую оптимизатор вообще удалил.

Где живут данные

Рабочий цикл расследования

1. зафиксировать симптом и пользовательский эффект;
2. собрать метрики, логи и профиль в условиях, похожих на реальные;
3. назвать гипотезу: CPU, блокировка, I/O, аллокации, GC или внешний сервис;
4. изменить одну вещь и повторить измерение;
5. проверить корректность, p95/p99 latency и использование ресурсов.

Java Flight Recorder

java -XX:StartFlightRecording=filename=nerosky.jfr,duration=60s \
             -jar target/nerowatch.jar

jcmd <PID> JFR.start \
              name=investigation \
              settings=profile \
              duration=2m \
              filename=investigation.jfr

Запись открывают в JDK Mission Control. Начните с CPU samples, allocation, lock contention, thread states, file/socket I/O и пауз GC. Не собирайте чувствительные данные без политики доступа и хранения.

Микробенчмарк — только через JMH

import java.util.HashSet;
        import java.util.List;
        import java.util.Set;
        import java.util.concurrent.TimeUnit;
        import org.openjdk.jmh.annotations.Benchmark;
        import org.openjdk.jmh.annotations.BenchmarkMode;
        import org.openjdk.jmh.annotations.Mode;
        import org.openjdk.jmh.annotations.OutputTimeUnit;
        import org.openjdk.jmh.annotations.Scope;
        import org.openjdk.jmh.annotations.State;

        @State(Scope.Benchmark)
        @BenchmarkMode(Mode.AverageTime)
        @OutputTimeUnit(TimeUnit.NANOSECONDS)
        public class LookupBenchmark {
            private final List<Integer> list =
                java.util.stream.IntStream.range(0, 10_000).boxed().toList();
            private final Set<Integer> set = new HashSet<>(list);

            @Benchmark
            public boolean listLookup() {
                return list.contains(9_999);
            }

            @Benchmark
            public boolean setLookup() {
                return set.contains(9_999);
            }
        }

JMH управляет warmup, повторениями, fork-процессами и защитой от части оптимизаций. Самодельный цикл с System.nanoTime() почти всегда отвечает не на тот вопрос. Но даже JMH не заменяет нагрузочный тест целого пользовательского сценария.

Наблюдаемость: три сигнала и один контекст

• Logs рассказывают о конкретном событии; используйте уровни и структуру.
• Metrics показывают тенденцию: rate, errors, duration, saturation.
• Traces связывают путь запроса через несколько сервисов.
• Correlation id помогает найти относящиеся к одному запросу события.

logger.info(
            "probe_completed endpoint={} status={} latency_ms={} attempt={}",
            endpoint.name(),
            statusCode,
            latency.toMillis(),
            attempt
        );

Production-готовность — это пределы

Graceful shutdown

После сигнала остановки приложение прекращает принимать новую работу, дает текущим операциям ограниченное время завершиться, сохраняет нужное состояние и закрывает ресурсы. Shutdown hook должен быть коротким, идемпотентным и иметь собственный deadline.

Перед релизом

• зависимости проверяются на известные уязвимости и регулярно обновляются;
• секреты приходят из защищенной конфигурации, а не из репозитория;
• права процесса минимальны;
• есть health/readiness-сигналы и понятный runbook;
• резервное восстановление проверено практикой, а не только наличием файла backup.