Search in sources :

Example 1 with UnsatisfiedDependencyException

use of cn.taketoday.beans.factory.UnsatisfiedDependencyException in project today-infrastructure by TAKETODAY.

the class ConstructorResolver method autowireConstructor.

/**
 * "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 Framework
 * bean factory is able to host components that expect constructor-based
 * dependency resolution.
 *
 * @param beanName the name of the bean
 * @param merged the merged bean definition for the bean
 * @param chosenCtors chosen candidate constructors (or {@code null} if none)
 * @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
 */
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition merged, @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
    BeanWrapperImpl wrapper = new BeanWrapperImpl();
    this.beanFactory.initBeanWrapper(wrapper);
    Constructor<?> constructorToUse = null;
    ArgumentsHolder argsHolderToUse = null;
    Object[] argsToUse = null;
    if (explicitArgs != null) {
        argsToUse = explicitArgs;
    } else {
        Object[] argsToResolve = null;
        synchronized (merged.constructorArgumentLock) {
            constructorToUse = (Constructor<?>) merged.resolvedConstructorOrFactoryMethod;
            if (constructorToUse != null && merged.constructorArgumentsResolved) {
                // Found a cached constructor...
                argsToUse = merged.resolvedConstructorArguments;
                if (argsToUse == null) {
                    argsToResolve = merged.preparedConstructorArguments;
                }
            }
        }
        if (argsToResolve != null) {
            argsToUse = resolvePreparedArguments(beanName, merged, constructorToUse, argsToResolve, wrapper);
        }
    }
    if (constructorToUse == null || argsToUse == null) {
        // Take specified constructors, if any.
        Constructor<?>[] candidates = chosenCtors;
        if (candidates == null) {
            Class<?> beanClass = merged.getBeanClass();
            try {
                candidates = merged.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : beanClass.getConstructors();
            } catch (Throwable ex) {
                throw new BeanCreationException(merged.getResourceDescription(), beanName, "Resolution of declared constructors on bean Class [" + beanClass.getName() + "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
            }
        }
        if (candidates.length == 1 && explicitArgs == null && !merged.hasConstructorArgumentValues()) {
            Constructor<?> uniqueCandidate = candidates[0];
            if (uniqueCandidate.getParameterCount() == 0) {
                synchronized (merged.constructorArgumentLock) {
                    merged.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                    merged.constructorArgumentsResolved = true;
                    merged.resolvedConstructorArguments = EMPTY_ARGS;
                }
                wrapper.setBeanInstance(instantiate(beanName, merged, uniqueCandidate, EMPTY_ARGS));
                return wrapper;
            }
        }
        // Need to resolve the constructor.
        boolean autowiring = chosenCtors != null || merged.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
        ConstructorArgumentValues resolvedValues = null;
        int minNrOfArgs;
        if (explicitArgs != null) {
            minNrOfArgs = explicitArgs.length;
        } else {
            ConstructorArgumentValues cargs = merged.getConstructorArgumentValues();
            resolvedValues = new ConstructorArgumentValues();
            minNrOfArgs = resolveConstructorArguments(beanName, merged, wrapper, cargs, resolvedValues);
        }
        AutowireUtils.sortConstructors(candidates);
        int minTypeDiffWeight = Integer.MAX_VALUE;
        Set<Constructor<?>> ambiguousConstructors = null;
        Deque<UnsatisfiedDependencyException> causes = null;
        for (Constructor<?> candidate : candidates) {
            int parameterCount = candidate.getParameterCount();
            if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
                // do not look any further, there are only less greedy constructors left.
                break;
            }
            if (parameterCount < minNrOfArgs) {
                continue;
            }
            ArgumentsHolder argsHolder;
            Class<?>[] paramTypes = candidate.getParameterTypes();
            if (resolvedValues != null) {
                try {
                    String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
                    if (paramNames == null) {
                        ParameterNameDiscoverer pnd = beanFactory.getParameterNameDiscoverer();
                        if (pnd != null) {
                            paramNames = pnd.getParameterNames(candidate);
                        }
                    }
                    argsHolder = createArgumentArray(beanName, merged, resolvedValues, paramTypes, paramNames, getUserDeclaredConstructor(candidate), wrapper, autowiring, candidates.length == 1);
                } catch (UnsatisfiedDependencyException ex) {
                    if (log.isTraceEnabled()) {
                        log.trace("Ignoring constructor [{}] of bean '{}': {}", candidate, beanName, ex);
                    }
                    // Swallow and try next constructor.
                    if (causes == null) {
                        causes = new ArrayDeque<>(1);
                    }
                    causes.add(ex);
                    continue;
                }
            } else {
                // Explicit arguments given -> arguments length must match exactly.
                if (parameterCount != explicitArgs.length) {
                    continue;
                }
                argsHolder = new ArgumentsHolder(explicitArgs);
            }
            int typeDiffWeight = merged.isLenientConstructorResolution() ? argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes);
            // Choose this constructor if it represents the closest match.
            if (typeDiffWeight < minTypeDiffWeight) {
                constructorToUse = candidate;
                argsHolderToUse = argsHolder;
                argsToUse = argsHolder.arguments;
                minTypeDiffWeight = typeDiffWeight;
                ambiguousConstructors = null;
            } else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
                if (ambiguousConstructors == null) {
                    ambiguousConstructors = new LinkedHashSet<>();
                    ambiguousConstructors.add(constructorToUse);
                }
                ambiguousConstructors.add(candidate);
            }
        }
        if (constructorToUse == null) {
            if (causes != null) {
                UnsatisfiedDependencyException ex = causes.removeLast();
                for (Exception cause : causes) {
                    beanFactory.onSuppressedException(cause);
                }
                throw ex;
            }
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "Could not resolve matching constructor on bean class [" + merged.getBeanClassName() + "] " + "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
        } else if (ambiguousConstructors != null && !merged.isLenientConstructorResolution()) {
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "Ambiguous constructor matches found on bean class [" + merged.getBeanClassName() + "] " + "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " + ambiguousConstructors);
        }
        if (explicitArgs == null && argsHolderToUse != null) {
            argsHolderToUse.storeCache(merged, constructorToUse);
        }
    }
    Assert.state(argsToUse != null, "Unresolved constructor arguments");
    wrapper.setBeanInstance(instantiate(beanName, merged, constructorToUse, argsToUse));
    return wrapper;
}
Also used : LinkedHashSet(java.util.LinkedHashSet) BeanCreationException(cn.taketoday.beans.factory.BeanCreationException) BeanWrapperImpl(cn.taketoday.beans.BeanWrapperImpl) Constructor(java.lang.reflect.Constructor) ParameterNameDiscoverer(cn.taketoday.core.ParameterNameDiscoverer) InjectionPoint(cn.taketoday.beans.factory.InjectionPoint) ArrayDeque(java.util.ArrayDeque) NoUniqueBeanDefinitionException(cn.taketoday.beans.factory.NoUniqueBeanDefinitionException) NoSuchBeanDefinitionException(cn.taketoday.beans.factory.NoSuchBeanDefinitionException) BeansException(cn.taketoday.beans.BeansException) BeanCreationException(cn.taketoday.beans.factory.BeanCreationException) TypeMismatchException(cn.taketoday.beans.TypeMismatchException) UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException) BeanDefinitionStoreException(cn.taketoday.beans.factory.BeanDefinitionStoreException) ConstructorArgumentValues(cn.taketoday.beans.factory.config.ConstructorArgumentValues) UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException)

