Package org.springframework.beans.factory.config

# Class DependencyDescriptor

java.lang.Object
org.springframework.beans.factory.InjectionPoint
org.springframework.beans.factory.config.DependencyDescriptor

All Implemented Interfaces:
  `Serializable`

public class DependencyDescriptor extends InjectionPoint implements Serializable
Descriptor for a specific dependency that is about to be injected. Wraps a constructor parameter, a method parameter or a field, allowing unified access to their metadata.

Since:
  2.5
Author:
  Juergen Hoeller
See Also:
  - Serialized Form

## Field Summary

### Fields inherited from class org.springframework.beans.factory.InjectionPoint

`field, methodParameter`

## Constructor Summary

Constructors
Constructor
Description
`DependencyDescriptor(Field field, boolean required)`
Create a new descriptor for a field.
`DependencyDescriptor(Field field, boolean required, boolean eager)`
Create a new descriptor for a field.
`DependencyDescriptor(DependencyDescriptor original)`
Copy constructor.
`DependencyDescriptor(org.springframework.core.MethodParameter methodParameter, boolean required)`
Create a new descriptor for a method or constructor parameter.
`DependencyDescriptor(org.springframework.core.MethodParameter methodParameter, boolean required, boolean eager)`
Create a new descriptor for a method or constructor parameter.

## Method Summary

Modifier and Type
Method
Description
`boolean`
`equals(Object other)`
`boolean`
`fallbackMatchAllowed()`
Return whether a fallback match is allowed.
`DependencyDescriptor`
`forFallbackMatch()`
Return a variant of this descriptor that is intended for a fallback match.
`String`
`getDependencyName()`
Determine the name of the wrapped parameter/field.
`Class<?>`
`getDependencyType()`
Determine the declared (non-generic) type of the wrapped parameter/field.
`org.springframework.core.ResolvableType`
`getResolvableType()`
Build a `ResolvableType` object for the wrapped parameter/field.
`org.springframework.core.convert.TypeDescriptor`
`getTypeDescriptor()`
Build a `TypeDescriptor` object for the wrapped parameter/field.
`int`
`hashCode()`
`void`
`increaseNestingLevel()`
Increase this descriptor's nesting level.
`void`
`initParameterNameDiscovery(org.springframework.core.ParameterNameDiscoverer parameterNameDiscoverer)`
Initialize parameter name discovery for the underlying method parameter, if any.
`boolean`
`isEager()`
Return whether this dependency is 'eager' in the sense of eagerly resolving potential target beans for type matching.
`boolean`
`isRequired()`
Return whether this dependency is required.
`Object`
`resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)`
Resolve the specified bean name, as a candidate result of the matching algorithm for this dependency, to a bean instance from the given factory.
`Object`
`resolveNotUnique(org.springframework.core.ResolvableType type, Map<String,Object> matchingBeans)`
Resolve the specified not-unique scenario: by default, throwing a `NoUniqueBeanDefinitionException`.
`Object`
`resolveShortcut(BeanFactory beanFactory)`
Resolve a shortcut for this dependency against the given factory, for example taking some pre-resolved information into account.
`void`
`setContainingClass(Class<?> containingClass)`
Optionally set the concrete class that contains this dependency.
`boolean`
`supportsLazyResolution()`
Determine whether this dependency supports lazy resolution, for example, through extra proxying.
`boolean`
`usesStandardBeanLookup()`
Determine whether this descriptor uses a standard bean lookup in `resolveCandidate(String, Class, BeanFactory)` and therefore qualifies for factory-level shortcut resolution.

### Methods inherited from class org.springframework.beans.factory.InjectionPoint

`getAnnotatedElement, getAnnotation, getAnnotations, getDeclaredType, getField, getMember, getMethodParameter, obtainMethodParameter, toString`

### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

## Constructor Details

### DependencyDescriptor

public DependencyDescriptor(org.springframework.core.MethodParameter methodParameter, boolean required)
Create a new descriptor for a method or constructor parameter. Considers the dependency as 'eager'.

Parameters:
  `methodParameter` - the MethodParameter to wrap
  `required` - whether the dependency is required

### DependencyDescriptor

public DependencyDescriptor(org.springframework.core.MethodParameter methodParameter, boolean required, boolean eager)
Create a new descriptor for a method or constructor parameter.

Parameters:
  `methodParameter` - the MethodParameter to wrap
  `required` - whether the dependency is required
  `eager` - whether this dependency is 'eager' in the sense of eagerly resolving potential target beans for type matching

### DependencyDescriptor

public DependencyDescriptor(Field field, boolean required)
Create a new descriptor for a field. Considers the dependency as 'eager'.

Parameters:
  `field` - the field to wrap
  `required` - whether the dependency is required

### DependencyDescriptor

public DependencyDescriptor(Field field, boolean required, boolean eager)
Create a new descriptor for a field.

Parameters:
  `field` - the field to wrap
  `required` - whether the dependency is required
  `eager` - whether this dependency is 'eager' in the sense of eagerly resolving potential target beans for type matching

### DependencyDescriptor

public DependencyDescriptor(DependencyDescriptor original)
Copy constructor.

Parameters:
  `original` - the original descriptor to create a copy from

## Method Details

### isRequired

