Что произойдет при циклической зависимости бинов?

Циклическая зависимость (circular dependency) — это ситуация в Spring Framework, когда два или более бина ссылаются друг на друга, создавая замкнутый круг. Например, Bean A требует Bean B для инициализации, а Bean B, в свою очередь, требует Bean A. Это классическая проблема проектирования, которую контейнер Spring пытается разрешить, но с определёнными ограничениями.

Как Spring обрабатывает циклические зависимости?

Поведение зависит от способа внедрения зависимости:

• Внедрение через конструктор (Constructor Injection): Spring не может разрешить циклическую зависимость и выбрасывает BeanCurrentlyInCreationException на этапе создания контекста приложения. Это происходит потому, что для создания бина A нужен готовый бин B, а для создания B — готовый A, что приводит к тупику.
• Внедрение через сеттер или поле (Setter/Field Injection): Spring может обойти проблему, используя механизм отложенной инициализации. Контейнер сначала создаёт объекты (экземпляры бинов) без полного заполнения их зависимостями, затем внедряет зависимости через рефлексию. Для этого он может создавать прокси-объекты. Этот процесс иногда называют «разрывом цикла».

Пример кода с циклической зависимостью

@Component
public class ServiceA {
    private ServiceB serviceB;
    
    @Autowired
    public ServiceA(ServiceB serviceB) { // Constructor injection
        this.serviceB = serviceB;
    }
}

@Component
public class ServiceB {
    private ServiceA serviceA;
    
    @Autowired
    public ServiceB(ServiceA serviceA) { // Constructor injection
        this.serviceA = serviceA;
    }
}

При запуске приложения с такой конфигурацией Spring выбросит исключение. Если заменить внедрение на сеттер (добавить @Autowired над setter-методом или полем), Spring, скорее всего, сможет создать бины, но это не рекомендуется.

Практические последствия и решения

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

• Рефакторинг: Выделите общую логику в третий бин или используйте интерфейсы для уменьшения связности.
• Использование @Lazy: Аннотация @Lazy на одной из зависимостей может помочь, отложив инициализацию, но это лишь маскирует проблему.
• Внедрение через ApplicationContext: Получать зависимость программно из контекста (через ApplicationContextAware), но это усложняет тестирование.

Вывод: Циклические зависимости следует избегать на этапе проектирования, так как они усложняют поддержку и тестирование кода. Использование внедрения через конструктор (рекомендуемый подход) помогает выявлять такие проблемы на ранней стадии. Если цикл неизбежен, рассмотрите рефакторинг архитектуры, а не технические обходные пути.