Example 2 with UnsatisfiedDependencyException

use of cn.taketoday.beans.factory.UnsatisfiedDependencyException in project today-infrastructure by TAKETODAY.

the class ConstructorResolver method createArgumentArray.

/**
 * Create an array of arguments to invoke a constructor or factory method,
 * given the resolved constructor argument values.
 */
private ArgumentsHolder createArgumentArray(String beanName, RootBeanDefinition merged, @Nullable ConstructorArgumentValues resolvedValues, Class<?>[] paramTypes, @Nullable String[] paramNames, Executable executable, BeanWrapper wrapper, boolean autowiring, boolean fallback) throws UnsatisfiedDependencyException {
    TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
    TypeConverter converter = customConverter != null ? customConverter : wrapper;
    ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
    HashSet<ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
    LinkedHashSet<String> autowiredBeanNames = new LinkedHashSet<>(4);
    for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
        Class<?> paramType = paramTypes[paramIndex];
        String paramName = paramNames != null ? paramNames[paramIndex] : "";
        // Try to find matching constructor argument value, either indexed or generic.
        ValueHolder valueHolder = null;
        if (resolvedValues != null) {
            valueHolder = resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
            // it could match after type conversion (for example, String -> int).
            if (valueHolder == null && (!autowiring || paramTypes.length == resolvedValues.getArgumentCount())) {
                valueHolder = resolvedValues.getGenericArgumentValue(null, null, usedValueHolders);
            }
        }
        if (valueHolder != null) {
            // We found a potential match - let's give it a try.
            // Do not consider the same value definition multiple times!
            usedValueHolders.add(valueHolder);
            Object originalValue = valueHolder.getValue();
            Object convertedValue;
            if (valueHolder.isConverted()) {
                convertedValue = valueHolder.getConvertedValue();
                args.preparedArguments[paramIndex] = convertedValue;
            } else {
                MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
                try {
                    convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
                } catch (TypeMismatchException ex) {
                    throw new UnsatisfiedDependencyException(merged.getResourceDescription(), beanName, new InjectionPoint(methodParam), "Could not convert argument value of type [" + ObjectUtils.nullSafeClassName(valueHolder.getValue()) + "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
                }
                Object sourceHolder = valueHolder.getSource();
                if (sourceHolder instanceof ValueHolder) {
                    Object sourceValue = ((ValueHolder) sourceHolder).getValue();
                    args.resolveNecessary = true;
                    args.preparedArguments[paramIndex] = sourceValue;
                }
            }
            args.arguments[paramIndex] = convertedValue;
            args.rawArguments[paramIndex] = originalValue;
        } else {
            MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
            // have to fail creating an argument array for the given constructor.
            if (!autowiring) {
                throw new UnsatisfiedDependencyException(merged.getResourceDescription(), beanName, new InjectionPoint(methodParam), "Ambiguous argument values for parameter of type [" + paramType.getName() + "] - did you specify the correct bean references as arguments?");
            }
            try {
                Object autowiredArgument = resolveAutowiredArgument(methodParam, beanName, autowiredBeanNames, converter, fallback);
                args.resolveNecessary = true;
                args.arguments[paramIndex] = autowiredArgument;
                args.rawArguments[paramIndex] = autowiredArgument;
                args.preparedArguments[paramIndex] = autowiredArgumentMarker;
            } catch (BeansException ex) {
                throw new UnsatisfiedDependencyException(merged.getResourceDescription(), beanName, new InjectionPoint(methodParam), ex);
            }
        }
    }
    for (String autowiredBeanName : autowiredBeanNames) {
        beanFactory.registerDependentBean(autowiredBeanName, beanName);
        if (log.isDebugEnabled()) {
            log.debug("Autowiring by type from bean name '{}' via {} to bean named '{}'", beanName, (executable instanceof Constructor ? "constructor" : "factory method"), autowiredBeanName);
        }
    }
    return args;
}
Also used : LinkedHashSet(java.util.LinkedHashSet) InjectionPoint(cn.taketoday.beans.factory.InjectionPoint) Constructor(java.lang.reflect.Constructor) TypeMismatchException(cn.taketoday.beans.TypeMismatchException) ValueHolder(cn.taketoday.beans.factory.config.ConstructorArgumentValues.ValueHolder) InjectionPoint(cn.taketoday.beans.factory.InjectionPoint) TypeConverter(cn.taketoday.beans.TypeConverter) UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException) MethodParameter(cn.taketoday.core.MethodParameter) HashSet(java.util.HashSet) LinkedHashSet(java.util.LinkedHashSet) BeansException(cn.taketoday.beans.BeansException)

