How to use

ConstructorResolver

in

org.springframework.beans.factory.support

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate,
 * to be injected into other beans which declare a dependency of matching type.
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
    DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
  String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
  resolveBeanClass(mbd, beanDefinitionName);
  if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
    new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
  }
  return resolver.isAutowireCandidate(
      new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}

/**
 * "autowire constructor" (with constructor arguments by type) behavior.
 * Also applied if explicit constructor argument values are specified,
 * matching all remaining arguments with beans from the bean factory.
 * <p>This corresponds to constructor injection: In this mode, a Spring
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param ctors the chosen candidate constructors
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 */
protected BeanWrapper autowireConstructor(
    String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

    argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
        mbd.resolvedConstructorArguments = EMPTY_ARGS;
      bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
      return bw;
    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
    resolvedValues = new ConstructorArgumentValues();
    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
        argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
            getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * mbd parameter specifies a class, rather than a factoryBean, or an instance variable
 * on a factory object itself configured using Dependency Injection.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 * @see #getBean(String, Object[])
 */
protected BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

    argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
  Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
  List<Method> candidateList = new ArrayList<>();
  for (Method candidate : rawCandidates) {
        mbd.resolvedConstructorArguments = EMPTY_ARGS;
      bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
      return bw;
      ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
      resolvedValues = new ConstructorArgumentValues();
      minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            paramNames = pnd.getParameterNames(candidate);
          argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
              paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
return bw;

argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
    argsHolder = createArgumentArray(
        beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);

Object autowiredArgument = resolveAutowiredArgument(
    methodParam, beanName, autowiredBeanNames, converter, fallback);
args.rawArguments[paramIndex] = autowiredArgument;

getUserDeclaredConstructor(candidate), autowiring);

    argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
  Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
  List<Method> candidateList = new ArrayList<>();
  for (Method candidate : rawCandidates) {
        mbd.resolvedConstructorArguments = EMPTY_ARGS;
      bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
      return bw;
      ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
      resolvedValues = new ConstructorArgumentValues();
      minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            paramNames = pnd.getParameterNames(candidate);
          argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
              paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
return bw;

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * mbd parameter specifies a class, rather than a factoryBean, or an instance variable
 * on a factory object itself configured using Dependency Injection.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 * @see #getBean(String, Object[])
 */
protected BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
        paramNames = pnd.getParameterNames(candidate);
      argsHolder = createArgumentArray(
          beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);

GenericTypeResolver.resolveParameterType(methodParam, executable.getDeclaringClass());
if (argValue instanceof AutowiredArgumentMarker) {
  argValue = resolveAutowiredArgument(methodParam, beanName, null, converter, fallback);

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate,
 * to be injected into other beans which declare a dependency of matching type.
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
    DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
  String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
  resolveBeanClass(mbd, beanDefinitionName);
  if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
    new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
  }
  return resolver.isAutowireCandidate(
      new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}

    argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
        mbd.resolvedConstructorArguments = EMPTY_ARGS;
      bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
      return bw;
    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
    resolvedValues = new ConstructorArgumentValues();
    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
        argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
            getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * mbd parameter specifies a class, rather than a factoryBean, or an instance variable
 * on a factory object itself configured using Dependency Injection.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or <code>null</code> if none (-> use constructor argument values from bean definition)
 * @return BeanWrapper for the new instance
 * @see #getBean(String, Object[])
 */
protected BeanWrapper instantiateUsingFactoryMethod(
    String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {
  return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

/**
 * "autowire constructor" (with constructor arguments by type) behavior.
 * Also applied if explicit constructor argument values are specified,
 * matching all remaining arguments with beans from the bean factory.
 * <p>This corresponds to constructor injection: In this mode, a Spring
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param ctors the chosen candidate constructors
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or {@code null} if none (-> use constructor argument values from bean definition)
 * @return a BeanWrapper for the new instance
 */
protected BeanWrapper autowireConstructor(
    String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
  return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

Object autowiredArgument = resolveAutowiredArgument(
    methodParam, beanName, autowiredBeanNames, converter, fallback);
args.rawArguments[paramIndex] = autowiredArgument;

/**
 * Determine whether the specified bean definition qualifies as an autowire candidate,
 * to be injected into other beans which declare a dependency of matching type.
 * @param beanName the name of the bean definition to check
 * @param mbd the merged bean definition to check
 * @param descriptor the descriptor of the dependency to resolve
 * @return whether the bean should be considered as autowire candidate
 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor) {
  resolveBeanClass(mbd, beanName);
  if (mbd.isFactoryMethodUnique) {
    boolean resolve;
    synchronized (mbd.constructorArgumentLock) {
      resolve = (mbd.resolvedConstructorOrFactoryMethod == null);
    }
    if (resolve) {
      new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
    }
  }
  return getAutowireCandidateResolver().isAutowireCandidate(
      new BeanDefinitionHolder(mbd, beanName, getAliases(beanName)), descriptor);
}

/**
 * "autowire constructor" (with constructor arguments by type) behavior.
 * Also applied if explicit constructor argument values are specified,
 * matching all remaining arguments with beans from the bean factory.
 * <p>This corresponds to constructor injection: In this mode, a Spring
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 * @param beanName the name of the bean
 * @param mbd the bean definition for the bean
 * @param ctors the chosen candidate constructors
 * @param explicitArgs argument values passed in programmatically via the getBean method,
 * or <code>null</code> if none (-> use constructor argument values from bean definition)
 * @return BeanWrapper for the new instance
 */
protected BeanWrapper autowireConstructor(
    String beanName, RootBeanDefinition mbd, Constructor[] ctors, Object[] explicitArgs) {
  return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

GenericTypeResolver.resolveParameterType(methodParam, executable.getDeclaringClass());
if (argValue instanceof AutowiredArgumentMarker) {
  argValue = resolveAutowiredArgument(methodParam, beanName, null, converter, fallback);