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:

  • Constructor Details

    • DependencyDescriptor

      public DependencyDescriptor(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(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(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:

    • 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 ResolvableType getResolvableType()
      Build a ResolvableType object for the wrapped parameter/field.
      Since:
      4.0

    • getTypeDescriptor

      public 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:

    • initParameterNameDiscovery

      public void initParameterNameDiscovery(@Nullable 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:

    • 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:

    • equals

      public boolean equals(@Nullable Object other)
      Overrides:
      equals in class InjectionPoint

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class InjectionPoint