Example 3 with UnsatisfiedDependencyException

use of cn.taketoday.beans.factory.UnsatisfiedDependencyException in project today-infrastructure by TAKETODAY.

the class ConstructorResolver method instantiateUsingFactoryMethod.

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * bean definition parameter specifies a class, rather than a "factory-bean", or
 * an instance variable on a factory object itself configured using Dependency Injection.
 * <p>Implementation requires iterating over the static or instance methods with the
 * name specified in the BeanDefinition (the method may be overloaded) and trying
 * to match with the parameters. We don't have the types attached to constructor args,
 * so trial and error is the only way to go here. The explicitArgs array may contain
 * argument values passed in programmatically via the corresponding getBean method.
 *
 * @param merged the merged 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
 */
public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition merged, @Nullable Object[] explicitArgs) {
    BeanWrapperImpl wrapper = new BeanWrapperImpl();
    beanFactory.initBeanWrapper(wrapper);
    boolean isStatic;
    Object factoryBean;
    Class<?> factoryClass;
    String factoryBeanName = merged.getFactoryBeanName();
    if (factoryBeanName != null) {
        if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(merged.getResourceDescription(), "factory-bean reference points back to the same bean definition");
        }
        factoryBean = beanFactory.getBean(factoryBeanName);
        if (merged.isSingleton() && beanFactory.containsSingleton(beanName)) {
            throw new ImplicitlyAppearedSingletonException();
        }
        beanFactory.registerDependentBean(factoryBeanName, beanName);
        factoryClass = factoryBean.getClass();
        isStatic = false;
    } else {
        // It's a static factory method on the bean class.
        if (!merged.hasBeanClass()) {
            throw new BeanDefinitionStoreException(merged.getResourceDescription(), "bean definition declares neither a bean class nor a factory-bean reference");
        }
        factoryBean = null;
        factoryClass = merged.getBeanClass();
        isStatic = true;
    }
    Method factoryMethodToUse = null;
    ArgumentsHolder argsHolderToUse = null;
    Object[] argsToUse = null;
    if (explicitArgs != null) {
        argsToUse = explicitArgs;
    } else {
        Object[] argsToResolve = null;
        synchronized (merged.constructorArgumentLock) {
            factoryMethodToUse = (Method) merged.resolvedConstructorOrFactoryMethod;
            if (factoryMethodToUse != null && merged.constructorArgumentsResolved) {
                // Found a cached factory method...
                argsToUse = merged.resolvedConstructorArguments;
                if (argsToUse == null) {
                    argsToResolve = merged.preparedConstructorArguments;
                }
            }
        }
        if (argsToResolve != null) {
            argsToUse = resolvePreparedArguments(beanName, merged, factoryMethodToUse, argsToResolve, wrapper);
        }
    }
    if (factoryMethodToUse == null || argsToUse == null) {
        // Need to determine the factory method...
        // Try all methods with this name to see if they match the given arguments.
        factoryClass = ClassUtils.getUserClass(factoryClass);
        List<Method> candidates = null;
        if (merged.isFactoryMethodUnique) {
            if (factoryMethodToUse == null) {
                factoryMethodToUse = merged.getResolvedFactoryMethod();
            }
            if (factoryMethodToUse != null) {
                candidates = Collections.singletonList(factoryMethodToUse);
            }
        }
        if (candidates == null) {
            candidates = new ArrayList<>();
            Method[] rawCandidates = getCandidateMethods(factoryClass, merged);
            for (Method candidate : rawCandidates) {
                if (Modifier.isStatic(candidate.getModifiers()) == isStatic && merged.isFactoryMethod(candidate)) {
                    candidates.add(candidate);
                }
            }
        }
        if (candidates.size() == 1 && explicitArgs == null && !merged.hasConstructorArgumentValues()) {
            Method uniqueCandidate = candidates.get(0);
            if (uniqueCandidate.getParameterCount() == 0) {
                merged.factoryMethodToIntrospect = uniqueCandidate;
                synchronized (merged.constructorArgumentLock) {
                    merged.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                    merged.constructorArgumentsResolved = true;
                    merged.resolvedConstructorArguments = EMPTY_ARGS;
                }
                wrapper.setBeanInstance(instantiate(beanName, merged, factoryBean, uniqueCandidate, EMPTY_ARGS));
                return wrapper;
            }
        }
        if (candidates.size() > 1) {
            // explicitly skip immutable singletonList
            candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
        }
        ConstructorArgumentValues resolvedValues = null;
        boolean autowiring = (merged.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
        int minTypeDiffWeight = Integer.MAX_VALUE;
        Set<Method> ambiguousFactoryMethods = null;
        int minNrOfArgs;
        if (explicitArgs != null) {
            minNrOfArgs = explicitArgs.length;
        } else {
            // arguments specified in the constructor arguments held in the bean definition.
            if (merged.hasConstructorArgumentValues()) {
                ConstructorArgumentValues cargs = merged.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                minNrOfArgs = resolveConstructorArguments(beanName, merged, wrapper, cargs, resolvedValues);
            } else {
                minNrOfArgs = 0;
            }
        }
        Deque<UnsatisfiedDependencyException> causes = null;
        for (Method candidate : candidates) {
            int parameterCount = candidate.getParameterCount();
            if (parameterCount >= minNrOfArgs) {
                ArgumentsHolder argsHolder;
                Class<?>[] paramTypes = candidate.getParameterTypes();
                if (explicitArgs != null) {
                    // Explicit arguments given -> arguments length must match exactly.
                    if (paramTypes.length != explicitArgs.length) {
                        continue;
                    }
                    argsHolder = new ArgumentsHolder(explicitArgs);
                } else {
                    // Resolved constructor arguments: type conversion and/or autowiring necessary.
                    try {
                        String[] paramNames = null;
                        ParameterNameDiscoverer pnd = beanFactory.getParameterNameDiscoverer();
                        if (pnd != null) {
                            paramNames = pnd.getParameterNames(candidate);
                        }
                        argsHolder = createArgumentArray(beanName, merged, resolvedValues, paramTypes, paramNames, candidate, wrapper, autowiring, candidates.size() == 1);
                    } catch (UnsatisfiedDependencyException ex) {
                        if (log.isTraceEnabled()) {
                            log.trace("Ignoring factory method [{}] of bean '{}': {}", candidate, beanName, ex);
                        }
                        // Swallow and try next overloaded factory method.
                        if (causes == null) {
                            causes = new ArrayDeque<>(1);
                        }
                        causes.add(ex);
                        continue;
                    }
                }
                int typeDiffWeight = merged.isLenientConstructorResolution() ? argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes);
                // Choose this factory method if it represents the closest match.
                if (typeDiffWeight < minTypeDiffWeight) {
                    factoryMethodToUse = candidate;
                    argsHolderToUse = argsHolder;
                    argsToUse = argsHolder.arguments;
                    minTypeDiffWeight = typeDiffWeight;
                    ambiguousFactoryMethods = null;
                } else // and explicitly ignore overridden methods (with the same parameter signature).
                if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight && !merged.isLenientConstructorResolution() && paramTypes.length == factoryMethodToUse.getParameterCount() && !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                    if (ambiguousFactoryMethods == null) {
                        ambiguousFactoryMethods = new LinkedHashSet<>();
                        ambiguousFactoryMethods.add(factoryMethodToUse);
                    }
                    ambiguousFactoryMethods.add(candidate);
                }
            }
        }
        if (factoryMethodToUse == null || argsToUse == null) {
            if (causes != null) {
                UnsatisfiedDependencyException ex = causes.removeLast();
                for (Exception cause : causes) {
                    beanFactory.onSuppressedException(cause);
                }
                throw ex;
            }
            ArrayList<String> argTypes = new ArrayList<>(minNrOfArgs);
            if (explicitArgs != null) {
                for (Object arg : explicitArgs) {
                    argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
                }
            } else if (resolvedValues != null) {
                LinkedHashSet<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
                valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                for (ValueHolder value : valueHolders) {
                    String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) : (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
                    argTypes.add(argType);
                }
            }
            String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "No matching factory method found on class [" + factoryClass.getName() + "]: " + (merged.getFactoryBeanName() != null ? "factory bean '" + merged.getFactoryBeanName() + "'; " : "") + "factory method '" + merged.getFactoryMethodName() + "(" + argDesc + ")'. " + "Check that a method with the specified name " + (minNrOfArgs > 0 ? "and arguments " : "") + "exists and that it is " + (isStatic ? "static" : "non-static") + ".");
        } else if (void.class == factoryMethodToUse.getReturnType()) {
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "Invalid factory method '" + merged.getFactoryMethodName() + "' on class [" + factoryClass.getName() + "]: needs to have a non-void return type!");
        } else if (ambiguousFactoryMethods != null) {
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "Ambiguous factory method matches found on class [" + factoryClass.getName() + "] " + "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " + ambiguousFactoryMethods);
        }
        if (explicitArgs == null && argsHolderToUse != null) {
            merged.factoryMethodToIntrospect = factoryMethodToUse;
            argsHolderToUse.storeCache(merged, factoryMethodToUse);
        }
    }
    wrapper.setBeanInstance(instantiate(beanName, merged, factoryBean, factoryMethodToUse, argsToUse));
    return wrapper;
}
Also used : LinkedHashSet(java.util.LinkedHashSet) BeanCreationException(cn.taketoday.beans.factory.BeanCreationException) BeanWrapperImpl(cn.taketoday.beans.BeanWrapperImpl) BeanDefinitionStoreException(cn.taketoday.beans.factory.BeanDefinitionStoreException) ParameterNameDiscoverer(cn.taketoday.core.ParameterNameDiscoverer) ArrayList(java.util.ArrayList) UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException) Method(java.lang.reflect.Method) ValueHolder(cn.taketoday.beans.factory.config.ConstructorArgumentValues.ValueHolder) InjectionPoint(cn.taketoday.beans.factory.InjectionPoint) ArrayDeque(java.util.ArrayDeque) NoUniqueBeanDefinitionException(cn.taketoday.beans.factory.NoUniqueBeanDefinitionException) NoSuchBeanDefinitionException(cn.taketoday.beans.factory.NoSuchBeanDefinitionException) BeansException(cn.taketoday.beans.BeansException) BeanCreationException(cn.taketoday.beans.factory.BeanCreationException) TypeMismatchException(cn.taketoday.beans.TypeMismatchException) UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException) BeanDefinitionStoreException(cn.taketoday.beans.factory.BeanDefinitionStoreException) ConstructorArgumentValues(cn.taketoday.beans.factory.config.ConstructorArgumentValues)