public boolean isRequired()
Return whether this dependency is required.

Optional semantics are derived from Java 8's `Optional`, any variant of a parameter-level `Nullable` annotation (such as from JSR-305 or the FindBugs set of annotations), or a language-level nullable type declaration in Kotlin.

### isEager

public boolean isEager()
Return whether this dependency is 'eager' in the sense of eagerly resolving potential target beans for type matching.

### resolveNotUnique

@Nullable public Object resolveNotUnique(org.springframework.core.ResolvableType type, Map<String,Object> matchingBeans) throws BeansException
Resolve the specified not-unique scenario: by default, throwing a `NoUniqueBeanDefinitionException`.

Subclasses may override this to select one of the instances or to opt out with no result at all through returning `null`.

Parameters:
  `type` - the requested bean type
  `matchingBeans` - a map of bean names and corresponding bean instances which have been pre-selected for the given type (qualifiers etc already applied)
Returns:
  a bean instance to proceed with, or `null` for none
Throws:
  `BeansException` - in case of the not-unique scenario being fatal
Since:
  5.1

### resolveShortcut

@Nullable public Object resolveShortcut(BeanFactory beanFactory) throws BeansException
Resolve a shortcut for this dependency against the given factory, for example taking some pre-resolved information into account.

The resolution algorithm will first attempt to resolve a shortcut through this method before going into the regular type matching algorithm across all beans. Subclasses may override this method to improve resolution performance based on pre-cached information while still receiving `InjectionPoint` exposure etc.

Parameters:
  `beanFactory` - the associated factory
Returns:
  the shortcut result if any, or `null` if none
Throws:
  `BeansException` - if the shortcut could not be obtained
Since:
  4.3.1

### resolveCandidate

public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) throws BeansException
Resolve the specified bean name, as a candidate result of the matching algorithm for this dependency, to a bean instance from the given factory.

The default implementation calls `BeanFactory.getBean(String)`. Subclasses may provide additional arguments or other customizations.

Parameters:
  `beanName` - the bean name, as a candidate result for this dependency
  `requiredType` - the expected type of the bean (as an assertion)
  `beanFactory` - the associated factory
Returns:
  the bean instance (never `null`)
Throws:
  `BeansException` - if the bean could not be obtained
Since:
  4.3.2
See Also:
  - `BeanFactory.getBean(String)`

### increaseNestingLevel

public void increaseNestingLevel()
Increase this descriptor's nesting level.

### setContainingClass

public void setContainingClass(Class<?> containingClass)
Optionally set the concrete class that contains this dependency. This may differ from the class that declares the parameter/field in that it may be a subclass thereof, potentially substituting type variables.

Since:
  4.0

### getResolvableType

public org.springframework.core.ResolvableType getResolvableType()
Build a `ResolvableType` object for the wrapped parameter/field.

Since:
  4.0

### getTypeDescriptor

public org.springframework.core.convert.TypeDescriptor getTypeDescriptor()
Build a `TypeDescriptor` object for the wrapped parameter/field.

Since:
  5.1.4

### fallbackMatchAllowed

public boolean fallbackMatchAllowed()
Return whether a fallback match is allowed.

This is `false` by default but may be overridden to return `true` in order to suggest to an `AutowireCandidateResolver` that a fallback match is acceptable as well.

Since:
  4.0

### forFallbackMatch

public DependencyDescriptor forFallbackMatch()
Return a variant of this descriptor that is intended for a fallback match.

Since:
  4.0
See Also:
  - `fallbackMatchAllowed()`

### initParameterNameDiscovery

public void initParameterNameDiscovery(@Nullable org.springframework.core.ParameterNameDiscoverer parameterNameDiscoverer)
Initialize parameter name discovery for the underlying method parameter, if any.

This method does not actually try to retrieve the parameter name at this point; it just allows discovery to happen when the application calls `getDependencyName()` (if ever).

### getDependencyName

@Nullable public String getDependencyName()
Determine the name of the wrapped parameter/field.

Returns:
  the declared name (may be `null` if unresolvable)

### getDependencyType

public Class<?> getDependencyType()
Determine the declared (non-generic) type of the wrapped parameter/field.

Returns:
  the declared type (never `null`)

### supportsLazyResolution

public boolean supportsLazyResolution()
Determine whether this dependency supports lazy resolution, for example, through extra proxying. The default is `true`.

Since:
  6.1.2
See Also:
  - `AutowireCandidateResolver.getLazyResolutionProxyIfNecessary(org.springframework.beans.factory.config.DependencyDescriptor, java.lang.String)`

### usesStandardBeanLookup

public boolean usesStandardBeanLookup()
Determine whether this descriptor uses a standard bean lookup in `resolveCandidate(String, Class, BeanFactory)` and therefore qualifies for factory-level shortcut resolution.

By default, the `DependencyDescriptor` class itself uses a standard bean lookup but subclasses may override this. If a subclass overrides other methods but preserves a standard bean lookup, it may override this method to return `true`.

Since:
  6.2
See Also:
  - `resolveCandidate(String, Class, BeanFactory)`

### equals

public boolean equals(@Nullable Object other)

Overrides:
  `equals` in class `InjectionPoint`

### hashCode

public int hashCode()

Overrides:
  `hashCode` in class `InjectionPoint`