第十一章 Spring 中的转换服务

public class Product {
 private String name;

 private BigDecimal price;
}

public class StringToProduct implements Converter<String, Product> {
 @Override
 public Product convert(String source) {
    String[] split = source.split(";");
    return new Product(split[0],new BigDecimal(split[1]));
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


 <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
       <list>
          <bean class="com.source.hot.ioc.book.convert.StringToProduct"/>
       </list>
    </property>
 </bean>
</beans>

class ConvertTest {
 @Test
 void convertTest() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/META-INF/convert.xml");
    ConversionService bean = context.getBean(ConversionService.class);
    Product convert = bean.convert("product;10.00", Product.class);
    System.out.println();
 }

}

@Override
public void afterPropertiesSet() {
   this.conversionService = createConversionService();
   ConversionServiceFactory.registerConverters(this.converters, this.conversionService);
}

protected GenericConversionService createConversionService() {
  return new DefaultConversionService();
}

public DefaultConversionService() {
   addDefaultConverters(this);
}

public interface ConverterRegistry {

 void addConverter(Converter<?, ?> converter);

 <S, T> void addConverter(Class<S> sourceType, Class<T> targetType, Converter<? super S, ? extends T> converter);

 void addConverter(GenericConverter converter);

 void addConverterFactory(ConverterFactory<?, ?> factory);

 void removeConvertible(Class<?> sourceType, Class<?> targetType);

}

@Override
public void addConverter(Converter<?, ?> converter) {
   // 获取解析类型
   ResolvableType[] typeInfo = getRequiredTypeInfo(converter.getClass(), Converter.class);
   if (typeInfo == null && converter instanceof DecoratingProxy) {
      typeInfo = getRequiredTypeInfo(((DecoratingProxy) converter).getDecoratedClass(), Converter.class);
   }
   if (typeInfo == null) {
      throw new IllegalArgumentException("Unable to determine source type <S> and target type <T> for your " +
            "Converter [" + converter.getClass().getName() + "]; does the class parameterize those types?");
   }
   // 添加 converter
   addConverter(new ConverterAdapter(converter, typeInfo[0], typeInfo[1]));
}

@Override
public <S, T> void addConverter(Class<S> sourceType, Class<T> targetType, Converter<? super S, ? extends T> converter) {
   // 添加 convert 的适配器对象
   addConverter(new ConverterAdapter(
         converter, ResolvableType.forClass(sourceType), ResolvableType.forClass(targetType)));
}

private ResolvableType(@Nullable Class<?> clazz) {
    this.resolved = (clazz != null ? clazz : Object.class);
    this.type = this.resolved;
    this.typeProvider = null;
    this.variableResolver = null;
    this.componentType = null;
    this.hash = null;
}

@Override
public void addConverter(GenericConverter converter) {
   // 加入 convert 接口
   this.converters.add(converter);
   // 缓存清除
   invalidateCache();
}

public void add(GenericConverter converter) {
   // 获取转换对象 ConvertiblePair
   Set<ConvertiblePair> convertibleTypes = converter.getConvertibleTypes();
   // 判空
   if (convertibleTypes == null) {
      Assert.state(converter instanceof ConditionalConverter,
            "Only conditional converters may return null convertible types");
      this.globalConverters.add(converter);
   }
   else {
      for (ConvertiblePair convertiblePair : convertibleTypes) {
         // 获取 ConvertersForPair对象
         ConvertersForPair convertersForPair = getMatchableConverters(convertiblePair);
         convertersForPair.add(converter);
      }
   }
}

private ConvertersForPair getMatchableConverters(ConvertiblePair convertiblePair) {
 // 缓存中获取
 ConvertersForPair convertersForPair = this.converters.get(convertiblePair);
 if (convertersForPair == null) {
    // 创建一个空对象
    convertersForPair = new ConvertersForPair();
    this.converters.put(convertiblePair, convertersForPair);
 }
 return convertersForPair;
}

private void invalidateCache() {
   this.converterCache.clear();
}

@Override
public void addConverterFactory(ConverterFactory<?, ?> factory) {
   // 获取类型信息
   ResolvableType[] typeInfo = getRequiredTypeInfo(factory.getClass(), ConverterFactory.class);
   // 判断 factory 是不是DecoratingProxy
   if (typeInfo == null && factory instanceof DecoratingProxy) {
      // 其中 DecoratingProxy 可以获取 class
      typeInfo = getRequiredTypeInfo(((DecoratingProxy) factory).getDecoratedClass(), ConverterFactory.class);
   }
   if (typeInfo == null) {
      throw new IllegalArgumentException("Unable to determine source type <S> and target type <T> for your " +
            "ConverterFactory [" + factory.getClass().getName() + "]; does the class parameterize those types?");
   }
   // 添加转换器
   addConverter(new ConverterFactoryAdapter(factory,
         new ConvertiblePair(typeInfo[0].toClass(), typeInfo[1].toClass())));
}

ConversionServiceFactory.registerConverters(this.converters, this.conversionService)

<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="com.source.hot.ioc.book.convert.StringToProduct"/>
        </list>
    </property>
</bean>

public static void registerConverters(@Nullable Set<?> converters, ConverterRegistry registry) {
   if (converters != null) {
      for (Object converter : converters) {
         if (converter instanceof GenericConverter) {
            registry.addConverter((GenericConverter) converter);
         }
         else if (converter instanceof Converter<?, ?>) {
            registry.addConverter((Converter<?, ?>) converter);
         }
         else if (converter instanceof ConverterFactory<?, ?>) {
            registry.addConverterFactory((ConverterFactory<?, ?>) converter);
         }
         else {
            throw new IllegalArgumentException("Each converter object must implement one of the " +
                  "Converter, ConverterFactory, or GenericConverter interfaces");
         }
      }
   }
}

ConversionService bean = context.getBean(ConversionService.class);
Product convert = bean.convert("product;10.00", Product.class);

@Override
@Nullable
public ConversionService getObject() {
   return this.conversionService;
}

@Override
public Class<? extends ConversionService> getObjectType() {
   return GenericConversionService.class;
}

@Override
public boolean isSingleton() {
   return true;
}

ConversionServiceFactoryBean bean1 = context.getBean(ConversionServiceFactoryBean.class);
Product convert1 = bean1.getObject().convert("product;10.00", Product.class);

@Override
@Nullable
public Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
   Assert.notNull(targetType, "Target type to convert to cannot be null");
   if (sourceType == null) {
      Assert.isTrue(source == null, "Source must be [null] if source type == [null]");
      // 处理 sourceType 为空的转换
      return handleResult(null, targetType, convertNullSource(null, targetType));
   }
   // 数据验证
   if (source != null && !sourceType.getObjectType().isInstance(source)) {
      throw new IllegalArgumentException("Source to convert from must be an instance of [" +
            sourceType + "]; instead it was a [" + source.getClass().getName() + "]");
   }
   // 获取转换器接口
   GenericConverter converter = getConverter(sourceType, targetType);
   if (converter != null) {
      // 通过工具获得转换结果
      Object result = ConversionUtils.invokeConverter(converter, source, sourceType, targetType);
      return handleResult(sourceType, targetType, result);
   }
   // 处理找不到 convert 的转换结果
   return handleConverterNotFound(source, sourceType, targetType);
}

