org.springframework.beans.factory.config

Class DependencyDescriptor

  • All Implemented Interfaces:
    java.io.Serializable


    public class DependencyDescriptor
    extends InjectionPoint
    implements java.io.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
    • Constructor Detail

      • 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(java.lang.reflect.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(java.lang.reflect.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 Detail

      • 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 java.lang.Object resolveNotUnique(ResolvableType type,
                                                           java.util.Map<java.lang.String,java.lang.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
      • resolveNotUnique

        @Deprecated
         @Nullable
        public java.lang.Object resolveNotUnique(java.lang.Class<?> type,
                                                                        java.util.Map<java.lang.String,java.lang.Object> matchingBeans)
                                                                 throws BeansException
        Deprecated. as of 5.1, in favor of resolveNotUnique(ResolvableType, Map)
        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:
        4.3
      • resolveShortcut

        @Nullable
        public java.lang.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 java.lang.Object resolveCandidate(java.lang.String beanName,
                                                 java.lang.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)
      • setContainingClass

        public void setContainingClass(java.lang.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
      • 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
      • 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 java.lang.String getDependencyName()
        Determine the name of the wrapped parameter/field.
        Returns:
        the declared name (never null)
      • getDependencyType

        public java.lang.Class<?> getDependencyType()
        Determine the declared (non-generic) type of the wrapped parameter/field.
        Returns:
        the declared type (never null)
      • equals

        public boolean equals(java.lang.Object other)
        Overrides:
        equals in class InjectionPoint