Why are circular dependencies bad in Spring

Circular dependencies are generally considered bad design practice in software development, including in Spring Boot applications. I always wondered why. Let's see what circular dependencies are in the first place. Supposed we have two classes that depend on each other like this:

Here we can see that PostService is injected via constructor injection into UserService. And UserService is injected the same way into PostService. If we run this we are going to get the following error in the console:

In conclusion: circular dependencies are so bad that Spring won't let you do it (without some hacking -> @Lazy annotation).

Here are a few reasons why circular dependencies can be problematic:

Code complexity and maintainability: Circular dependencies create tight coupling between classes, making the code more complex and harder to understand. It becomes difficult to determine the flow of dependencies and the order of initialization. As the codebase grows, it becomes challenging to maintain and modify the code due to its tangled nature.

Reduced modularity and re-usability: Circular dependencies break modularity and hinder code re-usability. Classes that are tightly coupled cannot be easily separated or reused in different contexts. This limits the flexibility and extensibility of the codebase.

Testing difficulties: Circular dependencies can make it harder to write unit tests. In order to test a class with circular dependencies, you may need to mock or stub a large number of interconnected classes. This increases the complexity of test setup and can make tests more fragile.

Dependency resolution issues: Circular dependencies can lead to issues with dependency resolution. For example, if two classes depend on each other, it becomes a challenge for the container (Spring ApplicationContext) to instantiate and initialize the objects correctly. It may result in runtime errors or unexpected behavior.

To overcome these issues, it's recommended to follow best practices and principles, such as the Dependency Inversion Principle (DIP) and the Single Responsibility Principle (SRP). These principles promote loose coupling, modular design, and clear separation of concerns. By structuring your codebase with a clear and hierarchical dependency graph, you can avoid circular dependencies and create more maintainable and testable Spring Boot applications.