Example 4 with UnsatisfiedDependencyException

use of cn.taketoday.beans.factory.UnsatisfiedDependencyException in project today-infrastructure by TAKETODAY.

the class AbstractInjectionFailureAnalyzer method getDescription.

@Nullable
private String getDescription(Throwable rootFailure) {
    UnsatisfiedDependencyException unsatisfiedDependency = findMostNestedCause(rootFailure, UnsatisfiedDependencyException.class);
    if (unsatisfiedDependency != null) {
        return getDescription(unsatisfiedDependency);
    }
    BeanInstantiationException beanInstantiationException = findMostNestedCause(rootFailure, BeanInstantiationException.class);
    if (beanInstantiationException != null) {
        return getDescription(beanInstantiationException);
    }
    return null;
}
Also used : UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException) BeanInstantiationException(cn.taketoday.beans.BeanInstantiationException) Nullable(cn.taketoday.lang.Nullable)

Example 5 with UnsatisfiedDependencyException

use of cn.taketoday.beans.factory.UnsatisfiedDependencyException in project today-framework by TAKETODAY.

the class ConstructorResolver method instantiateUsingFactoryMethod.

/**
 * Instantiate the bean using a named factory method. The method may be static, if the
 * bean definition parameter specifies a class, rather than a "factory-bean", or
 * an instance variable on a factory object itself configured using Dependency Injection.
 * <p>Implementation requires iterating over the static or instance methods with the
 * name specified in the BeanDefinition (the method may be overloaded) and trying
 * to match with the parameters. We don't have the types attached to constructor args,
 * so trial and error is the only way to go here. The explicitArgs array may contain
 * argument values passed in programmatically via the corresponding getBean method.
 *
 * @param merged the merged 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
 */
