Java 类org.springframework.beans.TypeConverter 实例源码

项目：lams 文件：DefaultListableBeanFactory.java

@Override
public Object resolveDependency(DependencyDescriptor descriptor, String beanName,
        Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

    descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    if (descriptor.getDependencyType().equals(ObjectFactory.class)) {
        return new DependencyObjectFactory(descriptor, beanName);
    }
    else if (descriptor.getDependencyType().equals(javaxInjectProviderClass)) {
        return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName);
    }
    else {
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, beanName);
        if (result == null) {
            result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
        }
        return result;
    }
}

项目：spring4-understanding 文件：DefaultListableBeanFactory.java

@Override
public Object resolveDependency(DependencyDescriptor descriptor, String beanName,
        Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

    descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    if (descriptor.getDependencyType().equals(javaUtilOptionalClass)) {
        return new OptionalDependencyFactory().createOptionalDependency(descriptor, beanName);
    }
    else if (ObjectFactory.class == descriptor.getDependencyType()) {
        return new DependencyObjectFactory(descriptor, beanName);
    }
    else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
        return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName);
    }
    else {
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, beanName);
        if (result == null) {
            result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
        }
        return result;
    }
}

项目：ignite-spring-boot 文件：IgniteBeanFactory.java

@Override
public Object resolveDependency(DependencyDescriptor descriptor, String beanName,
                                Set<String> autowiredBeanNames,
                                TypeConverter typeConverter) throws BeansException {
    if (descriptor == null
            || descriptor.getField() == null
            || !descriptor.getField().getType().equals(Ignite.class))
        return super.resolveDependency(descriptor, beanName,
                autowiredBeanNames, typeConverter);
    else {
        if (configuration == null)
            configuration = new IgniteSpringBootConfiguration(
                    createBean(DefaultIgniteProperties.class));
        return configuration.getIgnite(
                descriptor.getField().getAnnotationsByType(IgniteResource.class));
    }
}

项目：spring 文件：DefaultListableBeanFactory.java

@Override
public Object resolveDependency(DependencyDescriptor descriptor, String beanName,
        Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

    descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    if (descriptor.getDependencyType().equals(javaUtilOptionalClass)) {
        return new OptionalDependencyFactory().createOptionalDependency(descriptor, beanName);
    }
    else if (ObjectFactory.class == descriptor.getDependencyType() ||
            ObjectProvider.class == descriptor.getDependencyType()) {
        return new DependencyObjectProvider(descriptor, beanName);
    }
    else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
        return new Jsr330ProviderFactory().createDependencyProvider(descriptor, beanName);
    }
    else {
        Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, beanName);
        if (result == null) {
            result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter); // 解析依赖
        }
        return result;
    }
}

项目：cuba 文件：CubaDefaultListableBeanFactory.java

@Override
public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames,
                                TypeConverter typeConverter) throws BeansException {
    Field field = descriptor.getField();

    if (field != null && Logger.class == descriptor.getDependencyType()) {
        return LoggerFactory.getLogger(getDeclaringClass(descriptor));
    }

    if (field != null && Config.class.isAssignableFrom(field.getType())) {
        return getConfig(field.getType());
    }
    MethodParameter methodParam = descriptor.getMethodParameter();
    if (methodParam != null && Config.class.isAssignableFrom(methodParam.getParameterType())) {
        return getConfig(methodParam.getParameterType());
    }
    return super.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
}

项目：spring-autoproperties 文件：AutoPropertiesFactoryBean.java

private Object resolveValue(Method method) {
    Value val = AnnotationUtils.findAnnotation(method, Value.class);
    if (val != null) {
        if (LOG.isDebugEnabled()) {
            LOG.debug(String.format("Resolving @Value annotation on %s with key %s",
                    method.getName(), val.value()));
        }
        ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) getBeanFactory();
        String strValue = beanFactory.resolveEmbeddedValue(val.value());
        BeanExpressionResolver resolver = beanFactory.getBeanExpressionResolver();

        Object unconvertedResult = resolver.evaluate(strValue, new BeanExpressionContext(beanFactory, null));
        TypeConverter converter = beanFactory.getTypeConverter();
        return converter.convertIfNecessary(unconvertedResult, method.getReturnType());
    }
    String message = "Method %s on interface %s must be annotated with @Value for auto-properties to work!";
    throw new AutoPropertiesException(String.format(message, method.getName(), method.getDeclaringClass().getName()));
}

