# Вопросы на собеседовании по Java

237 вопросов с реальных собеседований. Здесь открытые: первые вопросы каждой подтемы с коротким ответом (первый абзац эталона) и источником. Все вопросы с ответами и AI-разбором — в тренажёре JobJump.

Страница: https://jobjump.app/questions/java

## Ядро языка и типы

### Чем отличаются JDK, JRE и JVM?

JVM исполняет байт-код, JRE — это JVM плюс библиотеки классов, JDK — это JRE плюс инструменты разработки.

Источник: https://docs.oracle.com/javase/specs/jvms/se25/html/jvms-1.html

### В чём разница между примитивными и ссылочными типами?

Примитивных типов **восемь** (byte, short, int, long, float, double, char, boolean): переменная хранит само значение фиксированного размера, обычно в стеке (или прямо в объекте как поле), у поля значение по умолчанию 0/false (локальную переменную нужно инициализировать явно), null для примитивов недопустим.

Источник: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

### Java передаёт аргументы по значению или по ссылке?

Java всегда передаёт аргументы по значению: метод получает копию значения, а для объектов — копию ссылки.

Источник: https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html

### Почему String в Java неизменяемый и что такое пул строк?

String **неизменяем** (immutable): после создания содержимое объекта строки менять нельзя, любые «модифицирующие» методы возвращают новую строку. Это позволяет безопасно делиться одним объектом между потоками без синхронизации (неизменяемый объект нельзя увидеть в промежуточном состоянии) и безопасно использовать строку как ключ HashMap: контракт Map не определяет поведение, если ключ изменили так, что изменился результат equals. Благодаря неизменяемости работает пул строк (String pool): в нём находятся все строковые литералы и значения константных выражений типа String, а также строки, на которых вызвали intern(). Одинаковые литералы ссылаются на один объект, что экономит память. Строки, созданные через **new String("…")**, в пул не попадают автоматически (это отдельный объект в куче), но их можно добавить туда вызовом intern(). Поэтому "a" == "a" всегда true (JLS 3.10.5: литерал всегда ссылается на один и тот же экземпляр String), а new String("a") == "a" — false.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/String.html

### В чём разница между == и equals при сравнении строк?

`==` сравнивает ссылки, `equals` у `String` сравнивает содержимое, поэтому строки сравнивают через `equals`.

Источник: https://docs.oracle.com/javase/specs/jls/se25/html/jls-3.html#jls-3.10.5

## ООП

### Что такое ООП и каковы его основные принципы?

ООП — подход, в котором программа строится из объектов, объединяющих состояние (поля) и поведение (методы); основные принципы — инкапсуляция, наследование, полиморфизм и абстракция.

Источник: https://docs.oracle.com/javase/tutorial/java/concepts/object.html

### Какие виды полиморфизма есть в Java и чем отличается статический от динамического?

Статический полиморфизм — перегрузка: метод выбирает компилятор по типам аргументов; динамический — переопределение: метод выбирает JVM по фактическому типу объекта во время выполнения.

Источник: https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html

### В чём разница между перегрузкой (overloading) и переопределением (overriding)?

Перегрузка — несколько методов с одним именем и разными параметрами, выбор делает компилятор; переопределение — метод подкласса с той же сигнатурой заменяет метод суперкласса, выбор делается во время выполнения.

Источник: https://docs.oracle.com/javase/tutorial/java/IandI/override.html

## Коллекции

### Как устроена иерархия Collection и чем отличаются List, Set и Map?

`Collection` — корень иерархии для групп элементов, и в неё не входит `Map`: `List` хранит упорядоченную последовательность с дубликатами, `Set` — уникальные элементы, `Map` — пары «ключ — значение» с уникальными ключами.

Источник: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html

### В чём разница между ArrayList и LinkedList?

**ArrayList** — динамический массив: доступ по индексу за **O(1)**, но вставка/удаление в середине требует сдвига элементов **O(n)**, а при переполнении массив перевыделяется с запасом. **LinkedList** — двусвязный список: вставка в начало и удаление из внутренней части при обходе итератором стоят **O(1)** (через addFirst/removeFirst и ListIterator), но доступ по индексу линейный **O(n)**, так как операции по индексу идут по ссылкам от ближнего края, и на каждый элемент тратится отдельный объект-узел.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/ArrayList.html

### Как HashMap устроен под капотом (put, бакеты, коллизии)?

**HashMap** — хеш-таблица из массива бакетов. При put() у ключа берётся hashCode(), затем применяется дополнительное перемешивание битов (h ^ (h >>> 16)), и индекс бакета берётся как (n - 1) & hash, где n — размер таблицы, степень двойки. Если бакет пуст — кладётся запись; при коллизии (разные ключи в один бакет) элементы связываются в цепочку. Начиная с Java 8, при добавлении в цепочку, где уже 8 узлов (TREEIFY\_THRESHOLD = 8), и если массив бакетов не короче 64 (MIN\_TREEIFY\_CAPACITY; иначе таблица расширяется), список превращается в дерево; по комментарию в исходном коде это даёт худший случай **O(log n)**, если у ключей различные хеши либо ключи реализуют Comparable. Дубликат ключа определяется через **hashCode + equals** и перезаписывает значение. По умолчанию начальная ёмкость 16 и load factor 0.75; при превышении порога происходит resize с удвоением и перераспределением. Документация обещает константное время put/get при условии, что хеш-функция хорошо распределяет элементы по бакетам.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/HashMap.html

### Чем HashMap отличается от Hashtable и ConcurrentHashMap?

**HashMap** не синхронизирован, допускает один null-ключ и null-значения, быстр, но не потокобезопасен: если несколько потоков работают с картой и хотя бы один изменяет её структуру, нужна внешняя синхронизация. **Hashtable** — унаследованный (legacy) класс, документация рекомендует HashMap или ConcurrentHashMap: все методы synchronized целиком, null не допускает, блокировка на весь объект делает его медленным при конкуренции. **ConcurrentHashMap** — современный потокобезопасный вариант: чтения обычно без блокировок, записи блокируют лишь отдельный бакет (с Java 8 — через CAS и synchronized на голове бакета, без старой сегментной блокировки), что даёт высокую конкурентность; null-ключи и null-значения запрещены. Каждая отдельная операция потокобезопасна, но последовательность «проверил, затем записал» (if (!m.containsKey(k)) m.put(k, v)) атомарной не становится: для этого есть putIfAbsent, computeIfAbsent, compute и merge.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html

## Дженерики

### Зачем нужны дженерики и что такое стирание типов (type erasure)?

