Java GenericConverter.ConvertiblePair方法代码示例

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
/**
 * Registers a conversion for the given converter. Inspects either generics or the convertible pairs returned
 * by a {@link GenericConverter}.
 *
 * @param converter the converter to register.
 */
private void registerConversion(final Object converter) {
  Class<?> type = converter.getClass();
  boolean isWriting = type.isAnnotationPresent(WritingConverter.class);
  boolean isReading = type.isAnnotationPresent(ReadingConverter.class);

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

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
/**
 * Registers the given {@link ConverterRegistration} as reading or writing pair depending on the type sides being basic
 * Crate types.
 *
 * @param registration the registration.
 */
private void register(final ConverterRegistration registration) {
  GenericConverter.ConvertiblePair pair = registration.getConvertiblePair();

  if (registration.isReading()) {
    readingPairs.add(pair);
    if (LOG.isWarnEnabled() && !registration.isSimpleSourceType()) {
      LOG.warn(String.format(READ_CONVERTER_NOT_SIMPLE, pair.getSourceType(), pair.getTargetType()));
    }
  }

  if (registration.isWriting()) {
    writingPairs.add(pair);
    customSimpleTypes.add(pair.getSourceType());
    if (LOG.isWarnEnabled() && !registration.isSimpleTargetType()) {
      LOG.warn(String.format(WRITE_CONVERTER_NOT_SIMPLE, pair.getSourceType(), pair.getTargetType()));
    }
  }
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
/**
 * Returns the actual target type for the given {@code sourceType} and {@code requestedTargetType}. Note that the
 * returned {@link Class} could be an assignable type to the given {@code requestedTargetType}.
 *
 * @param sourceType must not be {@literal null}.
 * @param requestedTargetType can be {@literal null}.
 * @return
 */
private Class<?> getCustomReadTarget(Class<?> sourceType, Class<?> requestedTargetType) {
  notNull(sourceType);
  if (requestedTargetType == null) {
    return null;
  }

  GenericConverter.ConvertiblePair lookupKey = new GenericConverter.ConvertiblePair(sourceType, requestedTargetType);
  CacheValue readTargetTypeValue = customReadTargetTypes.get(lookupKey);

  if (readTargetTypeValue != null) {
    return readTargetTypeValue.getType();
  }

  readTargetTypeValue = CacheValue.of(getCustomTarget(sourceType, requestedTargetType, readingPairs));
  CacheValue cacheValue = customReadTargetTypes.putIfAbsent(lookupKey, readTargetTypeValue);

  return cacheValue != null ? cacheValue.getType() : readTargetTypeValue.getType();
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
/**
 * Inspects the given {@link org.springframework.core.convert.converter.GenericConverter.ConvertiblePair} for ones
 * that have a source compatible type as source. Additionally checks assignability of the target type if one is
 * given.
 *
 * @param sourceType must not be {@literal null}.
 * @param requestedTargetType can be {@literal null}.
 * @param pairs must not be {@literal null}.
 * @return
 */
private static Class<?> getCustomTarget(Class<?> sourceType, Class<?> requestedTargetType,
  Iterable<GenericConverter.ConvertiblePair> pairs) {
  notNull(sourceType);
  notNull(pairs);

  for (GenericConverter.ConvertiblePair typePair : pairs) {
    if (typePair.getSourceType().isAssignableFrom(sourceType)) {
      Class<?> targetType = typePair.getTargetType();
      if (requestedTargetType == null || targetType.isAssignableFrom(requestedTargetType)) {
        return targetType;
      }
    }
  }

  return null;
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
@Test
public void testConvertiblePairEqualsAndHash() {
	GenericConverter.ConvertiblePair pair = new GenericConverter.ConvertiblePair(Number.class, String.class);
	GenericConverter.ConvertiblePair pairEqual = new GenericConverter.ConvertiblePair(Number.class, String.class);
	assertEquals(pair, pairEqual);
	assertEquals(pair.hashCode(), pairEqual.hashCode());
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
@Test
public void testConvertiblePairDifferentEqualsAndHash() {
	GenericConverter.ConvertiblePair pair = new GenericConverter.ConvertiblePair(Number.class, String.class);
	GenericConverter.ConvertiblePair pairOpposite = new GenericConverter.ConvertiblePair(String.class, Number.class);
	assertFalse(pair.equals(pairOpposite));
	assertFalse(pair.hashCode() == pairOpposite.hashCode());
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
@RequestMapping(value = "/entities", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public List<String> listEntities(){
    List<String> data = new ArrayList<String>();
    Set<GenericConverter.ConvertiblePair> list =  entityConverter.getConvertibleTypes();
    for (GenericConverter.ConvertiblePair element: list){
        if (!Modifier.isAbstract(element.getSourceType().getModifiers())){
            data.add(element.getSourceType().getCanonicalName());
        }
    }
    return data;
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
public void addConverterFactory(ConverterFactory<?, ?> converterFactory) {
	GenericConverter.ConvertiblePair typeInfo = getRequiredTypeInfo(converterFactory, ConverterFactory.class);
	if (typeInfo == null) {
		throw new IllegalArgumentException("Unable to the determine sourceType <S> and " +
				"targetRangeType R which your ConverterFactory<S, R> converts between; " +
				"declare these generic types.");
	}
	addConverter(new ConverterFactoryAdapter(converterFactory, typeInfo));
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
public void addConverter(Converter<?, ?> converter) {
	GenericConverter.ConvertiblePair typeInfo = getRequiredTypeInfo(converter, Converter.class);
	Assert.notNull(typeInfo, "Unable to the determine sourceType <S> and targetType " +
			"<T> which your Converter<S, T> converts between; declare these generic types.");
	addConverter(new ConverterAdapter(converter, typeInfo));
}
 

import org.springframework.core.convert.converter.GenericConverter; //导入方法依赖的package包/类
private GenericConverter.ConvertiblePair getRequiredTypeInfo(Object converter, Class<?> genericIfc) {
	Class<?>[] args = GenericTypeResolver.resolveTypeArguments(converter.getClass(), genericIfc);
	return (args != null ? new GenericConverter.ConvertiblePair(args[0], args[1]) : null);
}