Annotation Type Autowired

Marks a constructor, field, setter method, or config method as to be autowired by
Spring's dependency injection facilities. This is an alternative to the JSR-330
Inject annotation, adding required-vs-optional semantics.

Autowired Constructors

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 required
attribute is set to true, only a single constructor may be annotated
with @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. 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.

Autowired Fields

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.

Autowired Methods

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 Parameters

Although @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
the spring-test module (see the
TestContext framework
reference documentation for details).

Multiple Arguments and 'required' Semantics

In the case of a multi-arg constructor or method, the required() attribute
is applicable to all arguments. Individual parameters may be declared as Java-8 style
Optional or, as of Spring Framework 5.0, also as @Nullable
or a not-null parameter type in Kotlin, overriding the base 'required' semantics.

Autowiring Arrays, Collections, and Maps

In case of an array, Collection, or Map
dependency type, the container autowires all beans matching the declared value
type. For such purposes, the map keys must be declared as type String
which will be resolved to the corresponding bean names. Such a container-provided
collection will be ordered, taking into account
Ordered and
@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
Collection or Map itself, getting injected as such.