[[374345]]

 你好，我是A哥(YourBatman)。

Spring設(shè)計(jì)了org.springframework.format.Formatter格式化器接口抽象，對格式化器進(jìn)行了大一統(tǒng)，讓你只需要關(guān)心統(tǒng)一的API，而無需關(guān)注具體實(shí)現(xiàn)，相關(guān)議題上篇文章 有詳細(xì)介紹。

Spring內(nèi)建有不少格式化器實(shí)現(xiàn)，同時(shí)對它們的管理、調(diào)度使用也有專門的組件負(fù)責(zé)，可謂涇渭分明，職責(zé)清晰。本文將圍繞Formatter注冊中心FormatterRegistry展開，為你介紹Spring是如何優(yōu)雅，巧妙的實(shí)現(xiàn)注冊管理的。

學(xué)習(xí)編碼是個(gè)模仿的過程，絕大多數(shù)時(shí)候你并不需要?jiǎng)?chuàng)造東西。當(dāng)然這里指的模仿并非普通的CV模式，而是取精華為己所用，本文所述巧妙設(shè)計(jì)便是精華所在，任君提取。

本文提綱

版本約定

• Spring Framework：5.3.x
• Spring Boot：2.4.x

正文

對Spring的源碼閱讀、分析這么多了，會(huì)發(fā)現(xiàn)對于組件管理大體思想都一樣，離不開這幾個(gè)組件：注冊中心(注冊員) + 分發(fā)器。

一龍生九子，九子各不同。雖然大體思路保持一致，但每個(gè)實(shí)現(xiàn)在其場景下都有自己的發(fā)揮空間，值得我們向而往之。

FormatterRegistry：格式化器注冊中心

field屬性格式化器的注冊表(注冊中心)。請注意：這里強(qiáng)調(diào)了field的存在，先混個(gè)眼熟，后面你將能有較深體會(huì)。

public interface FormatterRegistry extends ConverterRegistry { 
 
 void addPrinter(Printer<?> printer); 
 void addParser(Parser<?> parser); 
 void addFormatter(Formatter<?> formatter); 
 void addFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter); 
 void addFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?> parser); 
 
 void addFormatterForFieldAnnotation(AnnotationFormatterFactory<? extends Annotation> annotationFormatterFactory); 
} 

此接口繼承自類型轉(zhuǎn)換器注冊中心ConverterRegistry，所以格式化注冊中心是轉(zhuǎn)換器注冊中心的加強(qiáng)版，是其超集，功能更多更強(qiáng)大。

❝關(guān)于類型轉(zhuǎn)換器注冊中心ConverterRegistry的詳細(xì)介紹，可翻閱本系列的這篇文章，看完后門清❞

雖然FormatterRegistry提供的添加方法挺多，但其實(shí)基本都是在描述同一個(gè)事：為指定類型fieldType添加格式化器(printer或parser)，繪制成圖如下所示：

❝說明：最后一個(gè)接口方法除外，addFormatterForFieldAnnotation()和格式化注解相關(guān)，因?yàn)樗浅Ｖ匾?，因此放在下文專門撰文講解❞

FormatterRegistry接口的繼承樹如下：

有了學(xué)過ConverterRegistry的經(jīng)驗(yàn)，這種設(shè)計(jì)套路很容易被看穿。這兩個(gè)實(shí)現(xiàn)類按層級進(jìn)行分工：

• FormattingConversionService：實(shí)現(xiàn)所有接口方法
• DefaultFormattingConversionService：繼承自上面的FormattingConversionService，在其基礎(chǔ)上注冊默認(rèn)的格式化器

事實(shí)上，功能分類確實(shí)如此。本文重點(diǎn)介紹FormattingConversionService，這個(gè)類的設(shè)計(jì)實(shí)現(xiàn)上有很多討巧之處，只要你來，要你好看。

FormattingConversionService

它是FormatterRegistry接口的實(shí)現(xiàn)類，實(shí)現(xiàn)其所有接口方法。

