Package org.springframework.beans

Examples of org.springframework.beans.TypeConverter


  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 (determinedBeanName != null) {
            argument = beanFactory.getBean(determinedBeanName);
          }
          else {
            Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
            TypeConverter typeConverter = beanFactory.getTypeConverter();
            argument = beanFactory.resolveDependency(
                new DependencyDescriptor(field, this.required),
                beanName, autowiredBeanNames, typeConverter);
            registerDependentBeans(beanName, autowiredBeanNames);
            if (autowiredBeanNames.size() == 1) {
              this.beanNameForField = autowiredBeanNames.iterator().next();
            }
          }
          if (argument != null) {
            ReflectionUtils.makeAccessible(field);
            field.set(bean, argument);
          }
        }
        catch (Throwable ex) {
          throw new BeanCreationException("Could not autowire field: " + field, ex);
        }
      }
      else {
        if (this.pd != null && pvs != null && pvs.contains(this.pd.getName())) {
          // Explicit value provided as part of the bean definition.
          this.skip = true;
          return;
        }
        Method method = (Method) this.member;
        Object[] arguments = new Object[method.getParameterTypes().length];
        try {
          String[] determinedBeanNames = this.beanNamesForMethod;
          if (determinedBeanNames != null) {
            for (int i = 0; i < determinedBeanNames.length; i++) {
              arguments[i] = beanFactory.getBean(determinedBeanNames[i]);
            }
          }
          else {
            Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
            TypeConverter typeConverter = beanFactory.getTypeConverter();
            for (int i = 0; i < arguments.length; i++) {
              arguments[i] = beanFactory.resolveDependency(
                  new DependencyDescriptor(new MethodParameter(method, i), this.required),
                  beanName, autowiredBeanNames, typeConverter);
              if (arguments[i] == null) {
View Full Code Here

   * Resolve the specified cached method argument or field value.
   */
  private Object resolvedCachedArgument(String beanName, Object cachedArgument) {
    if (cachedArgument instanceof DependencyDescriptor) {
      DependencyDescriptor descriptor = (DependencyDescriptor) cachedArgument;
      TypeConverter typeConverter = beanFactory.getTypeConverter();
      return beanFactory.resolveDependency(descriptor, beanName, null, typeConverter);
    }
    else if (cachedArgument instanceof RuntimeBeanReference) {
      return beanFactory.getBean(((RuntimeBeanReference) cachedArgument).getBeanName());
    }
View Full Code Here

        }
        else {
          synchronized (this) {
            if (!this.cached) {
              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

          synchronized (this) {
            if (!this.cached) {
              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

   */
  private int resolveConstructorArguments(
      String beanName, RootBeanDefinition mbd, BeanWrapper bw,
      ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {

    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
        this.beanFactory.getCustomTypeConverter() : bw);
    BeanDefinitionValueResolver valueResolver =
        new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);

    int minNrOfArgs = cargs.getArgumentCount();
View Full Code Here

      String beanName, RootBeanDefinition mbd, ConstructorArgumentValues resolvedValues,
      BeanWrapper bw, Class[] paramTypes, String[] paramNames, Object methodOrCtor,
      boolean autowiring) throws UnsatisfiedDependencyException {

    String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method");
    TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ?
        this.beanFactory.getCustomTypeConverter() : bw);

    ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
    Set<ConstructorArgumentValues.ValueHolder> usedValueHolders =
        new HashSet<ConstructorArgumentValues.ValueHolder>(paramTypes.length);
    Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
    boolean resolveNecessary = false;

    for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
      Class<?> paramType = paramTypes[paramIndex];
      String paramName = (paramNames != null ? paramNames[paramIndex] : null);
      // Try to find matching constructor argument value, either indexed or generic.
      ConstructorArgumentValues.ValueHolder valueHolder =
          resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
      // If we couldn't find a direct match and are not supposed to autowire,
      // let's try the next generic, untyped argument value as fallback:
      // it could match after type conversion (for example, String -> int).
      if (valueHolder == null && !autowiring) {
        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);
        ConstructorArgumentValues.ValueHolder sourceHolder =
            (ConstructorArgumentValues.ValueHolder) valueHolder.getSource();
        Object originalValue = valueHolder.getValue();
        Object sourceValue = sourceHolder.getValue();
        Object convertedValue;
        if (valueHolder.isConverted()) {
          convertedValue = valueHolder.getConvertedValue();
          args.preparedArguments[paramIndex] = convertedValue;
        }
        else {
          try {
            convertedValue = converter.convertIfNecessary(originalValue, paramType,
                MethodParameter.forMethodOrConstructor(methodOrCtor, paramIndex));
            if (originalValue == sourceValue || sourceValue instanceof TypedStringValue) {
              // Either a converted value or still the original one: store converted value.
              sourceHolder.setConvertedValue(convertedValue);
              args.preparedArguments[paramIndex] = convertedValue;
View Full Code Here

      String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor) {

    Class[] paramTypes = (methodOrCtor instanceof Method ?
        ((Method) methodOrCtor).getParameterTypes() : ((Constructor) methodOrCtor).getParameterTypes());
    Object[] argsToResolve = mbd.preparedConstructorArguments;
    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,
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

    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);
    }
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.