项目：gemini.blueprint 文件：SpringBlueprintConverter.java

private TypeConverter getConverter() {
    if (typeConverter == null) {
        SimpleTypeConverter simpleConverter = new SimpleTypeConverter();
        beanFactory.copyRegisteredEditorsTo(simpleConverter);
        simpleConverter.setConversionService(beanFactory.getConversionService());
        typeConverter = simpleConverter;
    }
    return typeConverter;
}

项目：lams 文件：DataBinder.java

/**
 * Return the underlying TypeConverter of this binder's BindingResult.
 */
protected TypeConverter getTypeConverter() {
    if (getTarget() != null) {
        return getInternalBindingResult().getPropertyAccessor();
    }
    else {
        return getSimpleTypeConverter();
    }
}

项目：lams 文件：JndiObjectFactoryBean.java

/**
 * Look up the JNDI object and store it.
 */
@Override
public void afterPropertiesSet() throws IllegalArgumentException, NamingException {
    super.afterPropertiesSet();

    if (this.proxyInterfaces != null || !this.lookupOnStartup || !this.cache || this.exposeAccessContext) {
        // We need to create a proxy for this...
        if (this.defaultObject != null) {
            throw new IllegalArgumentException(
                    "'defaultObject' is not supported in combination with 'proxyInterface'");
        }
        // We need a proxy and a JndiObjectTargetSource.
        this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this);
    }
    else {
        if (this.defaultObject != null && getExpectedType() != null &&
                !getExpectedType().isInstance(this.defaultObject)) {
            TypeConverter converter = (this.beanFactory != null ?
                    this.beanFactory.getTypeConverter() : new SimpleTypeConverter());
            try {
                this.defaultObject = converter.convertIfNecessary(this.defaultObject, getExpectedType());
            }
            catch (TypeMismatchException ex) {
                throw new IllegalArgumentException("Default object [" + this.defaultObject + "] of type [" +
                        this.defaultObject.getClass().getName() + "] is not of expected type [" +
                        getExpectedType().getName() + "] and cannot be converted either", ex);
            }
        }
        // Locate specified JNDI object.
        this.jndiObject = lookupWithFallback();
    }
}

项目：lams 文件：ConstructorResolver.java

/**
 * Resolve the prepared arguments stored in the given bean definition.
 */
private Object[] resolvePreparedArguments(
        String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) {

    Class<?>[] paramTypes = (methodOrCtor instanceof Method ?
            ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes());
    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
            this.beanFactory.getCustomTypeConverter() : bw);
    BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    Object[] resolvedArgs = new Object[argsToResolve.length];
    for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
        Object argValue = argsToResolve[argIndex];
        MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex);
        GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass());
        if (argValue instanceof AutowiredArgumentMarker) {
            argValue = resolveAutowiredArgument(methodParam, beanName, null, converter);
        }
        else if (argValue instanceof BeanMetadataElement) {
            argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue);
        }
        else if (argValue instanceof String) {
            argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd);
        }
        Class<?> paramType = paramTypes[argIndex];
        try {
            resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam);
        }
        catch (TypeMismatchException ex) {
            String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method");
            throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, argIndex, paramType,
                    "Could not convert " + methodType + " argument value of type [" +
                    ObjectUtils.nullSafeClassName(argValue) +
                    "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
        }
    }
    return resolvedArgs;
}

项目：lams 文件：ConstructorResolver.java

/**
 * Template method for resolving the specified argument which is supposed to be autowired.
 */
protected Object resolveAutowiredArgument(
        MethodParameter param, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) {

    return this.beanFactory.resolveDependency(
            new DependencyDescriptor(param, true), beanName, autowiredBeanNames, typeConverter);
}

项目：lams 文件：AbstractBeanFactory.java

@Override
public TypeConverter getTypeConverter() {
    TypeConverter customConverter = getCustomTypeConverter();
    if (customConverter != null) {
        return customConverter;
    }
    else {
        // Build default TypeConverter, registering custom editors.
        SimpleTypeConverter typeConverter = new SimpleTypeConverter();
        typeConverter.setConversionService(getConversionService());
        registerCustomEditors(typeConverter);
        return typeConverter;
    }
}

项目：lams 文件：AbstractAutowireCapableBeanFactory.java