FormatterRegistry是ConverterRegistry的子接口，而ConverterRegistry接口的所有方法均已由GenericConversionService全部實(shí)現(xiàn)了，所以可以通過繼承它來間接完成 ConverterRegistry接口方法的實(shí)現(xiàn)，因此本類的繼承結(jié)構(gòu)是這樣子的(請細(xì)品這個(gè)結(jié)構(gòu))：

FormattingConversionService通過繼承GenericConversionService搞定“左半邊”(父接口ConverterRegistry);只剩“右半邊”待處理，也就是FormatterRegistry新增的接口方法。

FormattingConversionService： 
 
 @Override 
 public void addPrinter(Printer<?> printer) { 
  Class<?> fieldType = getFieldType(printer, Printer.class); 
  addConverter(new PrinterConverter(fieldType, printer, this)); 
 } 
 @Override 
 public void addParser(Parser<?> parser) { 
  Class<?> fieldType = getFieldType(parser, Parser.class); 
  addConverter(new ParserConverter(fieldType, parser, this)); 
 } 
 @Override 
 public void addFormatter(Formatter<?> formatter) { 
  addFormatterForFieldType(getFieldType(formatter), formatter); 
 } 
 @Override 
 public void addFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter) { 
  addConverter(new PrinterConverter(fieldType, formatter, this)); 
  addConverter(new ParserConverter(fieldType, formatter, this)); 
 } 
 @Override 
 public void addFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?> parser) { 
  addConverter(new PrinterConverter(fieldType, printer, this)); 
  addConverter(new ParserConverter(fieldType, parser, this)); 
 } 

從接口的實(shí)現(xiàn)可以看到這個(gè)“驚天大秘密”：所有的格式化器(含Printer、Parser、Formatter)都是被當(dāng)作Converter注冊的，也就是說真正的注冊中心只有一個(gè)，那就是ConverterRegistry。

格式化器的注冊管理遠(yuǎn)沒有轉(zhuǎn)換器那么復(fù)雜，因?yàn)樗腔谏蠈舆m配的思想，最終適配為Converter來完成注冊的。所以最終注冊進(jìn)去的實(shí)際是個(gè)經(jīng)由格式化器適配來的轉(zhuǎn)換器，完美復(fù)用了那套復(fù)雜的轉(zhuǎn)換器管理邏輯。

❝這種設(shè)計(jì)思路，完全可以“CV”到我們自己的編程思維里吧❞

甭管是Printer還是Parser，都會(huì)被適配為GenericConverter從而被添加到ConverterRegistry里面去，被當(dāng)作轉(zhuǎn)換器管理起來?，F(xiàn)在你應(yīng)該知道為何FormatterRegistry接口僅需提供添加方法而無需提供刪除方法了吧。

當(dāng)然嘍，關(guān)于Printer/Parser的適配實(shí)現(xiàn)亦是本文本文關(guān)注的焦點(diǎn)，里面大有文章可為，let's go!

PrinterConverter：Printer接口適配器

把Printer適配為轉(zhuǎn)換器，轉(zhuǎn)換目標(biāo)為fieldType -> String。

private static class PrinterConverter implements GenericConverter { 
  
 private final Class<?> fieldType; 
 // 從Printer<?>泛型里解析出來的類型，有可能和fieldType一樣，有可能不一樣 
 private final TypeDescriptor printerObjectType; 
 // 實(shí)際執(zhí)行“轉(zhuǎn)換”動(dòng)作的組件 
 private final Printer printer; 
 private final ConversionService conversionService; 
 
 public PrinterConverter(Class<?> fieldType, Printer<?> printer, ConversionService conversionService) { 
  ... 
  // 從類上解析出泛型類型，但不一定是實(shí)際類型 
  this.printerObjectType = TypeDescriptor.valueOf(resolvePrinterObjectType(printer)); 
  ... 
 } 
 