Дженерики дают параметризацию по типу: коллекции и классы работают с конкретным типом, а компилятор проверяет типобезопасность и избавляет от ручных приведений (ошибка типа обнаруживается при компиляции, а не как ClassCastException в рантайме, если код не содержит unchecked-предупреждений). **Реализованы** они **через стирание типов** (type erasure): аргументы типа экземпляров проверяются только при компиляции, а в байт-коде List<String> и List<Integer> превращаются в один сырой List, параметры заменяются на границы (обычно Object). Метаданные объявлений остаются в атрибуте Signature класса, поэтому через рефлексию можно узнать, например, что поле объявлено как List<String>. Компилятор вставляет нужные приведения автоматически.

Источник: https://docs.oracle.com/javase/tutorial/java/generics/erasure.html

### Что такое wildcard-типы и принцип PECS?

**Wildcard «?»** — неизвестный тип-заполнитель. Ограниченные wildcard задают направление: **extends** — верхняя граница (? extends Number — «какой-то подтип Number»), **super** — нижняя (? super Integer — «Integer или его супертип»). Нужны они, потому что **дженерики инвариантны**: List<Integer> не является List<Number>, и wildcard возвращает нужную гибкость.

Источник: https://docs.oracle.com/javase/tutorial/java/generics/wildcards.html

### Что такое ограниченные параметры типа (bounded type parameters)?

Ограниченный параметр типа `<T extends Number>` разрешает подставлять только `Number` и его подтипы, а внутри кода позволяет вызывать методы границы.

Источник: https://docs.oracle.com/javase/tutorial/java/generics/bounded.html

## Функциональное программирование и Stream API

### Как работает лямбда-выражение в Java под капотом?

**Лямбда** — компактная запись реализации функционального интерфейса (интерфейса с одним абстрактным методом). Это не просто «сахар» над анонимным классом: значение лямбды — ссылка на объект класса, реализующего функциональный интерфейс, тождество этого объекта непредсказуемо, а новый объект при каждом вычислении создавать не обязательно (JLS 15.27.4); this и имена внутри лямбды те же, что в окружающем коде. Во что именно компилируется лямбда, спецификация языка не определяет. В реализации javac, как правило, тело лямбды становится синтетическим private-методом, а на месте лямбды ставится инструкция invokedynamic: при первом исполнении она вызывает bootstrap-метод LambdaMetafactory, тот возвращает CallSite, который выдаёт объекты-реализации (новые или уже существующие). Это деталь реализации, а не часть языка. Лямбда захватывает локальные переменные и параметры, которые должны быть final или effectively final; поля это ограничение не затрагивает.

Источник: https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

### Что такое функциональный интерфейс и какие встроенные бывают?

Функциональный интерфейс — интерфейс с ровно одним абстрактным методом: для него можно написать лямбду или ссылку на метод.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/function/package-summary.html

### В чём разница между промежуточными и терминальными операциями Stream?

Промежуточные операции (filter, map, sorted, distinct, limit) возвращают новый стрим и ленивы: они не выполняются в момент вызова, а лишь описывают конвейер обработки.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/stream/package-summary.html

### Почему стримы ленивы и что произойдёт при повторном вызове терминальной операции?

Ленивость означает, что промежуточные операции **лишь строят план обработки и ничего не считают до терминальной операции**. Это даёт две выгоды. **Во-первых**, слияние операций (fusion): в конвейере из операций без состояния каждый элемент проходит через всю цепочку за один проход, без промежуточных коллекций (операции вроде sorted этому мешают). **Во-вторых**, short-circuit: операции вроде findFirst, anyMatch или limit могут остановить обход, не перебирая все элементы, что позволяет работать с очень большими и даже бесконечными источниками (Stream.iterate + limit).

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/stream/Stream.html

## Многопоточность

### В чём разница между процессом и потоком?

**Процесс** — отдельная единица выполнения со своим изолированным адресным пространством и ресурсами ОС. **Поток** — единица выполнения внутри процесса; потоки одного процесса разделяют общие ресурсы, включая память и открытые файлы, но у каждого потока JVM есть собственный стек и собственный счётчик команд (pc register).

Источник: https://docs.oracle.com/javase/tutorial/essential/concurrency/procthread.html

### Какие состояния есть у потока (Thread.State) и как он между ними переходит?

Enum Thread.State определяет шесть состояний. **NEW** — поток создан, но не запущен (start() не вызван). **RUNNABLE** — поток исполняется в JVM, но может ждать других ресурсов ОС, например процессор (отдельного «running» в Java нет). **BLOCKED** — ждёт монитор, чтобы войти в synchronized-секцию или вернуться в неё после Object.wait(). **WAITING** — ждёт бессрочно другого потока (wait() без таймаута, join() без таймаута, LockSupport.park()). **TIMED\_WAITING** — то же с положительным таймаутом (sleep(ms), wait(ms), join(ms)). **TERMINATED** — метод run завершился. Поток из NEW переходит в RUNNABLE через start(); из RUNNABLE может уйти в BLOCKED, WAITING или TIMED\_WAITING и вернуться обратно. Выход из wait() идёт через BLOCKED: поток после notify или таймаута должен заново получить монитор. Из TERMINATED возврата нет: повторный start() бросит IllegalThreadStateException.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/Thread.State.html

### В чём разница между Runnable и Callable?

Оба описывают задачу для выполнения в потоке, но **Runnable.run()** ничего не возвращает и не может бросать проверяемые исключения, а **Callable.call()** возвращает результат (дженерик-тип) и может бросать checked-исключения. **Runnable** подходит, когда результат не нужен; его можно передать в new Thread(…) или в ExecutorService.execute/submit. **Callable** используют, когда нужен результат вычисления или проброс исключения — его отдают в ExecutorService.submit(callable) и получают Future<T>, через который позже забирают результат методом get() (он ждёт завершения задачи) или узнают об ошибке. submit(Runnable) тоже возвращает Future, но get() у него вернёт null: результата у Runnable нет.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/concurrent/Callable.html

### В чём разница между synchronized и volatile?

**volatile** гарантирует видимость: запись в volatile-переменную синхронизирована-с (synchronizes-with) каждым последующим чтением этой переменной любым потоком, то есть happens-before. Поток, прочитавший volatile, видит не только последнее значение, но и результаты действий, которые этому значению предшествовали. Чтение и запись volatile-переменной атомарны, включая long и double. Но volatile не делает атомарными составные операции: count++ (чтение-инкремент-запись) остаётся гоночным. **synchronized** обеспечивает и взаимное исключение (в блок или метод на данном мониторе входит только один поток), и видимость: освобождение монитора happens-before каждого последующего захвата того же монитора.