/**
 * Abstract method defining "autowire by type" (bean properties by type) behavior.
 * <p>This is like PicoContainer default, in which there must be exactly one bean
 * of the property type in the bean factory. This makes bean factories simple to
 * configure for small namespaces, but doesn't work as well as standard Spring
 * behavior for bigger applications.
 * @param beanName the name of the bean to autowire by type
 * @param mbd the merged bean definition to update through autowiring
 * @param bw BeanWrapper from which we can obtain information about the bean
 * @param pvs the PropertyValues to register wired objects with
 */
protected void autowireByType(
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        try {
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            // Don't try autowiring by type for type Object: never makes sense,
            // even if it technically is a unsatisfied, non-simple property.
            if (!Object.class.equals(pd.getPropertyType())) {
                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                // Do not allow eager init for type matching in case of a prioritized post-processor.
                boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                for (String autowiredBeanName : autowiredBeanNames) {
                    registerDependentBean(autowiredBeanName, beanName);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
                                propertyName + "' to bean named '" + autowiredBeanName + "'");
                    }
                }
                autowiredBeanNames.clear();
            }
        }
        catch (BeansException ex) {
            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
        }
    }
}

项目：lams 文件：AbstractAutowireCapableBeanFactory.java

/**
 * Convert the given value for the specified target property.
 */
private Object convertForProperty(Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
    if (converter instanceof BeanWrapperImpl) {
        return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
    }
    else {
        PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
        MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
        return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
    }
}

项目：lams 文件：BeanDefinitionValueResolver.java

/**
 * Create a BeanDefinitionValueResolver for the given BeanFactory and BeanDefinition.
 * @param beanFactory the BeanFactory to resolve against
 * @param beanName the name of the bean that we work on
 * @param beanDefinition the BeanDefinition of the bean that we work on
 * @param typeConverter the TypeConverter to use for resolving TypedStringValues
 */
public BeanDefinitionValueResolver(
        AbstractBeanFactory beanFactory, String beanName, BeanDefinition beanDefinition, TypeConverter typeConverter) {

    this.beanFactory = beanFactory;
    this.beanName = beanName;
    this.beanDefinition = beanDefinition;
    this.typeConverter = typeConverter;
}

项目：lams 文件：ListFactoryBean.java

@Override
@SuppressWarnings("unchecked")
protected List<Object> createInstance() {
    if (this.sourceList == null) {
        throw new IllegalArgumentException("'sourceList' is required");
    }
    List<Object> result = null;
    if (this.targetListClass != null) {
        result = BeanUtils.instantiateClass(this.targetListClass);
    }
    else {
        result = new ArrayList<Object>(this.sourceList.size());
    }
    Class<?> valueType = null;
    if (this.targetListClass != null) {
        valueType = GenericCollectionTypeResolver.getCollectionType(this.targetListClass);
    }
    if (valueType != null) {
        TypeConverter converter = getBeanTypeConverter();
        for (Object elem : this.sourceList) {
            result.add(converter.convertIfNecessary(elem, valueType));
        }
    }
    else {
        result.addAll(this.sourceList);
    }
    return result;
}

项目：lams 文件：AbstractFactoryBean.java

/**
 * Obtain a bean type converter from the BeanFactory that this bean
 * runs in. This is typically a fresh instance for each call,
 * since TypeConverters are usually <i>not</i> thread-safe.
 * <p>Falls back to a SimpleTypeConverter when not running in a BeanFactory.
 * @see ConfigurableBeanFactory#getTypeConverter()
 * @see org.springframework.beans.SimpleTypeConverter
 */
protected TypeConverter getBeanTypeConverter() {
    BeanFactory beanFactory = getBeanFactory();
    if (beanFactory instanceof ConfigurableBeanFactory) {
        return ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
    }
    else {
        return new SimpleTypeConverter();
    }
}

项目：lams 文件：SetFactoryBean.java

@Override
@SuppressWarnings("unchecked")
protected Set<Object> createInstance() {
    if (this.sourceSet == null) {
        throw new IllegalArgumentException("'sourceSet' is required");
    }
    Set<Object> result = null;
    if (this.targetSetClass != null) {
        result = BeanUtils.instantiateClass(this.targetSetClass);
    }
    else {
        result = new LinkedHashSet<Object>(this.sourceSet.size());
    }
    Class<?> valueType = null;
    if (this.targetSetClass != null) {
        valueType = GenericCollectionTypeResolver.getCollectionType(this.targetSetClass);
    }
    if (valueType != null) {
        TypeConverter converter = getBeanTypeConverter();
        for (Object elem : this.sourceSet) {
            result.add(converter.convertIfNecessary(elem, valueType));
        }
    }
    else {
        result.addAll(this.sourceSet);
    }
    return result;
}

