Package org.springframework.beans

Examples of org.springframework.beans.TypeConverter


    if (this.targetMapClass != null && JdkVersion.isAtLeastJava15()) {
      keyType = GenericCollectionTypeResolver.getMapKeyType(this.targetMapClass);
      valueType = GenericCollectionTypeResolver.getMapValueType(this.targetMapClass);
    }
    if (keyType != null || valueType != null) {
      TypeConverter converter = getBeanTypeConverter();
      for (Iterator it = this.sourceMap.entrySet().iterator(); it.hasNext();) {
        Map.Entry entry = (Map.Entry) it.next();
        Object convertedKey = converter.convertIfNecessary(entry.getKey(), keyType);
        Object convertedValue = converter.convertIfNecessary(entry.getValue(), valueType);
        result.put(convertedKey, convertedValue);
      }
    }
    else {
      result.putAll(this.sourceMap);
View Full Code Here


        return null;
      }
      if (autowiredBeanNames != null) {
        autowiredBeanNames.addAll(matchingBeans.keySet());
      }
      TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
      return converter.convertIfNecessary(matchingBeans.values(), type);
    }
    else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
      Class elementType = descriptor.getCollectionType();
      if (elementType == null) {
        if (descriptor.isRequired()) {
          throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");
        }
        return null;
      }
      Map matchingBeans = findAutowireCandidates(beanName, elementType, descriptor);
      if (matchingBeans.isEmpty()) {
        if (descriptor.isRequired()) {
          raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);
        }
        return null;
      }
      if (autowiredBeanNames != null) {
        autowiredBeanNames.addAll(matchingBeans.keySet());
      }
      TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
      return converter.convertIfNecessary(matchingBeans.values(), type);
    }
    else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
      Class keyType = descriptor.getMapKeyType();
      if (keyType == null || !String.class.isAssignableFrom(keyType)) {
        if (descriptor.isRequired()) {
View Full Code Here

      try {
        Object value = null;
        if (this.cached) {
          if (this.cachedFieldValue instanceof DependencyDescriptor) {
            DependencyDescriptor descriptor = (DependencyDescriptor) this.cachedFieldValue;
            TypeConverter typeConverter = beanFactory.getTypeConverter();
            value = beanFactory.resolveDependency(descriptor, beanName, null, typeConverter);
          }
          else if (this.cachedFieldValue instanceof RuntimeBeanReference) {
            value = beanFactory.getBean(((RuntimeBeanReference) this.cachedFieldValue).getBeanName());
          }
          else {
            value = this.cachedFieldValue;
          }
        }
        else {
          Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
          TypeConverter typeConverter = beanFactory.getTypeConverter();
          DependencyDescriptor descriptor = new DependencyDescriptor(field, this.required);
          this.cachedFieldValue = descriptor;
          value = beanFactory.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
          if (value != null) {
            registerDependentBeans(beanName, autowiredBeanNames);
View Full Code Here

            arguments = new Object[this.cachedMethodArguments.length];
            for (int i = 0; i < arguments.length; i++) {
              Object cachedArg = this.cachedMethodArguments[i];
              if (cachedArg instanceof DependencyDescriptor) {
                DependencyDescriptor descriptor = (DependencyDescriptor) cachedArg;
                TypeConverter typeConverter = beanFactory.getTypeConverter();
                arguments[i] = beanFactory.resolveDependency(descriptor, beanName, null, typeConverter);
              }
              else if (cachedArg instanceof RuntimeBeanReference) {
                arguments[i] = beanFactory.getBean(((RuntimeBeanReference) cachedArg).getBeanName());
              }
              else {
                arguments[i] = cachedArg;
              }
            }
          }
        }
        else {
          Class[] paramTypes = method.getParameterTypes();
          arguments = new Object[paramTypes.length];
          Set<String> autowiredBeanNames = new LinkedHashSet<String>(arguments.length);
          TypeConverter typeConverter = beanFactory.getTypeConverter();
          this.cachedMethodArguments = new Object[arguments.length];
          for (int i = 0; i < arguments.length; i++) {
            MethodParameter methodParam = new MethodParameter(method, i);
            GenericTypeResolver.resolveParameterType(methodParam, bean.getClass());
            DependencyDescriptor descriptor = new DependencyDescriptor(methodParam, this.required);
View Full Code Here

  protected TypeConverter getCustomTypeConverter() {
    return this.typeConverter;
  }

  public TypeConverter getTypeConverter() {
    TypeConverter customConverter = getCustomTypeConverter();
    if (customConverter != null) {
      return customConverter;
    }
    else {
      // Build default TypeConverter, registering custom editors.
View Full Code Here

            if (value instanceof String) {
                String strVal = resolveEmbeddedValue((String) value);
                BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
                value = evaluateBeanDefinitionString(strVal, bd);
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            return (descriptor.getField() != null ?
                    converter.convertIfNecessary(value, type, descriptor.getField()) :
                    converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
        }


        //http://my.oschina.net/hantsy/blog/186939#OSC_h1_1
        //support like CDI @Produces
        Map<String, Object> noneCollectionMatchingBeans = findAutowireCandidates(beanName, type, descriptor);

        if (noneCollectionMatchingBeans.size() == 1) {
            // We have exactly one match.
            Map.Entry<String, Object> entry = noneCollectionMatchingBeans.entrySet().iterator().next();
            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(entry.getKey());
            }
            return entry.getValue();
        } else if (noneCollectionMatchingBeans.size() > 1) {
            String primaryBeanName = determinePrimaryCandidate(noneCollectionMatchingBeans, descriptor);
            if (primaryBeanName == null) {
                throw new NoUniqueBeanDefinitionException(type, noneCollectionMatchingBeans.keySet());
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(primaryBeanName);
            }
            return noneCollectionMatchingBeans.get(primaryBeanName);
        }


        if (type.isArray()) {
            Class<?> componentType = type.getComponentType();
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (this.dependencyComparator != null && result instanceof Object[]) {
                Arrays.sort((Object[]) result, this.dependencyComparator);
            }
            return result;
        } else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
            Class<?> elementType = descriptor.getCollectionType();
            if (elementType == null) {
                if (descriptor.isRequired()) {
                    throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");
                }
                return null;
            }
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (this.dependencyComparator != null && result instanceof List) {
                Collections.sort((List<?>) result, this.dependencyComparator);
            }
            return result;
        } else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
View Full Code Here

   * @param propertyEditor editor to register
   * @see #setTypeConverter
   * @see org.springframework.beans.PropertyEditorRegistry#registerCustomEditor
   */
  public void registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor) {
    TypeConverter converter = getTypeConverter();
    if (!(converter instanceof PropertyEditorRegistry)) {
      throw new IllegalStateException(
          "TypeConverter does not implement PropertyEditorRegistry interface: " + converter);
    }
    ((PropertyEditorRegistry) converter).registerCustomEditor(requiredType, propertyEditor);
View Full Code Here

   * argument value is assignable to the corresponding parameter type.
   * @param arguments the argument values to match against method parameters
   * @return a matching method, or {@code null} if none
   */
  protected Method doFindMatchingMethod(Object[] arguments) {
    TypeConverter converter = getTypeConverter();
    if (converter != null) {
      String targetMethod = getTargetMethod();
      Method matchingMethod = null;
      int argCount = arguments.length;
      Method[] candidates = ReflectionUtils.getAllDeclaredMethods(getTargetClass());
      int minTypeDiffWeight = Integer.MAX_VALUE;
      Object[] argumentsToUse = null;
      for (Method candidate : candidates) {
        if (candidate.getName().equals(targetMethod)) {
          // Check if the inspected method has the correct number of parameters.
          Class<?>[] paramTypes = candidate.getParameterTypes();
          if (paramTypes.length == argCount) {
            Object[] convertedArguments = new Object[argCount];
            boolean match = true;
            for (int j = 0; j < argCount && match; j++) {
              // Verify that the supplied argument is assignable to the method parameter.
              try {
                convertedArguments[j] = converter.convertIfNecessary(arguments[j], paramTypes[j]);
              }
              catch (TypeMismatchException ex) {
                // Ignore -> simply doesn't match.
                match = false;
              }
View Full Code Here

    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);
    }
View Full Code Here

        }
        else {
          DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
          desc.setContainingClass(bean.getClass());
          Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
          TypeConverter typeConverter = beanFactory.getTypeConverter();
          value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
          synchronized (this) {
            if (!this.cached) {
              if (value != null || this.required) {
                this.cachedFieldValue = desc;
View Full Code Here

TOP

Related Classes of org.springframework.beans.TypeConverter

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.