Examples of org.springframework.core.convert.converter.GenericConverter

Package org.springframework.core.convert.converter

Examples of org.springframework.core.convert.converter.GenericConverter

org.springframework.core.convert.converter.GenericConverter
Generic converter interface for converting between two or more types.
This is the most flexible of the Converter SPI interfaces, but also the most complex. It is flexible in that a GenericConverter may support converting between multiple source/target type pairs (see {@link #getConvertibleTypes()}. In addition, GenericConverter implementations have access to source/target {@link TypeDescriptor field context} during the type conversion process.This allows for resolving source and target field metadata such as annotations and generics information, which can be used influence the conversion logic.
This interface should generally not be used when the simpler {@link Converter} or{@link ConverterFactory} interfaces are sufficient.
Implementations may additionally implement {@link ConditionalConverter}. @author Keith Donald @author Juergen Hoeller @since 3.0 @see TypeDescriptor @see Converter @see ConverterFactory @see ConditionalConverter

   * @param sourceType the source type to convert from
   * @param targetType the target type to convert to
   * @return the generic converter that will perform the conversion, or <code>null</code> if no suitable converter was found
   */
  protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
    GenericConverter converter = findConverterForClassPair(sourceType, targetType);
    if (converter != null) {
      return converter;
    }
    else {
      return getDefaultConverter(sourceType, targetType);

View Full Code Here

      LinkedList<Class<?>> classQueue = new LinkedList<Class<?>>();
      classQueue.addFirst(sourceObjectType);
      while (!classQueue.isEmpty()) {
        Class<?> currentClass = classQueue.removeLast();
        Map<Class<?>, MatchableConverters> converters = getTargetConvertersForSource(currentClass);
        GenericConverter converter = getMatchingConverterForTarget(sourceType, targetType, converters);
        if (converter != null) {
          return converter;
        }
        Class<?>[] interfaces = currentClass.getInterfaces();
        for (Class<?> ifc : interfaces) {
          classQueue.addFirst(ifc);
        }
      }
      Map<Class<?>, MatchableConverters> objectConverters = getTargetConvertersForSource(Object.class);
      return getMatchingConverterForTarget(sourceType, targetType, objectConverters);
    }
    else {
      LinkedList<Class<?>> classQueue = new LinkedList<Class<?>>();
      classQueue.addFirst(sourceObjectType);
      while (!classQueue.isEmpty()) {
        Class<?> currentClass = classQueue.removeLast();
        Map<Class<?>, MatchableConverters> converters = getTargetConvertersForSource(currentClass);
        GenericConverter converter = getMatchingConverterForTarget(sourceType, targetType, converters);
        if (converter != null) {
          return converter;
        }
        if (currentClass.isArray()) {
          Class<?> componentType = ClassUtils.resolvePrimitiveIfNecessary(currentClass.getComponentType());

View Full Code Here

      LinkedList<Class<?>> classQueue = new LinkedList<Class<?>>();
      classQueue.addFirst(targetObjectType);
      while (!classQueue.isEmpty()) {
        Class<?> currentClass = classQueue.removeLast();
        MatchableConverters matchable = converters.get(currentClass);
        GenericConverter converter = matchConverter(matchable, sourceType, targetType);
        if (converter != null) {
          return converter;
        }
        Class<?>[] interfaces = currentClass.getInterfaces();
        for (Class<?> ifc : interfaces) {
          classQueue.addFirst(ifc);
        }
      }
      return matchConverter(converters.get(Object.class), sourceType, targetType);
    }
    else {
      LinkedList<Class<?>> classQueue = new LinkedList<Class<?>>();
      classQueue.addFirst(targetObjectType);
      while (!classQueue.isEmpty()) {
        Class<?> currentClass = classQueue.removeLast();
        MatchableConverters matchable = converters.get(currentClass);
        GenericConverter converter = matchConverter(matchable, sourceType, targetType);
        if (converter != null) {
          return converter;
        }
        if (currentClass.isArray()) {
          Class<?> componentType = ClassUtils.resolvePrimitiveIfNecessary(currentClass.getComponentType());

View Full Code Here

        public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
          return (sourceType.getAnnotation(annotationType) != null);
        }
        public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
          FieldFormatterKey key = new FieldFormatterKey(sourceType.getAnnotation(annotationType), fieldType);
          GenericConverter converter = cachedPrinters.get(key);
          if (converter == null) {
            Printer<?> printer = annotationFormatterFactory.getPrinter(key.getAnnotation(), key.getFieldType());
            converter = new PrinterConverter(fieldType, printer, FormattingConversionService.this);
            cachedPrinters.put(key, converter);
          }
          return converter.convert(source, sourceType, targetType);
        }
        public String toString() {
          return "@" + annotationType.getName() + " " + fieldType.getName() + " -> " +
              String.class.getName() + ": " + annotationFormatterFactory;
        }
      });
      addConverter(new ConditionalGenericConverter() {
        public Set<ConvertiblePair> getConvertibleTypes() {
          return Collections.singleton(new ConvertiblePair(String.class, fieldType));
        }
        public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
          return (targetType.getAnnotation(annotationType) != null);
        }
        public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
          FieldFormatterKey key = new FieldFormatterKey(targetType.getAnnotation(annotationType), fieldType);
          GenericConverter converter = cachedParsers.get(key);
          if (converter == null) {
            Parser<?> printer = annotationFormatterFactory.getParser(key.getAnnotation(), key.getFieldType());
            converter = new ParserConverter(fieldType, printer, FormattingConversionService.this);
            cachedParsers.put(key, converter);
          }
          return converter.convert(source, sourceType, targetType);
        }
        public String toString() {
          return String.class.getName() + " -> @" + annotationType.getName() + " " +
              fieldType.getName() + ": " + annotationFormatterFactory;
        }

View Full Code Here

    }    
    if (sourceType == TypeDescriptor.NULL || targetType == TypeDescriptor.NULL) {
      logger.trace("Yes, I can convert");
      return true;
    }
    GenericConverter converter = getConverter(sourceType, targetType);
    if (converter != null) {
      logger.trace("Yes, I can convert");
      return true;
    }
    else {

View Full Code Here

    }
    if (targetType == TypeDescriptor.NULL) {
      logger.debug("Converted to null");
      return null;
    }
    GenericConverter converter = getConverter(sourceType, targetType);
    if (converter == null) {
      if (source == null || targetType.getType().isInstance(source)) {
        logger.debug("No converter found - returning assignable source object as-is");
        return source;
      }

View Full Code Here

   * @return the generic converter that will perform the conversion, or <code>null</code> if no suitable converter was found
   * @see #getDefaultConverter(TypeDescriptor, TypeDescriptor)
   */
  protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
    ConverterCacheKey key = new ConverterCacheKey(sourceType, targetType);
    GenericConverter converter = this.converterCache.get(key);
    if (converter != null) {
      if (logger.isTraceEnabled()) {
        logger.trace("Matched cached converter " + converter);
      }
      return (converter != NO_MATCH ? converter : null);

View Full Code Here

        Class<?> currentClass = classQueue.removeLast();
        if (logger.isTraceEnabled()) {
          logger.trace("Searching for converters indexed by sourceType [" + currentClass.getName() + "]");
        }
        Map<Class<?>, MatchableConverters> converters = getTargetConvertersForSource(currentClass);
        GenericConverter converter = getMatchingConverterForTarget(sourceType, targetType, converters);
        if (converter != null) {
          return converter;
        }
        Class<?>[] interfaces = currentClass.getInterfaces();
        for (Class<?> ifc : interfaces) {
          classQueue.addFirst(ifc);
        }
      }
      Map<Class<?>, MatchableConverters> objectConverters = getTargetConvertersForSource(Object.class);
      return getMatchingConverterForTarget(sourceType, targetType, objectConverters);
    }
    else {
      LinkedList<Class<?>> classQueue = new LinkedList<Class<?>>();
      classQueue.addFirst(sourceObjectType);
      while (!classQueue.isEmpty()) {
        Class<?> currentClass = classQueue.removeLast();
        if (logger.isTraceEnabled()) {
          logger.trace("Searching for converters indexed by sourceType [" + currentClass.getName() + "]");
        }
        Map<Class<?>, MatchableConverters> converters = getTargetConvertersForSource(currentClass);
        GenericConverter converter = getMatchingConverterForTarget(sourceType, targetType, converters);
        if (converter != null) {
          return converter;
        }
        if (currentClass.isArray()) {
          Class<?> componentType = ClassUtils.resolvePrimitiveIfNecessary(currentClass.getComponentType());

View Full Code Here

        Class<?> currentClass = classQueue.removeLast();
        if (logger.isTraceEnabled()) {
          logger.trace("and indexed by targetType [" + currentClass.getName() + "]");
        }
        MatchableConverters matchable = converters.get(currentClass);
        GenericConverter converter = matchConverter(matchable, sourceType, targetType);
        if (converter != null) {
          return converter;
        }
        Class<?>[] interfaces = currentClass.getInterfaces();
        for (Class<?> ifc : interfaces) {
          classQueue.addFirst(ifc);
        }
      }
      if (logger.isTraceEnabled()) {
        logger.trace("and indexed by [java.lang.Object]");
      }              
      return matchConverter(converters.get(Object.class), sourceType, targetType);
    }
    else {
      LinkedList<Class<?>> classQueue = new LinkedList<Class<?>>();
      classQueue.addFirst(targetObjectType);
      while (!classQueue.isEmpty()) {
        Class<?> currentClass = classQueue.removeLast();
        if (logger.isTraceEnabled()) {
          logger.trace("and indexed by targetType [" + currentClass.getName() + "]");
        }        
        MatchableConverters matchable = converters.get(currentClass);
        GenericConverter converter = matchConverter(matchable, sourceType, targetType);
        if (converter != null) {
          return converter;
        }
        if (currentClass.isArray()) {
          Class<?> componentType = ClassUtils.resolvePrimitiveIfNecessary(currentClass.getComponentType());

View Full Code Here

      isReading = true;
      isWriting = true;
    }


    if (converter instanceof GenericConverter) {
      GenericConverter genericConverter = (GenericConverter) converter;
      for (ConvertiblePair pair : genericConverter.getConvertibleTypes()) {
        register(new ConvertibleContext(pair, isReading, isWriting));
      }
    } else if (converter instanceof Converter) {
      Class<?>[] arguments = GenericTypeResolver.resolveTypeArguments(converter.getClass(), Converter.class);
      register(new ConvertibleContext(arguments[0], arguments[1], isReading, isWriting));

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of org.springframework.core.convert.converter.GenericConverter

org.springframework.context.support.ConversionServiceFactoryBeanTests

org.springframework.core.convert.support.ArrayToCollectionConverter

org.springframework.core.convert.support.CollectionToArrayConverter

org.springframework.core.convert.support.CollectionToCollectionConverter

org.springframework.core.convert.support.CollectionToObjectConverter

org.springframework.core.convert.support.CollectionToStringConverter

org.springframework.core.convert.support.GenericConversionService

org.springframework.core.convert.support.GenericConversionService$Converters

org.springframework.core.convert.support.GenericConversionServiceTests

org.springframework.core.convert.support.ObjectToArrayConverter

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.