项目：lams 文件：MapFactoryBean.java

@Override
@SuppressWarnings("unchecked")
protected Map<Object, Object> createInstance() {
    if (this.sourceMap == null) {
        throw new IllegalArgumentException("'sourceMap' is required");
    }
    Map<Object, Object> result = null;
    if (this.targetMapClass != null) {
        result = BeanUtils.instantiateClass(this.targetMapClass);
    }
    else {
        result = new LinkedHashMap<Object, Object>(this.sourceMap.size());
    }
    Class<?> keyType = null;
    Class<?> valueType = null;
    if (this.targetMapClass != null) {
        keyType = GenericCollectionTypeResolver.getMapKeyType(this.targetMapClass);
        valueType = GenericCollectionTypeResolver.getMapValueType(this.targetMapClass);
    }
    if (keyType != null || valueType != null) {
        TypeConverter converter = getBeanTypeConverter();
        for (Map.Entry<?, ?> entry : this.sourceMap.entrySet()) {
            Object convertedKey = converter.convertIfNecessary(entry.getKey(), keyType);
            Object convertedValue = converter.convertIfNecessary(entry.getValue(), valueType);
            result.put(convertedKey, convertedValue);
        }
    }
    else {
        result.putAll(this.sourceMap);
    }
    return result;
}

项目：lams 文件：MethodInvokingBean.java

/**
 * Obtain the TypeConverter from the BeanFactory that this bean runs in,
 * if possible.
 * @see ConfigurableBeanFactory#getTypeConverter()
 */
@Override
protected TypeConverter getDefaultTypeConverter() {
    if (this.beanFactory != null) {
        return this.beanFactory.getTypeConverter();
    }
    else {
        return super.getDefaultTypeConverter();
    }
}

项目：taboola-cronyx 文件：CronyxAutoConfiguration.java

@Bean
public TypeConverter typeConverter() {
    SimpleTypeConverter tc = new SimpleTypeConverter();
    tc.registerCustomEditor(LocalDateTime.class, new LocalDateTimePropertyEditor("yyyyMMdd_HHmmss"));
    tc.registerCustomEditor(LocalDate.class, new LocalDatePropertyEditor("yyyyMMdd"));
    return tc;
}

项目：taboola-cronyx 文件：DelegatingQuartzJob.java

public DelegatingQuartzJob(ListableBeanFactory listableBeanFactory,
                           TypeConverter typeConverter,
                           ArgumentResolver argumentResolver) {
    this.typeConverter = typeConverter;
    this.listableBeanFactory = listableBeanFactory;
    this.argumentResolver = argumentResolver;
}

项目：spring4-understanding 文件：DataBinder.java

/**
 * Return the underlying TypeConverter of this binder's BindingResult.
 */
protected TypeConverter getTypeConverter() {
    if (getTarget() != null) {
        return getInternalBindingResult().getPropertyAccessor();
    }
    else {
        return getSimpleTypeConverter();
    }
}

项目：spring4-understanding 文件：JndiObjectFactoryBean.java

/**
 * Look up the JNDI object and store it.
 */
@Override
public void afterPropertiesSet() throws IllegalArgumentException, NamingException {
    super.afterPropertiesSet();

    if (this.proxyInterfaces != null || !this.lookupOnStartup || !this.cache || this.exposeAccessContext) {
        // We need to create a proxy for this...
        if (this.defaultObject != null) {
            throw new IllegalArgumentException(
                    "'defaultObject' is not supported in combination with 'proxyInterface'");
        }
        // We need a proxy and a JndiObjectTargetSource.
        this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this);
    }
    else {
        if (this.defaultObject != null && getExpectedType() != null &&
                !getExpectedType().isInstance(this.defaultObject)) {
            TypeConverter converter = (this.beanFactory != null ?
                    this.beanFactory.getTypeConverter() : new SimpleTypeConverter());
            try {
                this.defaultObject = converter.convertIfNecessary(this.defaultObject, getExpectedType());
            }
            catch (TypeMismatchException ex) {
                throw new IllegalArgumentException("Default object [" + this.defaultObject + "] of type [" +
                        this.defaultObject.getClass().getName() + "] is not of expected type [" +
                        getExpectedType().getName() + "] and cannot be converted either", ex);
            }
        }
        // Locate specified JNDI object.
        this.jndiObject = lookupWithFallback();
    }
}