public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition merged, @Nullable Object[] explicitArgs) {
    BeanWrapperImpl wrapper = new BeanWrapperImpl();
    beanFactory.initBeanWrapper(wrapper);
    boolean isStatic;
    Object factoryBean;
    Class<?> factoryClass;
    String factoryBeanName = merged.getFactoryBeanName();
    if (factoryBeanName != null) {
        if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(merged.getResourceDescription(), "factory-bean reference points back to the same bean definition");
        }
        factoryBean = beanFactory.getBean(factoryBeanName);
        if (merged.isSingleton() && beanFactory.containsSingleton(beanName)) {
            throw new ImplicitlyAppearedSingletonException();
        }
        beanFactory.registerDependentBean(factoryBeanName, beanName);
        factoryClass = factoryBean.getClass();
        isStatic = false;
    } else {
        // It's a static factory method on the bean class.
        if (!merged.hasBeanClass()) {
            throw new BeanDefinitionStoreException(merged.getResourceDescription(), "bean definition declares neither a bean class nor a factory-bean reference");
        }
        factoryBean = null;
        factoryClass = merged.getBeanClass();
        isStatic = true;
    }
    Method factoryMethodToUse = null;
    ArgumentsHolder argsHolderToUse = null;
    Object[] argsToUse = null;
    if (explicitArgs != null) {
        argsToUse = explicitArgs;
    } else {
        Object[] argsToResolve = null;
        synchronized (merged.constructorArgumentLock) {
            factoryMethodToUse = (Method) merged.resolvedConstructorOrFactoryMethod;
            if (factoryMethodToUse != null && merged.constructorArgumentsResolved) {
                // Found a cached factory method...
                argsToUse = merged.resolvedConstructorArguments;
                if (argsToUse == null) {
                    argsToResolve = merged.preparedConstructorArguments;
                }
            }
        }
        if (argsToResolve != null) {
            argsToUse = resolvePreparedArguments(beanName, merged, factoryMethodToUse, argsToResolve, wrapper);
        }
    }
    if (factoryMethodToUse == null || argsToUse == null) {
        // Need to determine the factory method...
        // Try all methods with this name to see if they match the given arguments.
        factoryClass = ClassUtils.getUserClass(factoryClass);
        List<Method> candidates = null;
        if (merged.isFactoryMethodUnique) {
            if (factoryMethodToUse == null) {
                factoryMethodToUse = merged.getResolvedFactoryMethod();
            }
            if (factoryMethodToUse != null) {
                candidates = Collections.singletonList(factoryMethodToUse);
            }
        }
        if (candidates == null) {
            candidates = new ArrayList<>();
            Method[] rawCandidates = getCandidateMethods(factoryClass, merged);
            for (Method candidate : rawCandidates) {
                if (Modifier.isStatic(candidate.getModifiers()) == isStatic && merged.isFactoryMethod(candidate)) {
                    candidates.add(candidate);
                }
            }
        }
        if (candidates.size() == 1 && explicitArgs == null && !merged.hasConstructorArgumentValues()) {
            Method uniqueCandidate = candidates.get(0);
            if (uniqueCandidate.getParameterCount() == 0) {
                merged.factoryMethodToIntrospect = uniqueCandidate;
                synchronized (merged.constructorArgumentLock) {
                    merged.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                    merged.constructorArgumentsResolved = true;
                    merged.resolvedConstructorArguments = EMPTY_ARGS;
                }
                wrapper.setBeanInstance(instantiate(beanName, merged, factoryBean, uniqueCandidate, EMPTY_ARGS));
                return wrapper;
            }
        }
        if (candidates.size() > 1) {
            // explicitly skip immutable singletonList
            candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
        }
        ConstructorArgumentValues resolvedValues = null;
        boolean autowiring = (merged.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
        int minTypeDiffWeight = Integer.MAX_VALUE;
        Set<Method> ambiguousFactoryMethods = null;
        int minNrOfArgs;
        if (explicitArgs != null) {
            minNrOfArgs = explicitArgs.length;
        } else {
            // arguments specified in the constructor arguments held in the bean definition.
            if (merged.hasConstructorArgumentValues()) {
                ConstructorArgumentValues cargs = merged.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                minNrOfArgs = resolveConstructorArguments(beanName, merged, wrapper, cargs, resolvedValues);
            } else {
                minNrOfArgs = 0;
            }
        }
        Deque<UnsatisfiedDependencyException> causes = null;
        for (Method candidate : candidates) {
            int parameterCount = candidate.getParameterCount();
            if (parameterCount >= minNrOfArgs) {
                ArgumentsHolder argsHolder;
                Class<?>[] paramTypes = candidate.getParameterTypes();
                if (explicitArgs != null) {
                    // Explicit arguments given -> arguments length must match exactly.
                    if (paramTypes.length != explicitArgs.length) {
                        continue;
                    }
                    argsHolder = new ArgumentsHolder(explicitArgs);
                } else {
                    // Resolved constructor arguments: type conversion and/or autowiring necessary.
                    try {
                        String[] paramNames = null;
                        ParameterNameDiscoverer pnd = beanFactory.getParameterNameDiscoverer();
                        if (pnd != null) {
                            paramNames = pnd.getParameterNames(candidate);
                        }
                        argsHolder = createArgumentArray(beanName, merged, resolvedValues, paramTypes, paramNames, candidate, wrapper, autowiring, candidates.size() == 1);
                    } catch (UnsatisfiedDependencyException ex) {
                        if (log.isTraceEnabled()) {
                            log.trace("Ignoring factory method [{}] of bean '{}': {}", candidate, beanName, ex);
                        }
                        // Swallow and try next overloaded factory method.
                        if (causes == null) {
                            causes = new ArrayDeque<>(1);
                        }
                        causes.add(ex);
                        continue;
                    }
                }
                int typeDiffWeight = merged.isLenientConstructorResolution() ? argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes);
                // Choose this factory method if it represents the closest match.
                if (typeDiffWeight < minTypeDiffWeight) {
                    factoryMethodToUse = candidate;
                    argsHolderToUse = argsHolder;
                    argsToUse = argsHolder.arguments;
                    minTypeDiffWeight = typeDiffWeight;
                    ambiguousFactoryMethods = null;
                } else // and explicitly ignore overridden methods (with the same parameter signature).
                if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight && !merged.isLenientConstructorResolution() && paramTypes.length == factoryMethodToUse.getParameterCount() && !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                    if (ambiguousFactoryMethods == null) {
                        ambiguousFactoryMethods = new LinkedHashSet<>();
                        ambiguousFactoryMethods.add(factoryMethodToUse);
                    }
                    ambiguousFactoryMethods.add(candidate);
                }
            }
        }
        if (factoryMethodToUse == null || argsToUse == null) {
            if (causes != null) {
                UnsatisfiedDependencyException ex = causes.removeLast();
                for (Exception cause : causes) {
                    beanFactory.onSuppressedException(cause);
                }
                throw ex;
            }
            ArrayList<String> argTypes = new ArrayList<>(minNrOfArgs);
            if (explicitArgs != null) {
                for (Object arg : explicitArgs) {
                    argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
                }
            } else if (resolvedValues != null) {
                LinkedHashSet<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
                valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                for (ValueHolder value : valueHolders) {
                    String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) : (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
                    argTypes.add(argType);
                }
            }
            String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "No matching factory method found on class [" + factoryClass.getName() + "]: " + (merged.getFactoryBeanName() != null ? "factory bean '" + merged.getFactoryBeanName() + "'; " : "") + "factory method '" + merged.getFactoryMethodName() + "(" + argDesc + ")'. " + "Check that a method with the specified name " + (minNrOfArgs > 0 ? "and arguments " : "") + "exists and that it is " + (isStatic ? "static" : "non-static") + ".");
        } else if (void.class == factoryMethodToUse.getReturnType()) {
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "Invalid factory method '" + merged.getFactoryMethodName() + "' on class [" + factoryClass.getName() + "]: needs to have a non-void return type!");
        } else if (ambiguousFactoryMethods != null) {
            throw new BeanCreationException(merged.getResourceDescription(), beanName, "Ambiguous factory method matches found on class [" + factoryClass.getName() + "] " + "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " + ambiguousFactoryMethods);
        }
        if (explicitArgs == null && argsHolderToUse != null) {
            merged.factoryMethodToIntrospect = factoryMethodToUse;
            argsHolderToUse.storeCache(merged, factoryMethodToUse);
        }
    }
    wrapper.setBeanInstance(instantiate(beanName, merged, factoryBean, factoryMethodToUse, argsToUse));
    return wrapper;
}
Also used : LinkedHashSet(java.util.LinkedHashSet) BeanCreationException(cn.taketoday.beans.factory.BeanCreationException) BeanWrapperImpl(cn.taketoday.beans.BeanWrapperImpl) BeanDefinitionStoreException(cn.taketoday.beans.factory.BeanDefinitionStoreException) ParameterNameDiscoverer(cn.taketoday.core.ParameterNameDiscoverer) ArrayList(java.util.ArrayList) UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException) Method(java.lang.reflect.Method) ValueHolder(cn.taketoday.beans.factory.config.ConstructorArgumentValues.ValueHolder) InjectionPoint(cn.taketoday.beans.factory.InjectionPoint) ArrayDeque(java.util.ArrayDeque) NoUniqueBeanDefinitionException(cn.taketoday.beans.factory.NoUniqueBeanDefinitionException) NoSuchBeanDefinitionException(cn.taketoday.beans.factory.NoSuchBeanDefinitionException) BeansException(cn.taketoday.beans.BeansException) BeanCreationException(cn.taketoday.beans.factory.BeanCreationException) TypeMismatchException(cn.taketoday.beans.TypeMismatchException) UnsatisfiedDependencyException(cn.taketoday.beans.factory.UnsatisfiedDependencyException) BeanDefinitionStoreException(cn.taketoday.beans.factory.BeanDefinitionStoreException) ConstructorArgumentValues(cn.taketoday.beans.factory.config.ConstructorArgumentValues)