Источник: https://docs.oracle.com/javase/tutorial/essential/concurrency/atomic.html

### Что такое атомарные классы и как работает CAS?

Классы из java.util.concurrent.atomic (например, AtomicInteger, AtomicLong, AtomicReference) дают атомарные операции над одной переменной без блокировок — пакет описан как набор классов для lock-free потокобезопасного программирования на одиночных переменных. В основе — **CAS** (Compare-And-Swap): атомарная операция, которая сравнивает текущее значение ячейки с ожидаемым и, если они совпали, записывает новое; иначе ничего не делает и сообщает о неуспехе. Атомик в цикле читает значение, вычисляет новое и пытается применить CAS, повторяя, пока не удастся (оптимистично). **Плюс** — нет блокировок потока и переключений контекста при ожидании. **Минус** — при высокой конкуренции много «холостых» повторов: для счётчика, который обновляют многие потоки, Javadoc советует LongAdder, у которого при высокой конкуренции ожидаемая пропускная способность значительно выше, ценой большего расхода памяти. Ещё CAS видит только равенство значений, поэтому уязвим к ABA (значение сменилось и вернулось, а сравнение этого не заметит); от неё помогает версия вместе со ссылкой, как в AtomicStampedReference, который хранит ссылку вместе с целочисленной «меткой», обновляемыми атомарно.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/concurrent/atomic/package-summary.html

### Зачем нужен ExecutorService и в чём проблема ручного создания потоков?

Создавать поток на каждую задачу **через new Thread() дорого**: объекты потоков занимают заметную память, а выделение и освобождение множества таких объектов создаёт значительные накладные расходы на управление памятью. Без ограничения числа потоков пик нагрузки исчерпает память.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/concurrent/ExecutorService.html

## JVM, память и сборка мусора

### Как устроена память JVM (heap, stack, metaspace)?

Память JVM делится на области с разным назначением и разными лимитами.

Источник: https://docs.oracle.com/javase/specs/jvms/se25/html/jvms-2.html

### Как работает сборка мусора в JVM и что такое поколения объектов?

Сборщик мусора автоматически освобождает память объектов, которые стали недостижимыми: достижим объект, к которому можно обратиться в любом возможном продолжении вычисления из живого потока (например, через локальные переменные потоков или статические поля). Циклы ссылок друг на друга собираются, если из достижимых объектов к ним дойти нельзя. Работа опирается на **«слабую гипотезу о поколениях»**: большинство объектов живёт недолго. Поэтому у поколенческих сборщиков память делится на молодое поколение и старое. В классической схеме (Serial, Parallel) молодое поколение состоит из Eden и двух Survivor: новые объекты создаются в Eden, частые и дешёвые minor-сборки чистят только молодое поколение, а пережившие несколько сборок объекты продвигаются в старое, которое собирается реже и дороже (major-сборка затрагивает всю кучу). В G1 то же делают регионы кучи одинакового размера, а не два непрерывных пространства. Такое разделение сокращает объём работы GC, ведь чаще всего собирается короткоживущий мусор.

Источник: https://docs.oracle.com/en/java/javase/25/gctuning/garbage-collector-implementation.html

### Какие сборщики мусора есть в JVM и какой используется по умолчанию?

В HotSpot несколько основных сборщиков под разные цели.

Источник: https://docs.oracle.com/en/java/javase/25/gctuning/available-collectors.html

### Что такое модель памяти Java (JMM) и отношение happens-before?

**JMM** (Java Memory Model) — часть спецификации языка, определяющая, какие значения может увидеть чтение общей переменной, обновляемой несколькими потоками. Без синхронизации компилятор, процессор и кеши вправе переупорядочивать и кешировать обращения к памяти, из-за чего один поток может не увидеть изменения другого.

Источник: https://docs.oracle.com/javase/specs/jls/se25/html/jls-17.html

### Как работает загрузка классов и делегирование class loader'ов?

Класс проходит стадии: **загрузка** (чтение байт-кода и создание объекта Class), **связывание** (верификация **байт-кода**, **подготовка статических полей значениями по умолчанию**, разрешение ссылок) и **инициализация** (выполнение статических инициализаторов и присваиваний), которая происходит при первом активном использовании класса. Когда именно выполняются загрузка и связывание, спецификация оставляет реализации; HotSpot обычно делает это лениво. Загрузчики образуют иерархию: bootstrap (базовые модули платформы, прежде всего java.base), platform (остальные модули платформы Java SE) и application (system, classpath приложения). Загрузчик по умолчанию делегирует загрузку родителю (parent-first) и берётся сам, только если родитель не смог; Javadoc оговаривает, что модель не обязана быть строго иерархической. Это защищает от подмены системных классов. Идентичность класса в JVM определяется парой «двоичное имя + определяющий загрузчик», поэтому один и тот же класс, загруженный разными загрузчиками, — это разные типы, и между ними возможен ClassCastException.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/ClassLoader.html

## Spring Core: IoC, бины, AOP

### Что такое инверсия управления (IoC) и внедрение зависимостей (DI)?

IoC — принцип, по которому создаёт объекты и связывает зависимости не сам код, а контейнер; DI — способ реализовать IoC, когда объект получает зависимости извне, а не создаёт их через `new`.

Источник: https://docs.spring.io/spring-framework/reference/core/beans/dependencies/factory-collaborators.html

### Какие скоупы (scopes) бинов есть в Spring?

В Spring скоупы `singleton` (по умолчанию), `prototype` и веб-скоупы `request`, `session`, `application`, `websocket`; скоуп определяет, сколько экземпляров бина создаёт контейнер и сколько они живут.

Источник: https://docs.spring.io/spring-framework/reference/core/beans/factory-scopes.html

### Как выглядит жизненный цикл бина в Spring?

Контейнер сначала читает определения бинов и применяет **BeanFactoryPostProcessor'ы** к самим определениям (например, подстановка property из конфигурации). Затем для каждого бина: создаёт экземпляр (конструктор), внедряет зависимости, вызывает Aware-колбэки (BeanNameAware, BeanFactoryAware; ApplicationContextAware применяет встроенный BeanPostProcessor), затем postProcessBeforeInitialization всех BeanPostProcessor'ов — в этот шаг входит и @PostConstruct, его обрабатывает CommonAnnotationBeanPostProcessor, — затем InitializingBean.afterPropertiesSet и init-method, затем postProcessAfterInitialization (здесь обычно создаётся AOP-прокси). Дальше бин готов к работе.

