К содержимому
Войти

Java Road Map

🫘 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ДаНетНет
Тест без Springnew 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. Цикл между конструкторами это свойство не спасает

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

  1. Вынести общее в третий класс. OrderService и PaymentService вызывают друг друга ради расчёта суммы — расчёт уходит в PriceCalculator, от которого зависят оба
  2. Заменить прямой вызов событием. PaymentService публикует PaymentCompleted через ApplicationEventPublisher, OrderService слушает его в @EventListener. Зависимость остаётся в одну сторону
  3. Передать нужное аргументом метода вместо зависимости в конструкторе, если связь нужна в одном месте
  4. @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 и атомиках

📚 Что почитать