Aggregations

UnsatisfiedDependencyException (cn.taketoday.beans.factory.UnsatisfiedDependencyException)11 TypeMismatchException (cn.taketoday.beans.TypeMismatchException)9 InjectionPoint (cn.taketoday.beans.factory.InjectionPoint)9 BeansException (cn.taketoday.beans.BeansException)7 LinkedHashSet (java.util.LinkedHashSet)7 TypeConverter (cn.taketoday.beans.TypeConverter)5 ValueHolder (cn.taketoday.beans.factory.config.ConstructorArgumentValues.ValueHolder)5 MethodParameter (cn.taketoday.core.MethodParameter)5 Constructor (java.lang.reflect.Constructor)5 BeanWrapperImpl (cn.taketoday.beans.BeanWrapperImpl)4 BeanCreationException (cn.taketoday.beans.factory.BeanCreationException)4 BeanDefinitionStoreException (cn.taketoday.beans.factory.BeanDefinitionStoreException)4 NoSuchBeanDefinitionException (cn.taketoday.beans.factory.NoSuchBeanDefinitionException)4 NoUniqueBeanDefinitionException (cn.taketoday.beans.factory.NoUniqueBeanDefinitionException)4 ConstructorArgumentValues (cn.taketoday.beans.factory.config.ConstructorArgumentValues)4 ParameterNameDiscoverer (cn.taketoday.core.ParameterNameDiscoverer)4 ArrayDeque (java.util.ArrayDeque)4 HashSet (java.util.HashSet)3 BeanInstantiationException (cn.taketoday.beans.BeanInstantiationException)2 BeanMetadataElement (cn.taketoday.beans.BeanMetadataElement)2