public Constructor[] determineCandidateConstructors(Class beanClass,
    String beanName) throws BeansException 
{
		// Quick check on the concurrent map first, with minimal locking.
		Constructor[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
		if (candidateConstructors == null) {
			synchronized (this.candidateConstructorsCache) {
				candidateConstructors = this.candidateConstructorsCache.get(beanClass);
				if (candidateConstructors == null) {
					Constructor[] rawCandidates = beanClass.getDeclaredConstructors();
					List< Constructor > candidates = new ArrayList< Constructor >(rawCandidates.length);
					Constructor requiredConstructor = null;
					Constructor defaultConstructor = null;
					for (int i = 0; i <  rawCandidates.length; i++) {
						Constructor< ? > candidate = rawCandidates[i];
						Annotation annotation = candidate.getAnnotation(getAutowiredAnnotationType());
						if (annotation != null) {
							if (requiredConstructor != null) {
								throw new BeanCreationException("Invalid autowire-marked constructor: " + candidate +
										". Found another constructor with 'required' Autowired annotation: " + requiredConstructor);
							}
							if (candidate.getParameterTypes().length == 0) {
								throw new IllegalStateException("Autowired annotation requires at least one argument: " + candidate);
							}
							boolean required = determineRequiredStatus(annotation);
							if (required) {
								if (!candidates.isEmpty()) {
									throw new BeanCreationException("Invalid autowire-marked constructors: " + candidates +
											". Found another constructor with 'required' Autowired annotation: " + requiredConstructor);
								}
								requiredConstructor = candidate;
							}
							candidates.add(candidate);
						}
						else if (candidate.getParameterTypes().length == 0) {
							defaultConstructor = candidate;
						}
					}
					if (!candidates.isEmpty()) {
						// Add default constructor to list of optional constructors, as fallback.
						if (requiredConstructor == null && defaultConstructor != null) {
							candidates.add(defaultConstructor);
						}
						candidateConstructors = (Constructor[]) candidates.toArray(new Constructor[candidates.size()]);
					}
					else {
						candidateConstructors = new Constructor[0];
					}
					this.candidateConstructorsCache.put(beanClass, candidateConstructors);
				}
			}
		}
		return (candidateConstructors.length  > 0 ? candidateConstructors : null);
}

 protected boolean determineRequiredStatus(Annotation annotation) 
{
		try {
			Method method = ReflectionUtils.findMethod(annotation.annotationType(), this.requiredParameterName);
			return (this.requiredParameterValue == (Boolean) ReflectionUtils.invokeMethod(method, annotation));
		}
		catch (Exception ex) {
			// required by default
			return true;
		}
}

Determine if the annotated field or method requires its dependency.

A 'required' dependency means that autowiring should fail when no beans are found. Otherwise, the autowiring process will simply bypass the field or method when no beans are found.

 protected Map findAutowireCandidates(Class type) throws BeansException 
{
		if (this.beanFactory == null) {
			throw new IllegalStateException("No BeanFactory configured - " +
					"override the getBeanOfType method or specify the 'beanFactory' property");
		}
		return BeanFactoryUtils.beansOfTypeIncludingAncestors(this.beanFactory, type);
}

Obtain all beans of the given type as autowire candidates.

 protected Class getAutowiredAnnotationType() 
{
		return this.autowiredAnnotationType;
}

Return the 'autowired' annotation type.

 public int getOrder() 
{
	  return this.order;
}

 public boolean postProcessAfterInstantiation(Object bean,
    String beanName) throws BeansException 
{
		InjectionMetadata metadata = findAutowiringMetadata(bean.getClass());
		try {
			metadata.injectFields(bean, beanName);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Autowiring of fields failed", ex);
		}
		return true;
}

 public  void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
    Class beanType,
    String beanName) 
{
		if (beanType != null) {
			InjectionMetadata metadata = findAutowiringMetadata(beanType);
			metadata.checkConfigMembers(beanDefinition);
		}
}

 public PropertyValues postProcessPropertyValues(PropertyValues pvs,
    PropertyDescriptor[] pds,
    Object bean,
    String beanName) throws BeansException 
{
		InjectionMetadata metadata = findAutowiringMetadata(bean.getClass());
		try {
			metadata.injectMethods(bean, beanName, pvs);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Autowiring of methods failed", ex);
		}
		return pvs;
}

 public  void processInjection(Object bean) throws BeansException 
{
		InjectionMetadata metadata = findAutowiringMetadata(bean.getClass());
		try {
			metadata.injectFields(bean, null);
			metadata.injectMethods(bean, null, null);
		}
		catch (Throwable ex) {
			throw new BeanCreationException("Autowiring of fields/methods failed", ex);
		}
}

'Native' processing method for direct calls with an arbitrary target instance, resolving all of its fields and methods which are annotated with @Autowired.

 public  void setAutowiredAnnotationType(Class autowiredAnnotationType) 
{
	                                                    	 
		Assert.notNull(autowiredAnnotationType, "'autowiredAnnotationType' must not be null");
		this.autowiredAnnotationType = autowiredAnnotationType;
}

Set the 'autowired' annotation type, to be used on constructors, fields, setter methods and arbitrary config methods.

The default autowired annotation type is the Spring-provided Autowired annotation.

This setter property exists so that developers can provide their own (non-Spring-specific) annotation type to indicate that a member is supposed to be autowired.

 public  void setBeanFactory(BeanFactory beanFactory) throws BeansException 
{
		if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
			throw new IllegalArgumentException(
					"AutowiredAnnotationBeanPostProcessor requires a ConfigurableListableBeanFactory");
		}
		this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}

 public  void setOrder(int order) 
{
	  this.order = order;
}

 public  void setRequiredParameterName(String requiredParameterName) 
{
		this.requiredParameterName = requiredParameterName;
}

Set the name of a parameter of the annotation that specifies whether it is required.

 public  void setRequiredParameterValue(boolean requiredParameterValue) 
{
		this.requiredParameterValue = requiredParameterValue;
}

Set the boolean value that marks a dependency as required

For example if using 'required=true' (the default), this value should be true; but if using 'optional=false', this value should be false.