Marks a constructor, field, setter method or config method as to be autowired by Spring‘s dependency injection facilities.Only one constructor (at max) of any given bean class may carry this annotation, indicating the constructor to autowire when used as a Spring bean. Such a 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.In the case of multiple argument methods, the ‘required‘ parameter is applicable for all arguments.In case of a Collection or Map dependency type, the container will autowire all beans matching the declared value type. In case of a Map, the keys must be declared as type String and will be resolved to the corresponding bean names.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

Marks a class as being eligible for Spring-driven configuration.Typically used with the AspectJ AnnotationBeanConfigurerAspect.Since:2.0

Annotation at the field or method/constructor parameter level that indicates a default value expression for the affected argument.Typically used for expression-driven dependency injection. Also supported for dynamic resolution of handler method parameters, e.g. in Spring MVC.A common use case is to assign default field values using "#{systemProperties.myProp}" style expressions.Note that actual processing of the @Value annotation is performed by a BeanPostProcessor which in turn means that you cannot use @Value within BeanPostProcessor or BeanFactoryPostProcessor types. Please consult the javadoc for the AutowiredAnnotationBeanPostProcessor class (which, by default, checks for the presence of this annotation).Since:3.0

This annotation may be used on a field or parameter as a qualifier for candidate beans when autowiring. It may also be used to annotate other custom annotations that can then in turn be used as qualifiers.Since:2.5

Marks a method (typically a JavaBean setter method) as being ‘required‘: that is, the setter method must be configured to be dependency-injected with a value.Please do consult the javadoc for the RequiredAnnotationBeanPostProcessor class (which, by default, checks for the presence of this annotation).Since:2.0

public interface AnnotatedBeanDefinition extends BeanDefinition {    /**     * Obtain the annotation metadata (as well as basic class metadata)     * for this bean definition‘s bean class.     * @return the annotation metadata object (never {@code null})     */    AnnotationMetadata getMetadata();}

public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {}

String getClassName()返回该类的名称。boolean isInterface()返回该类是否是接口。boolean isAbstract()返回该类是否为抽象类。boolean isConcrete()返回该类是否为具体类。boolean isFinal()返回该类是否为final类boolean hasSuperClass()返回该类是否有父类String getSuperClassName()返回父类的名称，没有的话返回null.String[] getInterfaceNames()返回继承的接口数组，如果没有，返回空.String[] getMemberClassNames()返回引用的类的名称。

boolean isAnnotated(String annotationType)是否有匹配的注解类型

Map<String,Object> getAnnotationAttributes(String annotationType,boolean classValuesAsString)获取特定类型注解的属性

getAllAnnotationAttributes(String annotationType) getAnnotatedMethods(String annotationType) hasMetaAnnotation(String annotationType) isAnnotated(String annotationType) hasAnnotatedMethods(String annotationType) 

class ClassMetadataReadingVisitor extends ClassVisitor implements ClassMetadata {}

public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter        implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {}

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {    /**     * Post-process the given merged bean definition for the specified bean.     * @param beanDefinition the merged bean definition for the bean     * @param beanType the actual type of the managed bean instance     * @param beanName the name of the bean     */    void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);}

public class AnnotationBeanWiringInfoResolver implements BeanWiringInfoResolver {}

@Override    public BeanWiringInfo resolveWiringInfo(Object beanInstance) {        Assert.notNull(beanInstance, "Bean instance must not be null");        Configurable annotation = beanInstance.getClass().getAnnotation(Configurable.class);        return (annotation != null ? buildWiringInfo(beanInstance, annotation) : null);    }    /**     * Build the BeanWiringInfo for the given Configurable annotation.     * @param beanInstance the bean instance     * @param annotation the Configurable annotation found on the bean class     * @return the resolved BeanWiringInfo     */    protected BeanWiringInfo buildWiringInfo(Object beanInstance, Configurable annotation) {        if (!Autowire.NO.equals(annotation.autowire())) {            return new BeanWiringInfo(annotation.autowire().value(), annotation.dependencyCheck());        }        else {            if (!"".equals(annotation.value())) {                // explicitly specified bean name                return new BeanWiringInfo(annotation.value(), false);            }            else {                // default bean name                return new BeanWiringInfo(getDefaultBeanName(beanInstance), true);            }        }    }

public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwareAutowireCandidateResolver {}public class GenericTypeAwareAutowireCandidateResolver implements AutowireCandidateResolver, BeanFactoryAware {}

public class RequiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter        implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {}

public class InitDestroyAnnotationBeanPostProcessor        implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {}