Annotation Interface Autowired
Injectannotation, adding required-vs-optional semantics.
Only one constructor of any given bean class may declare this annotation with the
required() attribute set to
true, indicating the constructor
to autowire when used as a Spring bean. Furthermore, if the
attribute is set to
true, only a single constructor may be annotated
@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. If none of the candidates can be satisfied,
then a primary/default constructor (if present) will be used. Similarly, if a
class declares multiple constructors but none of them is annotated with
@Autowired, then a primary/default constructor (if present) will be used.
If a class only declares a single constructor to begin with, it will always be used,
even if not annotated. An annotated constructor does not have to be public.
Fields are injected right after construction of a bean, before any config methods are invoked. Such a config field does not have to be public.
Config methods may have an arbitrary name and any number of arguments; each of those arguments will be autowired with a matching bean in the Spring container. Bean property setter methods are effectively just a special case of such a general config method. Such config methods do not have to be public.
@Autowired can technically be declared on individual method
or constructor parameters since Spring Framework 5.0, most parts of the
framework ignore such declarations. The only part of the core Spring Framework
that actively supports autowired parameters is the JUnit Jupiter support in
spring-test module (see the
reference documentation for details).
Multiple Arguments and 'required' Semantics
In the case of a multi-arg constructor or method, the
is applicable to all arguments. Individual parameters may be declared as Java-8 style
Optional or, as of Spring Framework 5.0, also as
or a not-null parameter type in Kotlin, overriding the base 'required' semantics.
Autowiring Arrays, Collections, and Maps
In case of an array,
dependency type, the container autowires all beans matching the declared value
type. For such purposes, the map keys must be declared as type
which will be resolved to the corresponding bean names. Such a container-provided
collection will be ordered, taking into account
@Order values of the target
components, otherwise following their registration order in the container.
Alternatively, a single matching target bean may also be a generally typed
Map itself, getting injected as such.
Not supported in
Note that actual injection is performed through a
BeanPostProcessor which in turn means that you cannot
@Autowired to inject references into
types. Please consult the javadoc for the
class (which, by default, checks for the presence of this annotation).
Optional Element SummaryModifier and TypeOptional ElementDescription
booleanDeclares whether the annotated dependency is required.
requiredboolean requiredDeclares whether the annotated dependency is required.