 // fieldType -> String 
 @Override 
 public Set<ConvertiblePair> getConvertibleTypes() { 
  return Collections.singleton(new ConvertiblePair(this.fieldType, String.class)); 
 } 
 
} 

既然是轉(zhuǎn)換器，重點(diǎn)當(dāng)然是它的convert轉(zhuǎn)換方法：

PrinterConverter： 
 
 @Override 
 @SuppressWarnings("unchecked") 
 public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) { 
  // 若sourceType不是printerObjectType的子類型 
  // 就嘗試用conversionService轉(zhuǎn)一下類型試試 
  // （也就是說：若是子類型是可直接處理的，無需轉(zhuǎn)換一趟） 
  if (!sourceType.isAssignableTo(this.printerObjectType)) { 
   source = this.conversionService.convert(source, sourceType, this.printerObjectType); 
  } 
  if (source == null) { 
   return ""; 
  } 
 
  // 執(zhí)行實(shí)際轉(zhuǎn)換邏輯 
  return this.printer.print(source, LocaleContextHolder.getLocale()); 
 } 

轉(zhuǎn)換步驟分為兩步：

1.若源類型(實(shí)際類型)不是該P(yáng)rinter類型的泛型類型的子類型的話，那就嘗試使用conversionService轉(zhuǎn)一趟

    a.例如：Printer處理的是Number類型，但是你傳入的是Person類型，這個(gè)時(shí)候conversionService就會(huì)發(fā)揮作用了

2.交由目標(biāo)格式化器Printer執(zhí)行實(shí)際的轉(zhuǎn)換邏輯

可以說Printer它可以直接轉(zhuǎn)，也可以是構(gòu)建在conversionService 之上 的一個(gè)轉(zhuǎn)換器：只要源類型是我能處理的，或者經(jīng)過conversionService后能成為我能處理的類型，都能進(jìn)行轉(zhuǎn)換。有一次完美的能力復(fù)用。

說到這我估計(jì)有些小伙伴還不能理解啥意思，能解決什么問題，那么下面我分別給你用代碼舉例，加深你的了解。

準(zhǔn)備一個(gè)Java Bean：

@Data 
@NoArgsConstructor 
@AllArgsConstructor 
public class Person { 
 
    private Integer id; 
    private String name; 
} 

準(zhǔn)備一個(gè)Printer：將Integer類型加10后，再轉(zhuǎn)為String類型

private static class IntegerPrinter implements Printer<Integer> { 
 
    @Override 
    public String print(Integer object, Locale locale) { 
        object += 10; 
        return object.toString(); 
    } 
} 

示例一：使用Printer，無中間轉(zhuǎn)換

測試用例：

@Test 
public void test2() { 
    FormattingConversionService formattingConversionService = new FormattingConversionService(); 
    FormatterRegistry formatterRegistry = formattingConversionService; 
    // 說明：這里不使用DefaultConversionService是為了避免默認(rèn)注冊的那些轉(zhuǎn)換器對結(jié)果的“干擾”，不方便看效果 
    // ConversionService conversionService = new DefaultConversionService(); 
    ConversionService conversionService = formattingConversionService; 
 
    // 注冊格式化器 
    formatterRegistry.addPrinter(new IntegerPrinter()); 
 
    // 最終均使用ConversionService統(tǒng)一提供服務(wù)轉(zhuǎn)換 
    System.out.println(conversionService.canConvert(Integer.class, String.class)); 
    System.out.println(conversionService.canConvert(Person.class, String.class)); 
 
    System.out.println(conversionService.convert(1, String.class)); 
    // 報(bào)錯(cuò)：No converter found capable of converting from type [cn.yourbatman.bean.Person] to type [java.lang.String] 
    // System.out.println(conversionService.convert(new Person(1, "YourBatman"), String.class)); 
} 

運(yùn)行程序，輸出：

true 
false 
11 

完美。

但是，它不能完成Person -> String類型的轉(zhuǎn)換。一般來說，我們有兩種途徑來達(dá)到此目的：

