Spring: circular dependencies on constructor\setter injection

Question

I've read that circular dependencies are caused by setter injection. So I tried to check it by my own. And it appears that I can reproduce circular dependency only with constructor injection (see code below).

So the questions:

1. Can I accomplish circular dependency with setter injection?

2. How to resolve circular dependencies at code below?

   public class AConstr {
   
     private final BConstr b;
   
     public AConstr(BConstr bConstr) {
       System.out.println("AConstructor:: constructor");
       this.b = bConstr;
     }
   }
   
   public class BConstr {
   
     private final AConstr a;
   
     public BConstr(AConstr aConstr) {
       System.out.println("BConstructor:: constructor");
       this.a = aConstr;
     }
   }
   
   <bean id="aConstr" class="pack.bean.AConstr">
      <constructor-arg ref="bConstr"/>
   </bean>
   <bean id="bConstr" class="pack.bean.BConstr">
      <constructor-arg ref="aConstr"/>
   </bean>
   

Answer 1

There are 2 ways of injecting dependencies with Spring @Autowired: by field or by constructor.

If you have the following layers:

• RestController
• Service
• JpaRepository
• Entity

With the following bindings:

• 1 RestController is bound to the associated Service only
• 1 Service only use the associated JpaRepositories to manage the associated Entities
• To interact with Entities which are out of the service's functional scope, a Service uses other Services.

FooController       BarController
+                   +
|                   |
+                   +
FooService<-------->BarService
+                   +
|                   |
+                   +
FooJpaRepository    BarJpaRepository
+                   +
|                   |
+                   +
FooEntity           BarEntity

Thus, it's normal that 2 Services can depend from each other (directly or not), and that's why you can break the circular dependency:

• with @Autowired on fields instead of on constructor in one of your Service
• Or just adding @Lazy before a constructor parameter.

here is what Spring suggests: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#beans-dependencies

On the other hand, a Service (or directly a JpaRepository) should be injected to RestControllers by constructor. In that case a circular dependency would be an architecture problem.