@FunctionalInterfacepublic interface Converter<S, T> {	T convert(S source);}

/** * Converter：1:1 */@Testpublic void test() {    System.out.println("----------------StringToBooleanConverter---------------");    Converter<String, Boolean> converter = new StringToBooleanConverter();
    // trueValues.add("true");    // trueValues.add("on");    // trueValues.add("yes");    // trueValues.add("1");    System.out.println(converter.convert("true"));    System.out.println(converter.convert("1"));
    // falseValues.add("false");    // falseValues.add("off");    // falseValues.add("no");    // falseValues.add("0");    System.out.println(converter.convert("FalSe"));    System.out.println(converter.convert("off"));    // 注意：空串返回的是null    System.out.println(converter.convert(""));

    System.out.println("----------------StringToCharsetConverter---------------");    Converter<String, Charset> converter2 = new StringToCharsetConverter();    // 中间横杠非必须，但强烈建议写上   不区分大小写    System.out.println(converter2.convert("uTf-8"));    System.out.println(converter2.convert("utF8"));}

----------------StringToBooleanConverter---------------truetruefalsefalsenull----------------StringToCharsetConverter---------------UTF-8UTF-8

public interface ConverterFactory<S, R> {	<T extends R> Converter<S, T> getConverter(Class<T> targetType);}

final class StringToNumberConverterFactory implements ConverterFactory<String, Number> {
	@Override	public <T extends Number> Converter<String, T> getConverter(Class<T> targetType) {		return new StringToNumber<T>(targetType);	}

	// 私有内部类：实现Converter接口。用泛型边界约束一类类型	private static final class StringToNumber<T extends Number> implements Converter<String, T> {
		private final Class<T> targetType;		public StringToNumber(Class<T> targetType) {			this.targetType = targetType;		}
		@Override		public T convert(String source) {			if (source.isEmpty()) {				return null;			}			return NumberUtils.parseNumber(source, this.targetType);		}	}
}

/** * ConverterFactory：1:N */@Testpublic void test2() {    System.out.println("----------------StringToNumberConverterFactory---------------");    ConverterFactory<String, Number> converterFactory = new StringToNumberConverterFactory();    // 注意：这里不能写基本数据类型。如int.class将抛错    System.out.println(converterFactory.getConverter(Integer.class).convert("1").getClass());    System.out.println(converterFactory.getConverter(Double.class).convert("1.1").getClass());    System.out.println(converterFactory.getConverter(Byte.class).convert("0x11").getClass());}

----------------StringToNumberConverterFactory---------------class java.lang.Integerclass java.lang.Doubleclass java.lang.Byte

public interface GenericConverter {
	Set<ConvertiblePair> getConvertibleTypes();	Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);		// 普通POJO	final class ConvertiblePair {		private final Class<?> sourceType;		private final Class<?> targetType;	}}

final class CollectionToCollectionConverter implements ConditionalGenericConverter {
	private final ConversionService conversionService;	public CollectionToCollectionConverter(ConversionService conversionService) {		this.conversionService = conversionService;	}
		// 集合转集合：如String集合转为Integer集合	@Override	public Set<ConvertiblePair> getConvertibleTypes() {		return Collections.singleton(new ConvertiblePair(Collection.class, Collection.class));	}}

CollectionToCollectionConverter：
	@Override	public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {		return ConversionUtils.canConvertElements(sourceType.getElementTypeDescriptor(), targetType.getElementTypeDescriptor(), this.conversionService);	}

CollectionToCollectionConverter：
	@Override	public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {		if (source == null) {			return null;		}		Collection<?> sourceCollection = (Collection<?>) source;
				// 判断：这些情况下，将不用执行后续转换动作了，直接返回即可		boolean copyRequired = !targetType.getType().isInstance(source);		if (!copyRequired && sourceCollection.isEmpty()) {			return source;		}		TypeDescriptor elementDesc = targetType.getElementTypeDescriptor();		if (elementDesc == null && !copyRequired) {			return source;		}
		Collection<Object> target = CollectionFactory.createCollection(targetType.getType(),				(elementDesc != null ? elementDesc.getType() : null), sourceCollection.size());		// 若目标类型没有指定泛型（没指定就是Object），不用遍历直接添加全部即可		if (elementDesc == null) {			target.addAll(sourceCollection);		} else {			// 遍历：一个一个元素的转，时间复杂度还是蛮高的			// 元素转元素委托给conversionService去完成			for (Object sourceElement : sourceCollection) {				Object targetElement = this.conversionService.convert(sourceElement,						sourceType.elementTypeDescriptor(sourceElement), elementDesc);				target.add(targetElement);				if (sourceElement != targetElement) {					copyRequired = true;				}			}		}
		return (copyRequired ? target : source);	}

@Testpublic void test3() {    System.out.println("----------------CollectionToCollectionConverter---------------");    ConditionalGenericConverter conditionalGenericConverter = new CollectionToCollectionConverter(new DefaultConversionService());    // 将Collection转为Collection（注意：没有指定泛型类型哦）    System.out.println(conditionalGenericConverter.getConvertibleTypes());
    List<String> sourceList = Arrays.asList("1", "2", "2", "3", "4");    TypeDescriptor sourceTypeDesp = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));    TypeDescriptor targetTypeDesp = TypeDescriptor.collection(Set.class, TypeDescriptor.valueOf(Integer.class));
    System.out.println(conditionalGenericConverter.matches(sourceTypeDesp, targetTypeDesp));    Object convert = conditionalGenericConverter.convert(sourceList, sourceTypeDesp, targetTypeDesp);    System.out.println(convert.getClass());    System.out.println(convert);}

[java.util.Collection -> java.util.Collection]trueclass java.util.LinkedHashSet[1, 2, 3, 4]

public interface ConditionalConverter {	boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType);}