@Target(value={CONSTRUCTOR,METHOD,PARAMETER,FIELD,ANNOTATION_TYPE}) @Retention(value=RUNTIME) @Documented public @interface Autowired
Inject annotation, 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 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.
 
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.
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).
 
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.
 
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.
 
BeanPostProcessor or BeanFactoryPostProcessorNote 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).
AutowiredAnnotationBeanPostProcessor, 
Qualifier, 
Value| Modifier and Type | Optional Element and Description | 
|---|---|
| boolean | requiredDeclares whether the annotated dependency is required. |