Источник: https://docs.spring.io/spring-framework/reference/core/beans/factory-nature.html

### Чем BeanPostProcessor отличается от BeanFactoryPostProcessor?

`BeanFactoryPostProcessor` меняет определения бинов до создания экземпляров, `BeanPostProcessor` обрабатывает уже созданные бины вокруг их инициализации.

Источник: https://docs.spring.io/spring-framework/reference/core/beans/factory-extension.html

### Как Spring выбирает бин, если реализаций несколько (@Qualifier против @Primary)?

Сначала @Qualifier в точке внедрения сужает кандидатов по метке; если их всё ещё несколько, берётся бин с @Primary; если не помогло и это, Spring пробует сопоставить имя поля или параметра с именем бина и бросает NoUniqueBeanDefinitionException, когда неоднозначность осталась.

Источник: https://docs.spring.io/spring-framework/reference/core/beans/annotation-config/autowired-qualifiers.html

## Spring Boot и Spring MVC

### В чём преимущества Spring Boot по сравнению с обычным Spring?

Spring Boot не заменяет Spring, а настраивает его за вас: стартеры, автоконфигурация и встроенный сервер дают готовое приложение с минимумом настройки.

Источник: https://docs.spring.io/spring-boot/reference/using/auto-configuration.html

### Как работают стартеры и автоконфигурация в Spring Boot?

Стартер — это «**мета-зависимость**»: пустой артефакт, который транзитивно подтягивает согласованный набор библиотек под задачу (spring-boot-starter-webmvc тянет Spring MVC и встроенный Tomcat). Он решает проблему подбора совместимых версий. Автоконфигурация — набор конфигурационных классов, помеченных **@AutoConfiguration** и условными аннотациями **@ConditionalOnClass**, **@ConditionalOnMissingBean**, **@ConditionalOnProperty**. При старте Spring Boot читает файл META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports (по одному имени класса в строке) и применяет только те классы, чьи условия выполнены: есть класс в classpath, нет вручную заданного бина и т.д. (Регистрация в spring.factories работала до Boot 3.0, там её убрали.) Поэтому конфигурация «сама собирается» из того, что подключено, но любой автосконфигурированный бин можно переопределить, объявив свой — @ConditionalOnMissingBean уступит ему дорогу.

Источник: https://docs.spring.io/spring-boot/reference/features/developing-auto-configuration.html

### Для чего нужен Spring Boot Actuator?

Actuator добавляет в приложение готовые endpoints для наблюдения и управления: здоровье, метрики, сведения о сборке и окружении, логгеры.

Источник: https://docs.spring.io/spring-boot/reference/actuator/endpoints.html

## Транзакции в Spring

### Как аннотация @Transactional работает под капотом?

@Transactional **реализована через Spring AOP и прокси**. При старте бин с транзакционными методами оборачивается прокси; внешний вызов метода идёт через прокси, где **TransactionInterceptor** (advice вокруг метода) через **TransactionManager** (для обычного кода — PlatformTransactionManager) открывает транзакцию или присоединяется к текущей, а после метода коммитит при успешном завершении или откатывает при исключении; если внешняя транзакция была приостановлена, она возобновляется.

Источник: https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/annotations.html

### Почему @Transactional не срабатывает при self-invocation и как это исправить?

Транзакция навешивается прокси, который перехватывает только вызовы, приходящие снаружи через ссылку на бин. Когда метод объекта вызывает другой его же метод напрямую (this.method()), вызов идёт мимо прокси — прямо на целевой объект, — поэтому advice @Transactional (как и @Async, @Cacheable) **не срабатывает**, даже если у внутреннего метода стоит своя аннотация с другим propagation.

Источник: https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/annotations.html

### Что такое propagation у @Transactional и какие у него режимы?

Propagation задаёт, как метод с `@Transactional` ведёт себя, когда транзакция уже открыта; по умолчанию `REQUIRED` — присоединиться к текущей или создать новую.

Источник: https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/tx-propagation.html

## Hibernate и JPA

### Какие состояния сущности есть в JPA и когда они возникают?

У сущности JPA четыре состояния относительно контекста персистентности: transient (new), managed, detached и removed.

Источник: https://docs.hibernate.org/orm/7.2/userguide/html_single/#pc

### Что такое проблема N+1 запросов и как её решать в Hibernate?

N+1 — это один запрос списка из N сущностей плюс по одному запросу на ленивую связь каждой: итого 1 + N запросов вместо одного-двух. Это резко нагружает БД и замедляет ответ.

Источник: https://docs.hibernate.org/orm/7.2/userguide/html_single/#fetching

### В чём разница между ленивой и жадной загрузкой и когда возникает LazyInitializationException?

FetchType.LAZY разрешает провайдеру отложить загрузку связи до первого обращения к ней (это подсказка), а FetchType.EAGER требует загрузить связь сразу вместе с владельцем. По умолчанию @OneToMany/@ManyToMany ленивы, а @ManyToOne/@OneToOne — жадные. LazyInitializationException возникает при обращении к неинициализированной ленивой связи, когда сессия (persistence context) уже закрыта: сущность стала detached, а прокси связи не может сходить в БД.

Источник: https://docs.hibernate.org/orm/7.2/userguide/html_single/#fetching-strategies

### Какие уровни кэша есть в Hibernate и чем они отличаются?

В Hibernate два уровня кэша данных и отдельный кэш запросов. **Кэш первого уровня** (L1) — это сам persistence context (Session): он всегда включён и живёт, пока открыта сессия. В нём каждая загруженная сущность существует в единственном экземпляре, и повторный find по тому же id в рамках сессии не идёт в БД.

Источник: https://docs.hibernate.org/orm/7.2/userguide/html_single/#caching

### Как правильно переопределять equals и hashCode у Entity в Hibernate?

Лучше всего реализовать equals и hashCode по бизнес-ключу — натуральному уникальному полю, если оно есть. Если бизнес-ключа нет, документация Hibernate советует подумать, не оставить ли equals и hashCode вовсе нереализованными: внутри одной сессии строке соответствует один объект. Если нужно сравнивать по id, нужен обходной приём: hashCode возвращает константу, чтобы хеш не менялся до и после flush, а equals сравнивает id только у не-transient сущностей.

Источник: https://docs.hibernate.org/orm/7.2/userguide/html_single/#mapping-model-pojo-equalshashcode

### Какие стратегии маппинга наследования есть в Hibernate/JPA?