项目：spring4-understanding 文件：ConstructorResolver.java

/**
 * Resolve the prepared arguments stored in the given bean definition.
 */
private Object[] resolvePreparedArguments(
        String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) {

    Class<?>[] paramTypes = (methodOrCtor instanceof Method ?
            ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes());
    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
            this.beanFactory.getCustomTypeConverter() : bw);
    BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    Object[] resolvedArgs = new Object[argsToResolve.length];
    for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
        Object argValue = argsToResolve[argIndex];
        MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex);
        GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass());
        if (argValue instanceof AutowiredArgumentMarker) {
            argValue = resolveAutowiredArgument(methodParam, beanName, null, converter);
        }
        else if (argValue instanceof BeanMetadataElement) {
            argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue);
        }
        else if (argValue instanceof String) {
            argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd);
        }
        Class<?> paramType = paramTypes[argIndex];
        try {
            resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam);
        }
        catch (TypeMismatchException ex) {
            String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method");
            throw new UnsatisfiedDependencyException(
                    mbd.getResourceDescription(), beanName, argIndex, paramType,
                    "Could not convert " + methodType + " argument value of type [" +
                    ObjectUtils.nullSafeClassName(argValue) +
                    "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
        }
    }
    return resolvedArgs;
}

项目：spring4-understanding 文件：ConstructorResolver.java

/**
 * Template method for resolving the specified argument which is supposed to be autowired.
 */
protected Object resolveAutowiredArgument(
        MethodParameter param, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) {

    return this.beanFactory.resolveDependency(
            new DependencyDescriptor(param, true), beanName, autowiredBeanNames, typeConverter);
}

项目：spring4-understanding 文件：AbstractBeanFactory.java

@Override
public TypeConverter getTypeConverter() {
    TypeConverter customConverter = getCustomTypeConverter();
    if (customConverter != null) {
        return customConverter;
    }
    else {
        // Build default TypeConverter, registering custom editors.
        SimpleTypeConverter typeConverter = new SimpleTypeConverter();
        typeConverter.setConversionService(getConversionService());
        registerCustomEditors(typeConverter);
        return typeConverter;
    }
}

项目：spring4-understanding 文件：AbstractAutowireCapableBeanFactory.java

/**
 * Abstract method defining "autowire by type" (bean properties by type) behavior.
 * <p>This is like PicoContainer default, in which there must be exactly one bean
 * of the property type in the bean factory. This makes bean factories simple to
 * configure for small namespaces, but doesn't work as well as standard Spring
 * behavior for bigger applications.
 * @param beanName the name of the bean to autowire by type
 * @param mbd the merged bean definition to update through autowiring
 * @param bw BeanWrapper from which we can obtain information about the bean
 * @param pvs the PropertyValues to register wired objects with
 */
protected void autowireByType(
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        try {
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            // Don't try autowiring by type for type Object: never makes sense,
            // even if it technically is a unsatisfied, non-simple property.
            if (Object.class != pd.getPropertyType()) {
                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                // Do not allow eager init for type matching in case of a prioritized post-processor.
                boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                for (String autowiredBeanName : autowiredBeanNames) {
                    registerDependentBean(autowiredBeanName, beanName);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
                                propertyName + "' to bean named '" + autowiredBeanName + "'");
                    }
                }
                autowiredBeanNames.clear();
            }
        }
        catch (BeansException ex) {
            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
        }
    }
}

项目：spring4-understanding 文件：AbstractAutowireCapableBeanFactory.java

/**
 * Convert the given value for the specified target property.
 */
private Object convertForProperty(Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
    if (converter instanceof BeanWrapperImpl) {
        return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
    }
    else {
        PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
        MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
        return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
    }
}

项目：spring4-understanding 文件：BeanDefinitionValueResolver.java

/**
 * Create a BeanDefinitionValueResolver for the given BeanFactory and BeanDefinition.
 * @param beanFactory the BeanFactory to resolve against
 * @param beanName the name of the bean that we work on
 * @param beanDefinition the BeanDefinition of the bean that we work on
 * @param typeConverter the TypeConverter to use for resolving TypedStringValues
 */
