🫘 IoC, DI и бины
Spring-приложение собирает не main и не new, а контейнер: он читает, какие объекты нужны, создаёт их в правильном порядке и подставляет друг в друга. Эти объекты называются бинами. Без понимания контейнера не объяснить ни ошибку NoUniqueBeanDefinitionException на старте, ни гонку в сервисе под нагрузкой, а на техсекции по Spring с бинов и скоупов начинают почти всегда
🧠 Как это устроено
IoC и DI
Inversion of Control — объект не создаёт и не ищет свои зависимости сам, это делает кто-то снаружи. Dependency Injection — конкретный способ IoC: класс объявляет, что ему нужно, через конструктор, аргументы фабричного метода или сеттеры, а контейнер передаёт готовые зависимости при создании
OrderService с new PostgresOrderRepository() внутри сам выбирает реализацию, и в тесте подменить её нечем. Если он принимает OrderRepository в конструкторе, в проде реализацию подставит Spring, а в тесте ты передашь заглушку руками
Бин — объект, который создал, связал и хранит контейнер Spring. new Order() в методе бином не является
ApplicationContext и BeanFactory
BeanFactory — базовый интерфейс контейнера: создаёт бины по описаниям и отдаёт их по типу или имени. ApplicationContext расширяет его событиями (ApplicationEventPublisher), сообщениями для i18n, интеграцией с AOP и веб-контекстами. Работают с ApplicationContext, Spring Boot создаёт его сам в SpringApplication.run
На старте контейнер собирает описания бинов (BeanDefinition) из сканирования пакетов, классов @Configuration и автоконфигурации Boot, строит граф зависимостей и создаёт singleton-бины в его порядке. Если зависимости нет или кандидатов двое, приложение падает на старте, а не на первом запросе. Что происходит с бином между созданием и готовностью, разобрано на следующей странице «Жизненный цикл бина, прокси и AOP»
Способы внедрения
| Конструктор | Сеттер | Поле (@Autowired на поле) | |
|---|---|---|---|
Поле может быть final | Да | Нет | Нет |
| Тест без Spring | new Service(stub) | Вызвать сеттеры, легко забыть один | Только рефлексией или через Spring |
| Зависимости видны | В сигнатуре | Размазаны по методам | Спрятаны в полях |
| Когда уместно | По умолчанию | Необязательная зависимость с разумным значением по умолчанию | Почти никогда, разве что в тестовых классах |
Команда Spring в документации советует внедрение через конструктор. Причины, которые стоит назвать на собеседовании:
- неизменяемость: поля
final, объект после создания не меняется, и его безопасно читать из многих потоков - объект всегда целый: конструктор не завершится без всех зависимостей,
NullPointerExceptionиз-за забытого сеттера не будет - тесты без контекста: сервис создаётся через
new, юнит-тест не поднимает Spring и проходит за миллисекунды - явный список зависимостей: восемь аргументов в конструкторе сразу показывают, что класс делает слишком много
Если конструктор у класса один, @Autowired на нём не нужен, Spring возьмёт его сам. Аннотация нужна, только когда конструкторов несколько. Lombok-овский @RequiredArgsConstructor по final-полям генерирует тот же конструктор
Стереотипы и @Bean
Бин объявляют двумя способами
Аннотация на своём классе. @Component — общий стереотип, остальные помечены им как мета-аннотацией:
| Аннотация | Слой | Что добавляет сверх @Component |
|---|---|---|
@Component | Всё, что не подходит под остальные | — |
@Service | Бизнес-логика | Сейчас ничего, только смысл для читателя |
@Repository | Доступ к данным | Перевод исключений хранилища в DataAccessException |
@Controller, @RestController | Веб-слой | Spring MVC ищет в них обработчики запросов |
Перевод исключений разобран на странице про исключения, @RestController — на странице про Spring MVC. Документация оставляет стереотипам право получить новую семантику в будущих версиях, поэтому для сервиса @Service правильнее, чем @Component
Метод @Bean в классе @Configuration. Нужен, когда класс не твой (Clock, клиент стороннего API) или создание требует логики. Имя бина по умолчанию — имя метода
@Configuration по умолчанию работает в полном режиме: Spring создаёт CGLIB-подкласс конфигурации, и вызов одного @Bean-метода из другого возвращает уже существующий singleton, а не новый объект. С @Configuration(proxyBeanMethods = false) или в @Bean-методе внутри обычного @Component включается lite-режим: подкласса нет, прямой вызов метода создаёт новый объект при каждом обращении. Lite-режим легче, автоконфигурации Boot написаны в нём. Зависимости в нём принимай аргументами метода, а не вызовом соседнего @Bean
Несколько кандидатов: @Qualifier, @Primary, коллекции
Если под тип PaymentGateway подходят два бина, а в конструкторе один параметр, контекст не стартует с NoUniqueBeanDefinitionException. Выходов три:
@Primaryна одной реализации: её берут, когда кандидатов несколько@Qualifier("sbp")на параметре конструктора и на бине: выбрать конкретный по имени. Сильнее@Primary, когда оба указаны- взять все сразу:
List<PaymentGateway>получит все реализации,Map<String, PaymentGateway>— их же с именами бинов в ключах. Порядок в списке задают@OrderилиOrdered, без них порядок регистрации
Со Spring Framework 6.2 есть ещё @Fallback: бин берут, только если других кандидатов нет. Пример со списком реализаций был на странице про ООП и SOLID, ниже — вариант с Map
@Conditional и @Profile
@Conditional(SomeCondition.class) на бине или конфигурации: бин регистрируется, только если matches у условия вернул true. Условие видит свойства, classpath и уже зарегистрированные бины. @Profile — частный случай: он сам помечен @Conditional и проверяет активные профили. @Profile("!prod") подключит фейковый платёжный шлюз везде, кроме прода. На @Conditional построена автоконфигурация Boot, она разобрана на странице про Spring Boot
Скоупы
Скоуп решает, сколько экземпляров бина живёт и как долго
| Скоуп | Экземпляр | Где работает |
|---|---|---|
singleton | Один на контейнер, по умолчанию | Везде |
prototype | Новый при каждом запросе бина у контейнера | Везде. Уничтожение Spring не отслеживает, ресурсы освобождает тот, кто взял |
request | Один на HTTP-запрос | Только в веб-контексте |
session | Один на HTTP-сессию | Только в веб-контексте |
application | Один на ServletContext | Только в веб-контексте |
websocket | Один на WebSocket-сессию | Только в веб-контексте |
Singleton в Spring — не паттерн из GoF: это один экземпляр на имя бина в контейнере. Два @Bean-метода с одним типом дадут два singleton-бина одного класса
🛠️ На практике
Сервис через конструктор
@Service
public class OrderService {
private final OrderRepository orders;
private final PaymentGateway payments;
private final Clock clock;
// один конструктор, @Autowired не нужен
public OrderService(OrderRepository orders, PaymentGateway payments, Clock clock) {
this.orders = orders;
this.payments = payments;
this.clock = clock;
}
}
@Configuration(proxyBeanMethods = false)
class TimeConfig {
@Bean
Clock clock() {
return Clock.systemUTC(); // чужой класс, поэтому @Bean, а не @Component
}
}Clock бином удобен в тестах: передаёшь Clock.fixed(...) и проверяешь сроки без Thread.sleep
Стратегия по ключу через Map
@Component("email") class EmailSender implements NotificationSender { /* ... */ }
@Component("telegram") class TelegramSender implements NotificationSender { /* ... */ }
@Service
class Notifier {
private final Map<String, NotificationSender> senders; // ключ — имя бина
Notifier(Map<String, NotificationSender> senders) {
this.senders = senders;
}
void send(String channel, Message m) {
var sender = senders.get(channel);
if (sender == null) throw new IllegalArgumentException("Нет канала " + channel);
sender.send(m);
}
}Новый канал — новый класс с @Component, Notifier не меняется
Prototype внутри singleton
Зависимости внедряются один раз, при создании бина. Если положить prototype-бин в конструктор singleton-а, singleton получит один экземпляр на всю жизнь, и prototype фактически станет singleton-ом. Три способа получать новый экземпляр:
@Service
class ReportService {
private final ObjectProvider<ReportBuilder> builders; // ReportBuilder — @Scope("prototype")
ReportService(ObjectProvider<ReportBuilder> builders) {
this.builders = builders;
}
Report build(Long id) {
ReportBuilder b = builders.getObject(); // каждый вызов — новый экземпляр
return b.forOrder(id).build();
}
}ObjectProvider<T>— самый явный способ,getObject()идёт в контейнер при каждом вызове. ЕстьgetIfAvailable()для необязательных зависимостей@Lookupна методе без аргументов: Spring через CGLIB-подкласс переопределяет метод, и он возвращает бин из контейнера. Класс и метод не должны бытьfinal, а бин должен создавать сам контейнер: с объектом из@Bean-метода@Lookupне работает- scoped proxy:
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS). В singleton внедряется прокси, и каждый вызов метода на нём идёт в новый экземпляр. Для prototype это обычно не то, что нужно: два вызова подряд попадут в два разных объекта
Для request и session scoped proxy — стандартный путь, @RequestScope и @SessionScope включают его по умолчанию. Singleton-контроллер держит прокси, а прокси на каждом вызове находит экземпляр текущего запроса. Подробнее о прокси — на следующей странице
Циклические зависимости
A в конструкторе требует B, а B требует A. Чтобы вызвать конструктор A, нужен готовый B, а для него нужен готовый A. Средствами Java это не решить, и Spring бросает BeanCurrentlyInCreationException. Через поля и сеттеры цикл технически разрешим: Spring создаёт A пустым, отдаёт ссылку на недособранный объект в B и потом заполняет A
С Spring Boot 2.6 циклические ссылки запрещены по умолчанию, и даже цикл через поля роняет старт с отчётом, где нарисована цепочка бинов. Вернуть старое поведение можно свойством spring.main.allow-circular-references=true, его значение по умолчанию false. Цикл между конструкторами это свойство не спасает
Включать свойство — значит прятать проблему: цикл говорит, что границы между классами проведены неверно. Как развязать:
- Вынести общее в третий класс.
OrderServiceиPaymentServiceвызывают друг друга ради расчёта суммы — расчёт уходит вPriceCalculator, от которого зависят оба - Заменить прямой вызов событием.
PaymentServiceпубликуетPaymentCompletedчерезApplicationEventPublisher,OrderServiceслушает его в@EventListener. Зависимость остаётся в одну сторону - Передать нужное аргументом метода вместо зависимости в конструкторе, если связь нужна в одном месте
@Lazyна параметре конструктора — крайняя мера: Spring внедрит ленивый прокси вместо реального бина, цикл на старте исчезнет, но останется в дизайне
Singleton и потоки
Один экземпляр singleton-бина обслуживает все потоки сразу: 200 потоков Tomcat заходят в один и тот же OrderService. Spring синхронизацию не добавляет. Пока у бина только final-поля с другими бинами, а состояние запроса живёт в локальных переменных и параметрах, гонки нет
@Service
class DiscountService {
private BigDecimal lastTotal; // общее для всех запросов поле — гонка
BigDecimal apply(Cart cart) {
lastTotal = cart.total(); // поток A записал
return lastTotal.multiply(new BigDecimal("0.9")); // поток B уже переписал
}
}Под нагрузкой один клиент получит скидку от корзины другого. Исправление — локальная переменная. Для настоящего общего состояния, счётчика или кэша, бери AtomicLong и ConcurrentHashMap из модуля про многопоточность
⚠️ Где ошибаются
- Внедряют через поля по привычке. Тест на сервис тянет
@SpringBootTestи стартует секунды вместо миллисекунд, поле неfinal - Кладут состояние запроса в поле singleton-а: текущего пользователя, промежуточную сумму,
SimpleDateFormat. На тестах всё работает, гонка видна только под параллельной нагрузкой - Ждут нового экземпляра prototype в singleton-е и получают один на всё время работы. Нужен
ObjectProviderили@Lookup - Чинят цикл флагом
spring.main.allow-circular-references=trueили@Lazy. Связность остаётся, и следующий цикл появится рядом - Вызывают соседний
@Bean-метод вproxyBeanMethods = falseи получают два разных объекта вместо одного, например два пула соединений
🎯 Вопросы с собеседований
Что такое IoC и DI и чем они отличаются?
IoC — принцип: объект не создаёт свои зависимости сам, это делает внешний код, в Spring это контейнер. DI — способ реализовать IoC: класс объявляет зависимости в конструкторе или сеттерах, а контейнер передаёт готовые объекты. Другой вариант IoC — Service Locator, где объект сам просит зависимость у реестра и от этого реестра зависит. С DI класс не знает про Spring, его можно создать через new в тесте
Какие есть способы внедрения и почему рекомендуют конструктор?
Через конструктор, сеттер и поле. Конструктор даёт final-поля и неизменяемый объект, который не создастся без зависимостей, так что null из-за забытого сеттера не будет. Сервис тестируется без Spring через new, а длинный конструктор сразу показывает, что класс перегружен. С одним конструктором @Autowired не нужен. Сеттер оставляют для необязательных зависимостей
Что такое бин и чем ApplicationContext отличается от BeanFactory?
Бин — объект, который создал, связал и хранит контейнер Spring. BeanFactory — базовый контейнер, ApplicationContext добавляет к нему события, i18n, интеграцию с AOP и веб-контексты. В приложениях работают с ApplicationContext
Чем отличаются @Component, @Service, @Repository и @Controller?
Все они помечены @Component и регистрируют бин при сканировании. @Service сейчас ничего не добавляет, это метка слоя. @Repository включает перевод исключений хранилища в DataAccessException. В @Controller Spring MVC ищет обработчики запросов
Есть две реализации интерфейса. Как Spring выберет нужную?
Сама не выберет: контекст упадёт с NoUniqueBeanDefinitionException. @Primary помечает реализацию по умолчанию, @Qualifier на параметре выбирает конкретную по имени и сильнее @Primary. Можно внедрить List всех реализаций или Map, где ключ — имя бина, и выбирать в коде
Что делает @Conditional и как с ним связан @Profile?
@Conditional регистрирует бин, только если класс-условие вернул true, глядя на свойства, classpath и уже зарегистрированные бины. @Profile — его частный случай для активных профилей. На @Conditional построена автоконфигурация Boot, например @ConditionalOnMissingBean
Какие бывают скоупы бинов?
singleton — один экземпляр на контейнер, по умолчанию. prototype — новый при каждом запросе у контейнера, его уничтожение Spring не отслеживает. В веб-приложении есть request, session, application и websocket. Singleton Spring-а — один экземпляр на имя бина, а не на класс, как в GoF
Что будет, если внедрить prototype-бин в singleton?
Singleton получит один экземпляр prototype при создании и будет держать его всю жизнь, потому что внедрение происходит один раз. Чтобы получать новый, внедряют ObjectProvider<T> и зовут getObject(), используют @Lookup-метод, который Spring переопределяет через CGLIB, или scoped proxy с proxyMode. Scoped proxy — стандартный путь для request и session, @RequestScope включает его сам
Что такое циклическая зависимость и как Spring с ней поступает?
Это когда A зависит от B, а B от A, прямо или через цепочку. С конструкторами цикл неразрешим: каждому нужен готовый другой, Spring бросает BeanCurrentlyInCreationException. Через поля Spring умеет подставить ссылку на недособранный объект, но с Boot 2.6 это запрещено по умолчанию, включается spring.main.allow-circular-references=true. Правильно — развязать цикл: вынести общую логику в третий класс, заменить вызов событием или передать нужное аргументом метода. @Lazy на параметре — временная мера
Потокобезопасен ли singleton-бин?
Сам по себе нет: Spring отдаёт один экземпляр всем потокам без синхронизации. Бин потокобезопасен, если у него нет изменяемого состояния: в полях только final-ссылки на другие бины, а данные запроса в параметрах и локальных переменных. Поле вроде lastTotal в сервисе — гонка под нагрузкой. Общее состояние держат в ConcurrentHashMap и атомиках
📚 Что почитать
- The IoC Container в документации Spring Framework — первоисточник: контейнер,
BeanFactoryиApplicationContext, дальше по разделам скоупы и внедрение - Dependency Injection — почему конструктор, когда сеттер и что происходит с циклом
- Bean Scopes — все скоупы, prototype внутри singleton, scoped proxy и
ObjectProvider - Basic Concepts:
@Beanand@Configuration— полный и lite-режим,proxyBeanMethods