Три стратегии (аннотация @Inheritance). **SINGLE\_TABLE** (по умолчанию) — вся иерархия в одной таблице с колонкой-дискриминатором; быстро (без джойнов), но поля подклассов должны быть nullable, и это мешает ставить NOT NULL. **JOINED** — по таблице на класс, связанных по первичному ключу; нормализовано и позволяет NOT NULL, но чтение требует джойнов. **TABLE\_PER\_CLASS** — по таблице на конкретный класс, каждая содержит все поля; полиморфные запросы дороги (UNION), поддержка этой стратегии для провайдера необязательна по спецификации, а Hibernate советует её избегать, потому что она даёт неэффективный SQL. Есть и @MappedSuperclass — не настоящая стратегия наследования сущностей, а способ вынести общие поля в родителя, который сам не сущность и не участвует в полиморфных запросах.

Источник: https://docs.hibernate.org/orm/7.2/userguide/html_single/#entity-inheritance

## Базы данных и SQL

### Что такое индексы, зачем они нужны и какие типы бывают в PostgreSQL?

Индекс — вспомогательная структура, ускоряющая поиск строк по значению столбца: вместо полного сканирования таблицы СУБД идёт по индексу. По умолчанию в PostgreSQL это B-Tree — сбалансированное дерево, дающее поиск, диапазонные запросы и сортировку за O(log n); он поддерживает =, <, >, BETWEEN, ORDER BY и префиксный LIKE 'abc%'.

Источник: https://www.postgresql.org/docs/current/indexes-types.html

### Почему нельзя просто поставить индексы на все поля и все их комбинации?

Индексы не бесплатны. Каждый индекс — **это отдельная структура**, которую нужно синхронно обновлять при каждой вставке, обновлении и удалении, поэтому чем их больше, тем медленнее запись и тем больше нагрузка и объём на диске. Комбинаций полей экспоненциально много — покрыть все невозможно и бессмысленно. К тому же индекс полезен лишь при хорошей селективности: на столбце с малым числом различных значений (пол, boolean, статус) планировщик часто вообще проигнорирует индекс, предпочтя последовательное сканирование, так что индекс будет только вредить записи, не ускоряя чтение.

Источник: https://www.postgresql.org/docs/current/indexes-intro.html

### В чём разница между оптимистичной и пессимистичной блокировкой?

**Пессимистичная блокировка** исходит из того, что конфликты вероятны: строка блокируется на время работы (в SQL — SELECT … FOR UPDATE), и другие транзакции ждут её освобождения. Надёжно при высокой конкуренции за одни и те же данные, но снижает параллелизм и рискует дедлоками. **Оптимистичная блокировка** не держит блокировок: она предполагает, что конфликты редки, и проверяет их только при сохранении. Для этого у строки есть колонка версии (число или timestamp); при UPDATE проверяется, что версия не изменилась с момента чтения (WHERE version = ?), и версия инкрементируется. Если кто-то успел изменить строку, версия не совпадёт, обновление не пройдёт и приложение получит ошибку конкуренции (в JPA — @Version и OptimisticLockException), после чего перечитывает и повторяет.

Источник: https://www.postgresql.org/docs/current/explicit-locking.html

## Kafka и обмен сообщениями

### Как устроена Kafka (брокер, топик, партиция)?

**Kafka** — распределённый лог сообщений. Сообщения публикуются в **топики** — именованные категории. Каждый топик разбит на **партиции** — упорядоченные, только дописываемые (append-only) логи; именно партиция обеспечивает и параллелизм, и порядок. Внутри партиции сообщения строго упорядочены и получают возрастающий offset; между партициями глобального порядка нет. Партиции распределяются по **брокерам** (узлам кластера) и реплицируются для отказоустойчивости: одна реплика — лидер (принимает запись), остальные — фолловеры, копирующие лог лидера; реплики, которые не отстают от лидера (включая его самого), образуют набор синхронных реплик — **ISR**. Продюсер выбирает партицию по ключу (одинаковый ключ → одна партиция → сохранённый порядок для этого ключа) а без ключа партиционер по умолчанию закрепляется за одной (sticky) партицией и пишет в неё, пока не накопится `batch.size` байт, затем переключается на другую (круговой перебор — отдельный `RoundRobinPartitioner`, его задают через `partitioner.class`). Сообщения хранятся заданное время/объём (retention) и не удаляются сразу после чтения — их можно перечитать. Раньше метаданными управлял ZooKeeper, теперь — встроенный KRaft: Kafka 4.0 — первый мажорный релиз, который работает целиком без ZooKeeper.

Источник: https://kafka.apache.org/42/getting-started/introduction/

### Как работают консьюмер-группы и распределение партиций между консьюмерами?

Консьюмеры объединяются в группу **по одному group.id**. Ключевое правило: **каждую партицию топика в пределах группы** **читает ровно один консьюмер** — так каждое сообщение топика достаётся в группе одному процессу, нагрузка делится, а порядок внутри партиции сохраняется. Дубли в группе всё же возможны: если консьюмер упал или случился ребаланс, партицию подхватит другой и начнёт с последнего закоммиченного offset. Партиции распределяются между консьюмерами группы (rebalance) при подключении/ отключении участников.

Источник: https://kafka.apache.org/42/javadoc/org/apache/kafka/clients/consumer/KafkaConsumer.html

### Какие семантики доставки есть в Kafka?

В Kafka три семантики доставки: at-most-once (возможна потеря), at-least-once (возможны дубли) и exactly-once (без потерь и дублей, но только в рамках транзакций Kafka).

Источник: https://kafka.apache.org/42/design/design/

### Как Kafka понимает, что сообщение обработано (offset commit) и что происходит после?

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

Источник: https://kafka.apache.org/42/design/design/

## Микросервисы и распределённые системы

### В чём плюсы и минусы микросервисов по сравнению с монолитом?

Монолит — одно развёртываемое приложение с одной базой, где все операции локальны; микросервисы делят систему на независимые сервисы ценой распределённой сложности.

Источник: https://microservices.io/patterns/microservices.html

### Что такое service discovery и зачем нужна Eureka?

Service discovery — реестр, в котором сервисы регистрируют адреса своих инстансов, а клиенты находят их по логическому имени; Eureka — такой реестр из Spring Cloud Netflix.

Источник: https://microservices.io/patterns/service-registry.html

### Для чего нужен API Gateway в микросервисной архитектуре?

API Gateway — единая точка входа для клиентов микросервисной системы: он маршрутизирует запросы к нужному сервису и берёт на себя сквозные задачи.

Источник: https://microservices.io/patterns/apigateway.html

## Тестирование

