Spring Constructor Injection throws an error when more than one constructor has @Autowired

Question

Spring documentation says this:

Only one annotated constructor per class can be marked as required, but multiple non-required constructors can be annotated. In that case, each is considered among the candidates and Spring uses the greediest constructor whose dependencies can be satisfied — that is, the constructor that has the largest number of arguments. The constructor resolution algorithm is the same as for non-annotated classes with overloaded constructors, just narrowing the candidates to annotated constructors.

I tested it and I get an error as soon as I have another constructor marked by @Autowired

package com.example.demo.constructorinjection;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ConstructorInjectComponent {   

private InjectionServiceOne injectionServiceOne;

private InjectionServiceTwo injectionServiceTwo;

@Autowired(required = true)
public constructorInjectComponent(InjectionServiceOne injectionServiceOne,
        InjectionServiceTwo injectionServiceTwo) {
    this.injectionServiceOne = injectionServiceOne;
    this.injectionServiceTwo = injectionServiceTwo;
}

@Autowired(required = false)
public constructorInjectComponent(InjectionServiceTwo injectionServiceTwo) {
    this.injectionServiceTwo = injectionServiceTwo;
}

@Autowired(required = false)
public constructorInjectComponent(InjectionServiceOne injectionServiceOne) {
    this.injectionServiceOne = injectionServiceOne;
}

@Scheduled(fixedRate=1000L)
public void allFieldsConstructorInjectionTest() {
    System.err.println("constructorInjection " + injectionServiceOne.method() + " " + injectionServiceTwo.method());
}
}

Error:

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'constructorInjectComponent': Invalid autowire-marked constructor: public com.example.demo.constructorinjection.constructorInjectComponent(com.example.demo.constructorinjection.InjectionServiceOne). Found constructor with 'required' Autowired annotation already: public com.example.demo.constructorinjection.constructorInjectComponent(com.example.demo.constructorinjection.InjectionServiceOne,com.example.demo.constructorinjection.InjectionServiceTwo) at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors(AutowiredAnnotationBeanPostProcessor.java:314) ~[spring-beans-5.1.8.RELEASE.jar:5.1.8.RELEASE] at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors(AbstractAutowireCapableBeanFactory.java:1269) ~[spring-beans-5.1.8.RELEASE.jar:5.1.8.RELEASE]

Question:

Why can't I have more than one constructors marked with @Autowired? Spring documentation clearly says I can have more than one constructor marked with @Autowired.

Strange. It seems to be saying that you're trying to create a second required constructor, but your @Autowired annotation clearly says that you aren't. My guess is that this is some subtlety with Spring or simply a bug. If this were me and I got no other help, I think I'd be digging in with the debugger to try to figure out what Spring is doing. But that's sure yucky. Best of luck figuring this out. — CryptoFool
@Steve thanks for the response. I am trying to prepare for Spring Professional Certification. I will try to find an example online that has multiple constructors marked by @Autowired. — Faraz

Ken Chan Ken Chan · Accepted Answer · 2019-07-08T02:54:07

The @Autowired is processed by AutowiredAnnotationBeanPostProcessor which its javadoc has better description of this behaviour:

Only one constructor (at max) of any given bean class may declare this annotation with the 'required' parameter set to true, indicating the constructor to autowire when used as a Spring bean.

This statement talks about the case when 'required' = true.

So if 'required' = true , only one constructor (at max) can declare @Autowired.

If multiple non-required constructors declare the annotation, they will be considered as candidates for autowiring. The constructor with the greatest number of dependencies that can be satisfied by matching beans in the Spring container will be chosen.

This statement implies the other case (i.e. 'required' = false).

So if 'required' = false , it allows to have multiple constructors.

You can see this checking logic in the source codes of this for-loop , which the codes are well written which is quite easy to understand.

Spring Constructor Injection throws an error when more than one constructor has @Autowired

2 Answers