@Nullable
private Object handleResult(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType, @Nullable Object result) {
   if (result == null) {
      // 判断 target type
      assertNotPrimitiveTargetType(sourceType, targetType);
   }
   return result;
}

private void assertNotPrimitiveTargetType(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
    if (targetType.isPrimitive()) {
    	throw new ConversionFailedException(sourceType, targetType, null,
    		new IllegalArgumentException("A null value cannot be assigned to a primitive type"));
    }
}

@Nullable
protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
   ConverterCacheKey key = new ConverterCacheKey(sourceType, targetType);
   GenericConverter converter = this.converterCache.get(key);
   if (converter != null) {
      return (converter != NO_MATCH ? converter : null);
   }

   // 找出 converter 对象
   converter = this.converters.find(sourceType, targetType);
   if (converter == null) {
      // 获取默认的 converter
      converter = getDefaultConverter(sourceType, targetType);
   }

   if (converter != null) {
      // 设置缓存
      this.converterCache.put(key, converter);
      return converter;
   }
   // 设置缓存
   this.converterCache.put(key, NO_MATCH);
   return null;
}

@Nullable
public GenericConverter find(TypeDescriptor sourceType, TypeDescriptor targetType) {
 // Search the full type hierarchy
 // 找到 source 类型的类关系和接口关系
 List<Class<?>> sourceCandidates = getClassHierarchy(sourceType.getType());
 // 找到 target 类型的类关系和接口关系
 List<Class<?>> targetCandidates = getClassHierarchy(targetType.getType());
 // 循环 source 的类列表 和 target 的类列表
 for (Class<?> sourceCandidate : sourceCandidates) {
    for (Class<?> targetCandidate : targetCandidates) {
       // 创建 ConvertiblePair 对象
       ConvertiblePair convertiblePair = new ConvertiblePair(sourceCandidate, targetCandidate);
       // 获取 source + target 的转换接口
       GenericConverter converter = getRegisteredConverter(sourceType, targetType, convertiblePair);
       if (converter != null) {
          return converter;
       }
    }
 }
 return null;
}

@Nullable
private GenericConverter getRegisteredConverter(TypeDescriptor sourceType,
      TypeDescriptor targetType, ConvertiblePair convertiblePair) {

   // Check specifically registered converters
   // 从map中获取
   ConvertersForPair convertersForPair = this.converters.get(convertiblePair);
   if (convertersForPair != null) {
      // 获取 GenericConverter
      GenericConverter converter = convertersForPair.getConverter(sourceType, targetType);
      if (converter != null) {
         return converter;
      }
   }
   // Check ConditionalConverters for a dynamic match
   for (GenericConverter globalConverter : this.globalConverters) {
      if (((ConditionalConverter) globalConverter).matches(sourceType, targetType)) {
         return globalConverter;
      }
   }
   return null;
}

if (converter == null) {
   // 获取默认的 converter
   converter = getDefaultConverter(sourceType, targetType);
}