### Тест сервиса заказа должен убедиться, что после оплаты вызван notifier.send(orderId) ровно один раз. Какой тип тестового дублёра нужен для этой проверки и чем он отличается от дублёра, который лишь возвращает заготовленные данные?

Нужен **mock**: он проверяет поведение (с какими аргументами и сколько раз вызвали зависимость), а **stub** лишь отдаёт заранее заданные ответы, чтобы тестируемый код прошёл нужный путь, и проверяется результат или состояние.

Источник: https://martinfowler.com/bliki/TestDouble.html

### Два теста в одном классе падают в наборе, хотя каждый по отдельности проходит: второй видит изменение, которое сделал первый, в поле класса. Почему по умолчанию в JUnit 6 этого не происходит и при каком условии произойдёт?

По умолчанию JUnit создаёт **новый экземпляр тестового класса перед каждым тестовым методом** (`PER_METHOD`), поэтому поля экземпляра у тестов независимы; общим остаётся только `static`-состояние. Изменение поля станет видно следующему тесту, если включить `@TestInstance(Lifecycle.PER_CLASS)` (или поменять значение по умолчанию параметром `junit.jupiter.testinstance.lifecycle.default`): тогда экземпляр один на класс.

Источник: https://docs.junit.org/6.0.3/writing-tests/test-instance-lifecycle.html

### Сервис сохраняет заказ только после успешного вызова PaymentClient по HTTP. Как в юнит-тесте с Mockito проверить, что при ошибке клиента заказ не сохраняется, и что здесь не стоит подменять мокированием?

Подменить `PaymentClient` и репозиторий моками, заставить клиент бросить исключение через `when(client.charge(any())).thenThrow(...)` и проверить, что репозиторий не вызывался: `verify(repository, never()).save(any())`. Мок клиента нужен на границе системы (сеть), а проверка `never()` оправдана, потому что отсутствие сохранения нельзя увидеть в возвращаемом значении.

Источник: https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.0-Migration-Guide

### Набор интеграционных тестов вырос, и сборка замедлилась: каждый тестовый класс заново поднимает ApplicationContext. Из-за чего контекст не переиспользуется между классами и что служит ключом кеша?

Контекст переиспользуется, только если у тестовых классов **совпадает уникальная конфигурация**, и любое отличие в ключе даёт новый контекст. В ключ входят `@ContextConfiguration` (классы, локации, инициализаторы), `@ActiveProfiles`, `@TestPropertySource`, методы `@DynamicPropertySource`, подмены бинов (`@MockitoBean`, `@MockitoSpyBean`) и другие `ContextCustomizer`, в том числе из тестовой поддержки Spring Boot. Поэтому класс с собственным набором `@MockitoBean`, другим профилем или свойством получает отдельный контекст. Кеш статический, он живёт в одном JVM-процессе: если сборка запускает тесты в отдельных процессах, кеширование фактически отключено. Размер кеша ограничен 32 контекстами (LRU), его меняет системное свойство `spring.test.context.cache.maxSize`. `@DirtiesContext` помечает контекст как испорченный и вынуждает его пересоздать, поэтому применять его нужно точечно. Практика: держать конфигурацию тестов единообразной (общий базовый класс или общий набор подмен) и смотреть статистику кеша в логе категории `org.springframework.test.context.cache` на уровне DEBUG. `@SpringBootTest` по умолчанию поднимает весь контекст приложения без запуска сервера (`webEnvironment` по умолчанию имитирует веб-окружение); реальный сервер запускают режимы `RANDOM_PORT` и `DEFINED_PORT`.

Источник: https://docs.spring.io/spring-framework/reference/testing/testcontext-framework/ctx-management/caching.html

## Пробы, завершение и конфигурация в production

### Spring Boot сервис в Kubernetes: livenessProbe настроена на /actuator/health, где среди индикаторов есть проверка базы. База недоступна пять минут. Что произойдёт с подами и как это исправить?

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

Источник: https://docs.spring.io/spring-boot/reference/actuator/endpoints.html

### У Spring Boot сервиса в Kubernetes включено корректное завершение (server.shutdown=graceful), но во время выкатки часть клиентов всё равно получает connection refused. Почему и что добавить в манифест?

Новые соединения отклоняются раньше, чем балансировка узнала, что под уходит; в манифест добавляют preStop-хук с короткой паузой.

Источник: https://docs.spring.io/spring-boot/reference/web/graceful-shutdown.html

### В поде заданы terminationGracePeriodSeconds: 30, preStop с паузой 20 секунд и spring.lifecycle.timeout-per-shutdown-phase: 30s. В момент отправки SIGTERM приложение обрабатывает запрос, которому нужно ещё 25 секунд. Что с ним случится?

Запрос оборвётся: контейнер будет убит сигналом SIGKILL по истечении 30 секунд общего бюджета, а таймаут фазы завершения в 30 секунд до этого не дойдёт.

Источник: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/

## Наблюдаемость Java-сервиса: логи, метрики, трассы

### В 14:05 p99 эндпоинта вырос с 200 мс до 3 с. Как вы используете метрики, трассы и логи и в каком порядке?

Метрики отвечают, что и когда сломалось, трасса показывает, на каком шаге цепочки, а лог с traceId объясняет почему.

Источник: https://docs.spring.io/spring-boot/reference/actuator/observability.html

### В Spring Boot сервисе подключён Micrometer Tracing, но в бэкенде трасс видна примерно каждая десятая. Почему и какой сервис решает, попадёт ли трасса туда?

Boot по умолчанию отправляет в бэкенд 10 % трасс (management.tracing.sampling.probability = 0.1), а решение принимает первый сервис цепочки.

Источник: https://docs.spring.io/spring-boot/reference/actuator/tracing.html

### В обработчике запроса в MDC положен orderId, но строки лога, написанные внутри задачи в пуле потоков (CompletableFuture.supplyAsync), идут без orderId. Почему и как это исправить?

MDC хранится в текущем потоке (ThreadLocal), а поток пула другой, поэтому контекст в него не попадает.

Источник: https://logback.qos.ch/manual/mdc.html

## Контейнеры, Kubernetes и конвейер для JVM

### После правки одного класса docker build пересобирает слой с зависимостями на 150 МБ, потому что jar копируется в образ целиком. Как построить образ Spring Boot сервиса, чтобы пересобирался только небольшой слой?

Распаковать слоистый jar и копировать его слои отдельными инструкциями COPY, от редко меняющихся к часто меняющимся.

Источник: https://docs.spring.io/spring-boot/reference/packaging/container-images/efficient-images.html

### Под с лимитом памяти 1 ГиБ и JVM с `-XX:MaxRAMPercentage=90` раз в несколько часов перезапускается; в логах нет OutOfMemoryError, а `kubectl describe` показывает OOMKilled. Почему?