1.直接方式：寫一個(gè)Person轉(zhuǎn)String的轉(zhuǎn)換器，專用

   a.缺點(diǎn)明顯：多寫一套代碼

2.組合方式(推薦)：如果目前已經(jīng)有Person -> Integer的了，那我們就組合起來用就非常方便啦，下面這個(gè)例子將告訴你使用這種方式完成“需求”

   a.缺點(diǎn)不明顯：轉(zhuǎn)換器一般要求與業(yè)務(wù)數(shù)據(jù)無關(guān)，因此通用性強(qiáng)，應(yīng)最大可能的復(fù)用

下面示例二將幫你解決通過復(fù)用已有能力方式達(dá)到Person -> String的目的。

示例二：使用Printer，有中間轉(zhuǎn)換

基于示例一，若要實(shí)現(xiàn)Person -> String的話，只需再給寫一個(gè)Person -> Integer的轉(zhuǎn)換器放進(jìn)ConversionService里即可。

❝說明：一般來說ConversionService已經(jīng)具備很多“能力”了的，拿來就用即可。本例為了幫你說明底層原理，所以用的是一個(gè)“干凈的”ConversionService實(shí)例❞

@Test 
public void test2() { 
    FormattingConversionService formattingConversionService = new FormattingConversionService(); 
    FormatterRegistry formatterRegistry = formattingConversionService; 
    // 說明：這里不使用DefaultConversionService是為了避免默認(rèn)注冊的那些轉(zhuǎn)換器對結(jié)果的“干擾”，不方便看效果 
    // ConversionService conversionService = new DefaultConversionService(); 
    ConversionService conversionService = formattingConversionService; 
 
    // 注冊格式化器 
    formatterRegistry.addFormatterForFieldType(Person.class, new IntegerPrinter(), null); 
    // 強(qiáng)調(diào)：此處絕不能使用lambda表達(dá)式代替，否則泛型類型丟失，結(jié)果將出錯(cuò) 
    formatterRegistry.addConverter(new Converter<Person, Integer>() { 
        @Override 
        public Integer convert(Person source) { 
            return source.getId(); 
        } 
    }); 
 
    // 最終均使用ConversionService統(tǒng)一提供服務(wù)轉(zhuǎn)換 
    System.out.println(conversionService.canConvert(Person.class, String.class)); 
    System.out.println(conversionService.convert(new Person(1, "YourBatman"), String.class)); 
} 

運(yùn)行程序，輸出：

true 
11 

完美。

針對本例，有如下關(guān)注點(diǎn)：

1.使用addFormatterForFieldType()方法注冊了IntegerPrinter，并且明確指定了處理的類型：只處理Person類型
    a.說明：IntegerPrinter是可以注冊多次分別用于處理不同類型。比如你依舊可以保留formatterRegistry.addPrinter(new IntegerPrinter());來處理Integer -> String是木問題的

2.因?yàn)镮ntegerPrinter 實(shí)際上 只能轉(zhuǎn)換 Integer -> String，因此還必須注冊一個(gè)轉(zhuǎn)換器，用于Person -> Integer橋接一下，這樣就串起來了Person -> Integer -> String。只是外部看起來這些都是IntegerPrinter做的一樣，特別工整

3.強(qiáng)調(diào)：addConverter()注冊轉(zhuǎn)換器時(shí)請務(wù)必不要使用lambda表達(dá)式代替輸入，否則會(huì)失去泛型類型，導(dǎo)致出錯(cuò)

   a.若想用lambda表達(dá)式，請使用addConverter(Class,Class,Converter)這個(gè)重載方法完成注冊

ParserConverter：Parser接口適配器

把Parser適配為轉(zhuǎn)換器，轉(zhuǎn)換目標(biāo)為String -> fieldType。

private static class ParserConverter implements GenericConverter { 
 
 private final Class<?> fieldType; 
 private final Parser<?> parser; 
 private final ConversionService conversionService; 
 
 ... // 省略構(gòu)造器 
 