protected GenericConverter getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
   return (sourceType.isAssignableTo(targetType) ? NO_OP_CONVERTER : null);
}

private static class NoOpConverter implements GenericConverter {

    private final String name;

    public NoOpConverter(String name) {
        this.name = name;
    }

    @Override
    public Set<ConvertiblePair> getConvertibleTypes() {
        return null;
    }

    @Override
    @Nullable
    public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
        return source;
    }

    @Override
    public String toString() {
        return this.name;
    }
}

@Nullable
public static Object invokeConverter(GenericConverter converter, @Nullable Object source,
      TypeDescriptor sourceType, TypeDescriptor targetType) {

   try {
      // converter 方法调用
      return converter.convert(source, sourceType, targetType);
   }
   catch (ConversionFailedException ex) {
      throw ex;
   }
   catch (Throwable ex) {
      throw new ConversionFailedException(sourceType, targetType, source, ex);
   }
}

@Override
@Nullable
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
   if (source == null) {
      // 空对象转换
      return convertNullSource(sourceType, targetType);
   }
   // 转换接口调用
   return this.converter.convert(source);
}

@Nullable
protected Object convertNullSource(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
  if (targetType.getObjectType() == Optional.class) {
     return Optional.empty();
  }
  return null;
}

this.converter.convert(source)

@Override
@Nullable
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
   if (source == null) {
      return convertNullSource(sourceType, targetType);
   }
   // 从工厂中获取一个 convert 接口进行转换
   return this.converterFactory.getConverter(targetType.getObjectType()).convert(source);
}

@Override
public <T extends Number> Converter<Number, T> getConverter(Class<T> targetType) {
 return new NumberToNumber<>(targetType);
}

@Override
public T convert(Number source) {
 return NumberUtils.convertNumberToTargetClass(source, this.targetType);
}

private Object handleConverterNotFound(
      @Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {

   if (source == null) {
      assertNotPrimitiveTargetType(sourceType, targetType);
      return null;
   }
   if ((sourceType == null || sourceType.isAssignableTo(targetType)) &&
         targetType.getObjectType().isInstance(source)) {
      return source;
   }
   throw new ConverterNotFoundException(sourceType, targetType);
}

public interface CommonConvert<S, T> {
    /**
     * 转换
     * @param source 原始对象
     * @return 转换结果对象
     */
    T convert(S source);
}

static Map<ConvertSourceAndTarget, CommonConvert> convertMap
      = new ConcurrentHashMap<>(256);

public class ConvertSourceAndTarget {

    /**
     * {@link CommonConvert} 中的 S
     */
    private Class<?> sourceTypeClass;

    /**
     * {@link CommonConvert} 中的 T
     */
    private Class<?> targetTypeClass;
}

@Override
public void register(Class<? extends CommonConvert> convert) throws IllegalAccessException, InstantiationException {
    if (convert == null) {
        log.warn("当前传入的convert对象为空");
        return;
    }
    CommonConvert cv = convert.newInstance();

    if (cv != null) {
        handler(cv, convert);
    }

}

@Override
public void register(CommonConvert commonConvert ) {

    if (commonConvert == null) {
        log.warn("当前传入的convert对象为空");
        return;
    }


    Class<? extends CommonConvert> convertClass = commonConvert.getClass();

    handler(commonConvert, convertClass);

}

private void handler(CommonConvert commonConvert, Class<? extends CommonConvert> convertClass) {
  Type[] genericInterfaces = convertClass.getGenericInterfaces();

  for (Type genericInterface : genericInterfaces) {
      ParameterizedType pType = (ParameterizedType) genericInterface;
      boolean equals = pType.getRawType().equals(CommonConvert.class);
      if (equals) {
          Type[] actualTypeArguments = pType.getActualTypeArguments();

          if (actualTypeArguments.length == 2) {
              Type a1 = actualTypeArguments[0];
              Type a2 = actualTypeArguments[1];

              try {

                  Class<?> sourceClass = Class.forName(a1.getTypeName());
                  Class<?> targetClass = Class.forName(a2.getTypeName());

                  ConvertSourceAndTarget convertSourceAndTarget =
                      new ConvertSourceAndTarget(sourceClass,
                                                 targetClass);
                  // 如果类型相同 覆盖
                  convertMap.put(convertSourceAndTarget, commonConvert);
              }
              catch (Exception e) {
                  log.error("a1=[{}]", a1);
                  log.error("a2=[{}]", a2);
                  log.error("从泛型中转换成class异常", e);
              }
          }
      }
  }
}

public static <T> T convert(Object source, Class<T> target) {
    if (log.isInfoEnabled()) {
        log.info("convert,source = {}, target = {}", source, target);
    }

    if (source == null || target == null) {
        throw new IllegalArgumentException("参数异常请重新检查");
    }


    ConvertSourceAndTarget  convertSourceAndTarget = new ConvertSourceAndTarget(source.getClass(), target);

    CommonConvert commonConvert = DefaultConvertRegister.getConvertMap(convertSourceAndTarget);
    if (commonConvert != null) {

        return (T) commonConvert.convert(source);
    }
    return null;
}