public BeanDefinitionValueResolver(
        AbstractBeanFactory beanFactory, String beanName, BeanDefinition beanDefinition, TypeConverter typeConverter) {

    this.beanFactory = beanFactory;
    this.beanName = beanName;
    this.beanDefinition = beanDefinition;
    this.typeConverter = typeConverter;
}

项目：spring4-understanding 文件：ListFactoryBean.java

@Override
@SuppressWarnings("unchecked")
protected List<Object> createInstance() {
    if (this.sourceList == null) {
        throw new IllegalArgumentException("'sourceList' is required");
    }
    List<Object> result = null;
    if (this.targetListClass != null) {
        result = BeanUtils.instantiateClass(this.targetListClass);
    }
    else {
        result = new ArrayList<Object>(this.sourceList.size());
    }
    Class<?> valueType = null;
    if (this.targetListClass != null) {
        valueType = GenericCollectionTypeResolver.getCollectionType(this.targetListClass);
    }
    if (valueType != null) {
        TypeConverter converter = getBeanTypeConverter();
        for (Object elem : this.sourceList) {
            result.add(converter.convertIfNecessary(elem, valueType));
        }
    }
    else {
        result.addAll(this.sourceList);
    }
    return result;
}

项目：spring4-understanding 文件：AbstractFactoryBean.java

/**
 * Obtain a bean type converter from the BeanFactory that this bean
 * runs in. This is typically a fresh instance for each call,
 * since TypeConverters are usually <i>not</i> thread-safe.
 * <p>Falls back to a SimpleTypeConverter when not running in a BeanFactory.
 * @see ConfigurableBeanFactory#getTypeConverter()
 * @see org.springframework.beans.SimpleTypeConverter
 */
protected TypeConverter getBeanTypeConverter() {
    BeanFactory beanFactory = getBeanFactory();
    if (beanFactory instanceof ConfigurableBeanFactory) {
        return ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
    }
    else {
        return new SimpleTypeConverter();
    }
}

项目：spring4-understanding 文件：SetFactoryBean.java

@Override
@SuppressWarnings("unchecked")
protected Set<Object> createInstance() {
    if (this.sourceSet == null) {
        throw new IllegalArgumentException("'sourceSet' is required");
    }
    Set<Object> result = null;
    if (this.targetSetClass != null) {
        result = BeanUtils.instantiateClass(this.targetSetClass);
    }
    else {
        result = new LinkedHashSet<Object>(this.sourceSet.size());
    }
    Class<?> valueType = null;
    if (this.targetSetClass != null) {
        valueType = GenericCollectionTypeResolver.getCollectionType(this.targetSetClass);
    }
    if (valueType != null) {
        TypeConverter converter = getBeanTypeConverter();
        for (Object elem : this.sourceSet) {
            result.add(converter.convertIfNecessary(elem, valueType));
        }
    }
    else {
        result.addAll(this.sourceSet);
    }
    return result;
}

项目：spring4-understanding 文件：MapFactoryBean.java

@Override
@SuppressWarnings("unchecked")
protected Map<Object, Object> createInstance() {
    if (this.sourceMap == null) {
        throw new IllegalArgumentException("'sourceMap' is required");
    }
    Map<Object, Object> result = null;
    if (this.targetMapClass != null) {
        result = BeanUtils.instantiateClass(this.targetMapClass);
    }
    else {
        result = new LinkedHashMap<Object, Object>(this.sourceMap.size());
    }
    Class<?> keyType = null;
    Class<?> valueType = null;
    if (this.targetMapClass != null) {
        keyType = GenericCollectionTypeResolver.getMapKeyType(this.targetMapClass);
        valueType = GenericCollectionTypeResolver.getMapValueType(this.targetMapClass);
    }
    if (keyType != null || valueType != null) {
        TypeConverter converter = getBeanTypeConverter();
        for (Map.Entry<?, ?> entry : this.sourceMap.entrySet()) {
            Object convertedKey = converter.convertIfNecessary(entry.getKey(), keyType);
            Object convertedValue = converter.convertIfNecessary(entry.getValue(), valueType);
            result.put(convertedKey, convertedValue);
        }
    }
    else {
        result.putAll(this.sourceMap);
    }
    return result;
}

项目：spring4-understanding 文件：MethodInvokingBean.java