Heap занимает лишь часть памяти процесса, и процесс целиком превысил лимит контейнера, поэтому его убило ядро, а не JVM.

Источник: https://docs.oracle.com/en/java/javase/25/docs/specs/man/java.html

### Deployment на 10 реплик с настройками RollingUpdate по умолчанию. Сколько подов может существовать одновременно во время выкатки и сколько как минимум остаётся доступными?

До 13 подов одновременно и не меньше 8 доступных.

Источник: https://kubernetes.io/docs/concepts/workloads/controllers/deployment/

## Устойчивость вызовов: пулы, таймауты, повторы, переборки

### Эндпоинт синхронно вызывает зависимость, которая замедлилась с 100 мс до 5 с. Нагрузка 100 запросов в секунду, Tomcat с настройками по умолчанию. Что произойдёт с сервисом?

Пул потоков Tomcat заполнится за считанные секунды, и перестанут отвечать все эндпоинты сервиса, включая не связанные с зависимостью.

Источник: https://docs.spring.io/spring-boot/appendix/application-properties/index.html

### Сервис вызывает зависимость через java.net.http.HttpClient, запрос создан как `HttpRequest.newBuilder(uri).build()`, а зависимость перестала отвечать. Сколько клиент будет ждать?

Без ограничения: ни таймаута запроса, ни таймаута соединения по умолчанию нет.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.net.http/java/net/http/HttpRequest.Builder.html

### Метод аннотирован `@Retryable` без параметров в Spring Framework 7 (включён @EnableResilientMethods) и каждый раз выбрасывает исключение. Сколько раз он будет вызван и при каких исключениях повторяется?

Четыре раза: один исходный вызов и три повтора, при любом исключении, с паузой в одну секунду.

Источник: https://docs.spring.io/spring-framework/reference/core/resilience.html

## gRPC в Java: схема, дедлайны, потоки

### В message Order удалили поле `string note = 3;`, а позже добавили `int32 priority = 3;`. Часть клиентов ещё работает на старой схеме. Что сломается и как менять схему правильно?

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

Источник: https://protobuf.dev/programming-guides/proto3/

### Фронтенд в браузере хочет вызвать gRPC-сервис напрямую через стандартный API браузера. Получится ли и что для этого нужно?

Напрямую не получится: нужен gRPC-Web и прокси, который переводит запросы, либо отдельный REST-шлюз.

Источник: https://grpc.io/docs/what-is-grpc/introduction/

### Клиент вызывает сервис A с дедлайном 2 секунды. A тратит на обработку 1,5 секунды, затем из того же потока обработчика вызывает B через stub без собственного дедлайна. Сколько времени есть у B?

Около 0,5 секунды: дедлайн один на всю цепочку, и он убывает по мере прохождения.

Источник: https://grpc.io/docs/guides/deadlines/

## Reactive Streams, Reactor и WebFlux

### Издатель Reactive Streams имеет 100 элементов. Подписчик вызвал `request(3)`, а затем, не получив ничего, `request(2)`. Сколько элементов издатель может отправить?

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

Источник: https://raw.githubusercontent.com/reactive-streams/reactive-streams-jvm/v1.0.4/README.md

### В обработчике WebFlux внутри `map` вызывается блокирующий `jdbcTemplate.query(...)`. Под нагрузкой замирают все эндпоинты, хотя CPU почти не занят. Почему и как исправить?

Блокирующий вызов держит поток event loop, а их мало, поэтому остальные запросы ждут свободного потока.

Источник: https://docs.spring.io/spring-framework/reference/web/webflux/new-framework.html

### Метод создаёт `Mono.fromCallable(() -> repository.save(order)).map(...)`, но вызывающий код результат не использует. Запись в базу не происходит. Почему и что случится при двух подписках?

Цепочка Reactor ленивая: без подписки ничего не выполняется; при двух подписках запись выполнится дважды.

Источник: https://projectreactor.io/docs/core/release/reference/reactiveProgramming.html

## Spring MVC: привязка параметров, валидация и JSON

### Метод `@PostMapping("/orders/search")` принимает `@RequestParam int limit` и параметр `SearchFilter filter` без аннотаций (обычный класс с полем `String status`). Клиент шлёт `POST /orders/search?limit=10` с телом `{"status":"NEW"}`. Что окажется в `filter.status`?

В `filter.status` будет `null`: тело запроса никто не читает.

Источник: https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-controller/ann-methods/arguments.html

### Эндпоинт `GET /api/orders` объявлен как `@RequestParam(defaultValue = "20") int limit`. Что получит клиент на запрос `?limit=abc`, и подставится ли значение 20 на `?limit=`?

На `?limit=abc` придёт ответ 400, а на `?limit=` метод получит `limit = 20`.

Источник: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/RequestParam.html

### Метод контроллера `create(@Valid @RequestBody CreateOrderRequest request)` работает, а `@ExceptionHandler(MethodArgumentNotValidException.class)` превращает нарушения в ответ 400 с полями. После того как в сигнатуру добавили `@RequestParam @Min(1) int priority`, обработчик перестал срабатывать на ошибки тела. Какое исключение теперь приходит?

`HandlerMethodValidationException`.

Источник: https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-controller/ann-validation.html

## Семантика HTTP-API: методы, идемпотентность, кеширование, версии

### На ресурсе `/orders/7` сервер поддерживает только `GET` и `PUT`. Клиент присылает `DELETE /orders/7`. Какой статус должен вернуть сервер по RFC 9110 и какой заголовок он обязан добавить?

Статус 405 Method Not Allowed и заголовок `Allow` со списком поддерживаемых методов, здесь `Allow: GET, PUT`.

Источник: https://www.rfc-editor.org/rfc/rfc9110.html#name-405-method-not-allowed

### Первый `DELETE /orders/7` вернул 204, повторный такой же запрос вернул 404. Нарушила ли реализация идемпотентность метода DELETE?

Нет, идемпотентность не нарушена.

Источник: https://www.rfc-editor.org/rfc/rfc9110.html#name-idempotent-methods

### Клиент отправил `POST /payments` и получил таймаут: неизвестно, списаны ли деньги. Повторять запрос слепо нельзя, потому что `POST` не идемпотентен. Какой приём делает повтор безопасным?

Клиент генерирует ключ идемпотентности один раз на логическую операцию и передаёт его в каждой попытке (обычно заголовком `Idempotency-Key`). Сервер сохраняет результат по ключу и на повтор возвращает тот же результат, не выполняя платёж второй раз.

