Spring FormattingConversionService

public class NumberStyleFormatter extends AbstractNumberFormatter {}
public abstract class AbstractNumberFormatter implements Formatter<Number>{}
public interface Formatter<T> extends Printer<T>, Parser<T> {}

@Override
public void addFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter) {
   addConverter(new PrinterConverter(fieldType, formatter, this));
   addConverter(new ParserConverter(fieldType, formatter, this));
}

@Override
@SuppressWarnings("unchecked")
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
   if (!sourceType.isAssignableTo(this.printerObjectType)) {
      // 值转换
      source = this.conversionService.convert(source, sourceType, this.printerObjectType);
   }
   if (source == null) {
      return "";
   }
   // 获取 print 值
   return this.printer.print(source, LocaleContextHolder.getLocale());
}

@Override
@Nullable
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
   // 强制转换
   String text = (String) source;
   if (!StringUtils.hasText(text)) {
      return null;
   }
   Object result;
   try {
      // 解析器解析
      result = this.parser.parse(text, LocaleContextHolder.getLocale());
   }
   catch (IllegalArgumentException ex) {
      throw ex;
   }
   catch (Throwable ex) {
      throw new IllegalArgumentException("Parse attempt failed for value [" + text + "]", ex);
   }
   // 获取类型描述
   TypeDescriptor resultType = TypeDescriptor.valueOf(result.getClass());
   if (!resultType.isAssignableTo(targetType)) {
      // 转换
      result = this.conversionService.convert(result, resultType, targetType);
   }
   return result;
}

@Override
public void addFormatterForFieldAnnotation(AnnotationFormatterFactory<? extends Annotation> annotationFormatterFactory) {
   // 获取 annotationFormatterFactory 的注解类型
   Class<? extends Annotation> annotationType = getAnnotationType(annotationFormatterFactory);
   if (this.embeddedValueResolver != null && annotationFormatterFactory instanceof EmbeddedValueResolverAware) {
      // 设置字符串解析类
      ((EmbeddedValueResolverAware) annotationFormatterFactory).setEmbeddedValueResolver(this.embeddedValueResolver);
   }
   // 调用 AnnotationFormatterFactory 获取字段类型
   Set<Class<?>> fieldTypes = annotationFormatterFactory.getFieldTypes();
   for (Class<?> fieldType : fieldTypes) {
      // 设置 converter
      // 1. 设置 printer
      addConverter(new AnnotationPrinterConverter(annotationType, annotationFormatterFactory, fieldType));
      // 2. 设置 parser
      addConverter(new AnnotationParserConverter(annotationType, annotationFormatterFactory, fieldType));
   }
}

1. AnnotationPrinterConverter
2. AnnotationParserConverter

@Override
@SuppressWarnings("unchecked")
@Nullable
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
   Annotation ann = sourceType.getAnnotation(this.annotationType);
   if (ann == null) {
      throw new IllegalStateException(
            "Expected [" + this.annotationType.getName() + "] to be present on " + sourceType);
   }
   // 缓存key
   AnnotationConverterKey converterKey = new AnnotationConverterKey(ann, sourceType.getObjectType());
   // 从缓存中获取
   GenericConverter converter = cachedPrinters.get(converterKey);
   if (converter == null) {
      Printer<?> printer = this.annotationFormatterFactory.getPrinter(
            converterKey.getAnnotation(), converterKey.getFieldType());
      // 创建缓存value
      converter = new PrinterConverter(this.fieldType, printer, FormattingConversionService.this);
      // 设置缓存
      cachedPrinters.put(converterKey, converter);
   }
   // 执行转换
   return converter.convert(source, sourceType, targetType);
}

@Override
@SuppressWarnings("unchecked")
@Nullable
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
   Annotation ann = targetType.getAnnotation(this.annotationType);
   if (ann == null) {
      throw new IllegalStateException(
            "Expected [" + this.annotationType.getName() + "] to be present on " + targetType);
   }
   AnnotationConverterKey converterKey = new AnnotationConverterKey(ann, targetType.getObjectType());
   GenericConverter converter = cachedParsers.get(converterKey);
   if (converter == null) {
      Parser<?> parser = this.annotationFormatterFactory.getParser(
            converterKey.getAnnotation(), converterKey.getFieldType());
      converter = new ParserConverter(this.fieldType, parser, FormattingConversionService.this);
      cachedParsers.put(converterKey, converter);
   }
   return converter.convert(source, sourceType, targetType);
}