/**
 * Obtain the TypeConverter from the BeanFactory that this bean runs in,
 * if possible.
 * @see ConfigurableBeanFactory#getTypeConverter()
 */
@Override
protected TypeConverter getDefaultTypeConverter() {
    if (this.beanFactory != null) {
        return this.beanFactory.getTypeConverter();
    }
    else {
        return super.getDefaultTypeConverter();
    }
}

项目：my-spring-cache-redis 文件：DataBinder.java

/**
 * Return the underlying TypeConverter of this binder's BindingResult.
 */
protected TypeConverter getTypeConverter() {
    if (getTarget() != null) {
        return getInternalBindingResult().getPropertyAccessor();
    }
    else {
        return getSimpleTypeConverter();
    }
}

项目：my-spring-cache-redis 文件：JndiObjectFactoryBean.java

/**
 * Look up the JNDI object and store it.
 */
@Override
public void afterPropertiesSet() throws IllegalArgumentException, NamingException {
    super.afterPropertiesSet();

    if (this.proxyInterfaces != null || !this.lookupOnStartup || !this.cache || this.exposeAccessContext) {
        // We need to create a proxy for this...
        if (this.defaultObject != null) {
            throw new IllegalArgumentException(
                    "'defaultObject' is not supported in combination with 'proxyInterface'");
        }
        // We need a proxy and a JndiObjectTargetSource.
        this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this);
    }
    else {
        if (this.defaultObject != null && getExpectedType() != null &&
                !getExpectedType().isInstance(this.defaultObject)) {
            TypeConverter converter = (this.beanFactory != null ?
                    this.beanFactory.getTypeConverter() : new SimpleTypeConverter());
            try {
                this.defaultObject = converter.convertIfNecessary(this.defaultObject, getExpectedType());
            }
            catch (TypeMismatchException ex) {
                throw new IllegalArgumentException("Default object [" + this.defaultObject + "] of type [" +
                        this.defaultObject.getClass().getName() + "] is not of expected type [" +
                        getExpectedType().getName() + "] and cannot be converted either", ex);
            }
        }
        // Locate specified JNDI object.
        this.jndiObject = lookupWithFallback();
    }
}

项目：puzzle 文件：PluginListableBeanFactory.java

@Override
public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
        Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

    Map<String, Object> tmp = new HashMap<String,Object>();
    tmp.put("descriptor", descriptor);
    tmp.put("beanName", beanName);
    DependencyDescriptorHolder.setDependencyDescriptor(tmp);
    try{
        return super.doResolveDependency(descriptor,beanName,autowiredBeanNames,typeConverter);
    }finally{
        DependencyDescriptorHolder.setDependencyDescriptor(null);
    }
}

项目：spring 文件：DataBinder.java

/**
 * Return the underlying TypeConverter of this binder's BindingResult.
 */
protected TypeConverter getTypeConverter() {
    if (getTarget() != null) {
        return getInternalBindingResult().getPropertyAccessor();
    }
    else {
        return getSimpleTypeConverter();
    }
}

项目：spring 文件：JndiObjectFactoryBean.java

/**
 * Look up the JNDI object and store it.
 */
@Override
public void afterPropertiesSet() throws IllegalArgumentException, NamingException {
    super.afterPropertiesSet();

    if (this.proxyInterfaces != null || !this.lookupOnStartup || !this.cache || this.exposeAccessContext) {
        // We need to create a proxy for this...
        if (this.defaultObject != null) {
            throw new IllegalArgumentException(
                    "'defaultObject' is not supported in combination with 'proxyInterface'");
        }
        // We need a proxy and a JndiObjectTargetSource.
        this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this);
    }
    else {
        if (this.defaultObject != null && getExpectedType() != null &&
                !getExpectedType().isInstance(this.defaultObject)) {
            TypeConverter converter = (this.beanFactory != null ?
                    this.beanFactory.getTypeConverter() : new SimpleTypeConverter());
            try {
                this.defaultObject = converter.convertIfNecessary(this.defaultObject, getExpectedType());
            }
            catch (TypeMismatchException ex) {
                throw new IllegalArgumentException("Default object [" + this.defaultObject + "] of type [" +
                        this.defaultObject.getClass().getName() + "] is not of expected type [" +
                        getExpectedType().getName() + "] and cannot be converted either", ex);
            }
        }
        // Locate specified JNDI object.
        this.jndiObject = lookupWithFallback();
    }
}