 // String -> fieldType 
 @Override 
 public Set<ConvertiblePair> getConvertibleTypes() { 
  return Collections.singleton(new ConvertiblePair(String.class, this.fieldType)); 
 } 
  
} 

既然是轉(zhuǎn)換器，重點(diǎn)當(dāng)然是它的convert轉(zhuǎn)換方法：

ParserConverter： 
 
 @Override 
 @Nullable 
 public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) { 
  // 空串當(dāng)null處理 
  String text = (String) source; 
  if (!StringUtils.hasText(text)) { 
   return null; 
  } 
   
  ... 
  Object result = this.parser.parse(text, LocaleContextHolder.getLocale()); 
  ... 
   
  // 解讀/轉(zhuǎn)換結(jié)果 
  TypeDescriptor resultType = TypeDescriptor.valueOf(result.getClass()); 
  if (!resultType.isAssignableTo(targetType)) { 
   result = this.conversionService.convert(result, resultType, targetType); 
  } 
  return result; 
 } 

轉(zhuǎn)換步驟分為兩步：

1. 通過Parser將String轉(zhuǎn)換為指定的類型結(jié)果result(若失敗，則拋出異常)
2. 判斷若result屬于目標(biāo)類型的子類型，直接返回，否則調(diào)用ConversionService轉(zhuǎn)換一把

可以看到它和Printer的“順序”是相反的，在返回值上做文章。同樣的，下面將用兩個(gè)例子來加深理解。

private static class IntegerParser implements Parser<Integer> { 
 
    @Override 
    public Integer parse(String text, Locale locale) throws ParseException { 
        return NumberUtils.parseNumber(text, Integer.class); 
    } 
} 

示例一：使用Parser，無中間轉(zhuǎn)換

書寫測試用例：

@Test 
public void test3() { 
    FormattingConversionService formattingConversionService = new FormattingConversionService(); 
    FormatterRegistry formatterRegistry = formattingConversionService; 
    ConversionService conversionService = formattingConversionService; 
 
    // 注冊格式化器 
    formatterRegistry.addParser(new IntegerParser()); 
 
    System.out.println(conversionService.canConvert(String.class, Integer.class)); 
    System.out.println(conversionService.convert("1", Integer.class)); 
} 

運(yùn)行程序，輸出：

true 
1 

完美。

示例二：使用Parser，有中間轉(zhuǎn)換

下面示例輸入一個(gè)“1”字符串，出來一個(gè)Person對象(因?yàn)橛辛松厦胬拥匿亯|，這里就“直抒胸臆”了哈)。

@Test 
public void test4() { 
    FormattingConversionService formattingConversionService = new FormattingConversionService(); 
    FormatterRegistry formatterRegistry = formattingConversionService; 
    ConversionService conversionService = formattingConversionService; 
 
    // 注冊格式化器 
    formatterRegistry.addFormatterForFieldType(Person.class, null, new IntegerParser()); 
    formatterRegistry.addConverter(new Converter<Integer, Person>() { 
        @Override 
        public Person convert(Integer source) { 
            return new Person(source, "YourBatman"); 
        } 
    }); 
 
    System.out.println(conversionService.canConvert(String.class, Person.class)); 
    System.out.println(conversionService.convert("1", Person.class)); 
} 

運(yùn)行程序，啪，空指針了：

java.lang.NullPointerException 
 at org.springframework.format.support.FormattingConversionService$PrinterConverter.resolvePrinterObjectType(FormattingConversionService.java:179) 
 at org.springframework.format.support.FormattingConversionService$PrinterConverter.<init>(FormattingConversionService.java:155) 
 at org.springframework.format.support.FormattingConversionService.addFormatterForFieldType(FormattingConversionService.java:95) 
 at cn.yourbatman.formatter.Demo.test4(Demo.java:86) 
 ... 

根據(jù)異常棧信息，可明確原因?yàn)椋篴ddFormatterForFieldType()方法的第二個(gè)參數(shù)不能傳null，否則空指針。這其實(shí)是Spring Framework的bug，我已向社區(qū)提了issue，期待能夠被解決嘍：