Источник: https://www.rfc-editor.org/rfc/rfc9110.html#name-idempotent-methods

## JDBC, пул соединений HikariCP и миграции схемы

### Код получил `Connection` в режиме по умолчанию, выполнил `UPDATE` списания, затем `UPDATE` зачисления, и на втором оператор нарушил ограничение `CHECK` (`SQLException`). Что хранится в базе после выхода из метода?

Списание сохранено, зачисления нет.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.sql/java/sql/Connection.html

### Код отключил autocommit, выполнил `SELECT`, прочитал `ResultSet`, закрыл его и вернул соединение туда, откуда взял, не вызывая `commit()` или `rollback()`. Закончилась ли транзакция после закрытия `ResultSet`?

Нет, транзакция остаётся открытой.

Источник: https://docs.oracle.com/en/java/javase/25/docs/api/java.sql/java/sql/Connection.html

### Пул HikariCP из 10 соединений, каждый запрос держит соединение 50 мс, постоянно приходит 300 запросов в секунду. Сколько запросов в секунду обслужит пул и что получат запросы, ожидающие дольше `connectionTimeout`?

Пул обслужит около 200 запросов в секунду (10 соединений / 0,05 с), остальные 100 в секунду копятся в очереди ожидания. Дождавшиеся истечения `connectionTimeout` получат `SQLException` (в HikariCP это `SQLTransientConnectionException` с сообщением, что соединение недоступно за отведённое время).

Источник: https://github.com/brettwooldridge/HikariCP/blob/HikariCP-7.0.2/README.md

## Spring Security: цепочка фильтров, правила доступа, JWT, CSRF и CORS

### В приложении две `SecurityFilterChain`: одна с `securityMatcher("/api/**")`, другая с `securityMatcher("/admin/**")`, других нет. Что произойдёт с запросом `GET /metrics` от анонимного клиента?

Запрос дойдёт до контроллера без проверок Spring Security.

Источник: https://docs.spring.io/spring-security/reference/servlet/architecture.html

### В приложении есть цепочки `api` (`securityMatcher("/api/**")`) и `admin`. Разработчик добавил третий бин `SecurityFilterChain` без `securityMatcher` и поставил `@Order(0)`. Что изменится для запроса `GET /api/orders`?

Запрос обработает новая цепочка, а правила цепочки `api` перестанут применяться.

Источник: https://docs.spring.io/spring-security/reference/servlet/architecture.html

### Приложение использует `PasswordEncoderFactories.createDelegatingPasswordEncoder()`. В базе пароль хранится как обычный bcrypt-хеш `$2a$10$...` без префикса. Пользователь вводит верный пароль. Что произойдёт?

`DelegatingPasswordEncoder` бросит `IllegalArgumentException`, пароль даже не будет сравниваться.

Источник: https://docs.spring.io/spring-security/reference/features/authentication/password-storage.html

## Records, sealed-типы и switch с образцами

### Интерфейс `Payment` запечатан (`sealed`) и разрешает `Card` и `Cash`. Вы добавили третий тип `Crypto` в список `permits`. Один `switch` по `Payment` перечисляет случаи `Card` и `Cash` без `default`, другой содержит `default`. Что покажет перекомпиляция?

Первый `switch` не скомпилируется, второй скомпилируется молча.

Источник: https://docs.oracle.com/javase/specs/jls/se25/html/jls-14.html#jls-14.11

### Что компилятор создаёт для `record Point(int x, int y) {}` и можно ли добавить в запись ещё одно поле экземпляра?

Для каждого компонента запись получает приватное финальное поле и метод доступа с тем же именем (`x()`, `y()`), плюс канонический конструктор и реализации `equals`, `hashCode` и `toString`. Дополнительные поля экземпляра добавить нельзя.

Источник: https://docs.oracle.com/javase/specs/jls/se25/html/jls-8.html#jls-8.10

## Maven и Gradle: версии зависимостей

### Приложение зависит от библиотеки A, которая тянет `lib:1.0`, и от библиотеки B, которая через C тянет `lib:2.0`. Версию `lib` в проекте напрямую не объявляли. Какую версию получит приложение в Maven и какую в Gradle?

Maven возьмёт `lib:1.0`, Gradle возьмёт `lib:2.0`.

Источник: https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html

### В `pom.xml` проекта на Spring Boot подключён `spring-boot-starter-web` без указания версии, и всё собирается. Откуда берутся версии этого стартера и его транзитивных библиотек?

Версии задаёт управление зависимостями Spring Boot: список рекомендованных версий (BOM, `spring-boot-dependencies`), который подключается через родительский POM `spring-boot-starter-parent` или импортом в `dependencyManagement`.

Источник: https://docs.spring.io/spring-boot/reference/using/build-systems.html

## Spring Boot: источники свойств и профили

### В `application.properties` указано `server.port=8080`, в переменной окружения `SERVER_PORT=9090`, а приложение запущено с аргументом `--server.port=7070`. На каком порту оно стартует и по какому правилу?

На порту 7070: аргументы командной строки имеют самый высокий приоритет среди этих источников.

Источник: https://docs.spring.io/spring-boot/reference/features/external-config.html

### Активны два профиля: `spring.profiles.active=dev,local`. Оба профильных файла задают `app.url`. Какое значение получит приложение?

Победит значение из `application-local.properties`: при нескольких профилях действует правило «последний выигрывает».

Источник: https://docs.spring.io/spring-boot/reference/features/external-config.html

## Профилирование JVM: JFR и флеймграфы

### Бенчмарк JMH вычисляет значение в методе и не использует его; результат — доли наносекунды на вызов. Что здесь не так и как исправить?

JIT-компилятор выбросил вычисление как мёртвый код, поэтому бенчмарк меряет пустой метод.

Источник: https://raw.githubusercontent.com/openjdk/jmh/1.37/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_08_DeadCode.java

### Метод ускорили втрое по результатам JMH, а p99 задержки эндпоинта в продакшене не изменился. С чего начинать дальше?

С измерения того, где запрос проводит время, а не с новой оптимизации: микробенчмарк показывает скорость метода в изоляции, но не его долю в запросе.

Источник: https://docs.spring.io/spring-boot/reference/actuator/metrics.html

### Как снять запись JFR длительностью 60 секунд с уже работающего процесса JVM, не перезапуская его?

Командой `jcmd <pid> JFR.start duration=60s filename=rec.jfr`, где `<pid>` — идентификатор процесса JVM.

Источник: https://docs.oracle.com/en/java/javase/25/docs/specs/man/jcmd.html
