Annotation Interface Autowired
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 be autowired 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. 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.
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.
Not supported in BeanPostProcessor
or BeanFactoryPostProcessor
Note that actual injection is performed through a
BeanPostProcessor
which in turn means that you cannot
use @Autowired
to inject references into
BeanPostProcessor
or
BeanFactoryPostProcessor
types. Please consult the javadoc for the AutowiredAnnotationBeanPostProcessor
class (which, by default, checks for the presence of this annotation).
- Since:
- 2.5
- Author:
- Juergen Hoeller, Mark Fisher, Sam Brannen
- See Also:
-
Optional Element Summary
Modifier and TypeOptional ElementDescriptionboolean
Declares whether the annotated dependency is required.
-
Element Details
-
required
boolean requiredDeclares whether the annotated dependency is required.Defaults to
true
.- Default:
- true
-