為了正常運(yùn)行本例，這么改一下：

// 第二個(gè)參數(shù)不傳null，用IntegerPrinter占位 
formatterRegistry.addFormatterForFieldType(Person.class, new IntegerPrinter(), new IntegerParser()); 

再次運(yùn)行程序，輸出：

true 
Person(id=1, name=YourBatman) 

完美。

針對本例，有如下關(guān)注點(diǎn)：

1.使用addFormatterForFieldType()方法注冊了IntegerParser，并且明確指定了處理的類型，用于處理Person類型

   a.也就是說此IntegerParser專門用于轉(zhuǎn)換目標(biāo)類型為Person的屬性

2.因?yàn)镮ntegerParser 實(shí)際上 只能轉(zhuǎn)換 String -> Integer，因此還必須注冊一個(gè)轉(zhuǎn)換器，用于Integer -> Person橋接一下，這樣就串起來了String -> Integer -> Person。外面看起來這些都是IntegerParser做的一樣，非常工整

3.同樣強(qiáng)調(diào)：addConverter()注冊轉(zhuǎn)換器時(shí)請務(wù)必不要使用lambda表達(dá)式代替輸入，否則會(huì)失去泛型類型，導(dǎo)致出錯(cuò)

二者均持有ConversionService帶來哪些增強(qiáng)?

❝說明：關(guān)于如此重要的ConversionService你懂的，遺忘了的可乘坐電梯到這復(fù)習(xí)❞

對于PrinterConverter和ParserConverter來講，它們的源目的是實(shí)現(xiàn) String <-> Object，特點(diǎn)是：

• PrinterConverter：出口必須是String類型，入口類型也已確定，即Printer的泛型類型，只能處理 T(或T的子類型) -> StringParserConverter：入口必須是String類型，出口類型也已確定，即Parser的泛型類型，只能處理 String -> T(或T的子類型)按既定“規(guī)則”，它倆的能力范圍還是蠻受限的。Spring厲害的地方就在于此，可以巧妙的通過組合的方式，擴(kuò)大現(xiàn)有組件的能力邊界。比如本利中它就在PrinterConverter/ParserConverter里分別放入了ConversionService引用，從而到這樣的效果：

ConversionService

通過能力組合協(xié)作，起到串聯(lián)作用，從而擴(kuò)大輸入/輸出“范圍”，感覺就像起到了放大鏡的效果一樣，這個(gè)設(shè)計(jì)還是很討巧的。

總結(jié)

本文以介紹FormatterRegistry接口為中心，重點(diǎn)研究了此接口的實(shí)現(xiàn)方式，發(fā)現(xiàn)即使小小的一枚注冊中心實(shí)現(xiàn)，也蘊(yùn)藏有豐富亮點(diǎn)供以學(xué)習(xí)、CV。

一般來說ConversionService 天生具備非常強(qiáng)悍的轉(zhuǎn)換能力，因此實(shí)際情況是你若需要自定義一個(gè)Printer/Parser的話是大概率不需要自己再額外加個(gè)Converter轉(zhuǎn)換器的，也就是說底層機(jī)制讓你已然站在了“巨人”肩膀上。

☾本文思考題☽

看完了不一定看懂了，看懂了不一定記住了，記住了不一定掌握了。本文思考/進(jìn)階內(nèi)容：

1. FormatterRegistry作為注冊中心只有添加方法，why?
2. 示例中為何強(qiáng)調(diào)：addConverter()注冊轉(zhuǎn)換器時(shí)請務(wù)必不要使用lambda表達(dá)式代替輸入，會(huì)有什么問題?
3. 這種功能組合/橋接的巧妙設(shè)計(jì)方式，你腦中還能想到其它案例嗎?

本文是 A哥(YourBatman) 原創(chuàng)文章，未經(jīng)作者允許不得轉(zhuǎn)載，謝謝合作。