Spring Circular Dependencies with `@Lazy` annotation

Published in

Spring Boot Tips and Tricks

2 min readFeb 9, 2024

Spring Circular Dependencies with `@Lazy` annotation

Hi, this is Paul, and welcome to my Spring guide. Today we will discuss how to resolve circular dependencies in Spring Boot.

Understanding Circular Dependencies

A circular dependency arises in a Spring application when two or more beans depend on each other, creating a loop that prevents the Spring container from determining the order of bean instantiation. This can lead to runtime errors and complications in the application’s startup process.

Example With Interfaces

Step 1: Defining Interfaces

First, we define two interfaces representing the interdependent services:

public interface ServiceA {
    void methodInA();
}

public interface ServiceB {
    void methodInB();
}

Step 2: Implementing Interfaces

Next, we implement these interfaces in our service classes and use setter injection with the @Lazy annotation to inject the dependencies. This approach allows Spring to manage the instantiation and dependency resolution.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
public class ServiceAImpl implements ServiceA {

    private ServiceB serviceB;

    @Autowired
    public void setServiceB(@Lazy ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    @Override
    public void methodInA() {
        System.out.println("Inside Method A");
    }
}

@Component
public class ServiceBImpl implements ServiceB {

    private ServiceA serviceA;

    @Autowired
    public void setServiceA(@Lazy ServiceA serviceA) {
        this.serviceA = serviceA;
    }

    @Override
    public void methodInB() {
        System.out.println("Inside Method B");
    }
}

Step 3: Configuring Spring Context

Ensure your Spring context is configured to automatically scan for components and inject dependencies. This is typically achieved with @ComponentScan in your configuration class or through XML configuration.

Example Without Interfaces

Suppose we have two concrete service classes, ServiceAImpl and ServiceBImpl, without interfaces. By applying @Lazy alongside @Autowired for setter injection, Spring will use CGLIB to create a subclass proxy of these beans, facilitating lazy initialization and dependency resolution.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
public class ServiceAImpl {

    private ServiceB serviceB;

    @Autowired
    public void setServiceB(@Lazy ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    public void methodInA() {
        System.out.println("Inside Method A");
    }
}

@Component
public class ServiceBImpl {

    private ServiceA serviceA;

    @Autowired
    public void setServiceA(@Lazy ServiceA serviceA) {
        this.serviceA = serviceA;
    }

    public void methodInB() {
        System.out.println("Inside Method B");
    }
}

(Note: The actual code snippet for the CGLIB example would mirror the earlier example but omit the interface implementation part, demonstrating Spring’s ability to handle circular dependencies with concrete classes.)

Conclusion

Spring’s support for interfaces and dynamic proxies provides a robust solution to the challenge of circular dependencies. By deferring bean instantiation until necessary, applications can maintain a clean architecture, avoid initialization errors, and ensure components are testable and loosely coupled. This technique exemplifies the flexibility and power of the Spring Framework in managing complex dependency scenarios.

Thank you for reading until the end. Before you go:

Please consider clapping and following the writer! 👏
Follow us on Twitter(X), LinkedIn

Spring Circular Dependencies with @Lazy annotation