4. 上新了Spring，全新一代类型转换机制

亦凉 2022-12-28 01:41 95阅读 0赞

### 目录 ###

*  ✍前言
 *   *  版本约定
 *  ✍正文
 *   *  PropertyEditor设计缺陷
     *  新一代类型转换
     *   *  Converter
         *   *  代码示例
             *  不足
         *  ConverterFactory
         *   *  代码示例
             *  不足
         *  GenericConverter
         *   *  代码示例
             *  不足
         *  ConditionalConverter
 *  ✍总结
 *   *   *  ✔✔✔推荐阅读✔✔✔
 *  ♥关注A哥♥

![在这里插入图片描述][2020121707475621.png_pic_center]

> 分享、成长，拒绝浅藏辄止。关注公众号【**BAT的乌托邦**】，回复关键字`专栏`有Spring技术栈、中间件等小而美的**原创专栏**供以免费学习。本文已被 [https://www.yourbatman.cn][https_www.yourbatman.cn] 收录。

# ✍前言 #

你好，我是YourBatman。

[上篇文章][Link 1] 介绍完了Spring类型转换早期使用的PropertyEditor详细介绍，关于PropertyEditor现存的资料其实还蛮少的，希望这几篇文章能弥补这块空白，贡献一份微薄之力。

如果你也吐槽过PropertyEditor不好用，那么本文将对会有帮助。Spring自**3.0版本**开始自建了一套全新类型转换接口，这就是本文的主要内容，接下来逐步展开。

> 说明：Spring自3.0后笑傲群雄，进入大一统。Java从此步入Spring的时代

## 版本约定 ##

*  Spring Framework：5.3.1
 *  Spring Boot：2.4.0

![在这里插入图片描述][20201217074252478.png_pic_center]

# ✍正文 #

在了解新一代的转换接口之前，先思考一个问题：**Spring为何要自己造一套轮子呢？** 一向秉承不重复造轮子原则的Spring，不是迫不得已的话是不会去动他人奶酪的，毕竟互利共生才能长久。类型转换，作为Spring框架的基石，扮演着异常重要的角色，因此对其可扩展性、可维护性、高效性均有很高要求。

基于此，我们先来了解下PropertyEditor设计上到底有哪些缺陷/不足（不能满足现代化需求），让Spring“被迫”走上了自建道路。

## PropertyEditor设计缺陷 ##

前提说明：本文指出它的设计缺陷，只讨论把它当做类型转换器在转换场景下存在的一些缺陷。

1.  职责不单一：该接口有非常多的方法，但只用到2个而已
2.  类型不安全：setValue()方法入参是Object，getValue()返回值是Object，依赖于约定好的类型**强转**，不安全
3.  线程不安全：依赖于setValue()后getValue()，实例是线程不安全的
4.  语义不清晰：从语义上根本不能知道它是用于类型转换的组件
5.  **只能用于String类型**：它只能进行**String <-> 其它类型**的转换，而非更灵活的**Object <-> Object**

PropertyEditor存在这五宗“罪”，让Spring决定自己设计一套全新API用于专门服务于类型转换，这就是本文标题所述：新一代类型转换Converter、ConverterFactory、GenericConverter。

> 关于PropertyEditor在Spring中的详情介绍，请参见文章：[3. 搞定收工，PropertyEditor就到这][Link 1]

## 新一代类型转换 ##

为了解决PropertyEditor作为类型转换方式的设计缺陷，Spring 3.0版本重新设计了一套类型转换接口，有3个核心接口：

1.  `Converter<S, T>`：Source -> Target类型转换接口，适用于1:1转换
2.  `ConverterFactory<S, R>`：Source -> R类型转换接口，适用于1:N转换
3.  `GenericConverter`：更为通用的类型转换接口，适用于N:N转换
    
    1.  注意：就它没有泛型约束，因为是通用

另外，还有一个条件接口`ConditionalConverter`，可跟上面3个接口搭配组合使用，提供前置条件判断验证。

这套接口，解决了PropertyEditor做类型转换存在的**所有缺陷**，且具有非常高的灵活性和可扩展性。下面进入详细了解。

### Converter ###

将源类型S转换为目标类型T。

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

它是个函数式接口，接口定义非常简单。适合1:1转换场景：可以将任意类型 转换为 任意类型。它的实现类非常多，部分截图如下：  
![在这里插入图片描述][20201213211505110.png_pic_center]  
值得注意的是：几乎所有实现类的访问权限都是`default/private`，只有少数几个是public公开的，下面我用代码示例来“近距离”感受一下。

#### 代码示例 ####

/** * Converter：1:1 */
    @Test
    public 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---------------
    true
    true
    false
    false
    null
    ----------------StringToCharsetConverter---------------
    UTF-8
    UTF-8

说明：StringToBooleanConverter/StringToCharsetConverter访问权限都是default，外部不可直接使用。此处为了做示例用到一个小技巧 -> **将Demo的报名调整为和转换器的一样，这样就可以直接访问**。

关注点：true/on/yes/1都能被正确转换为`true`的，且对于英文字母来说一般都不区分大小写，增加了容错性（包括Charset的转换）。

#### 不足 ####

Converter用于解决1:1的任意类型转换，因此它必然存在一个不足：解决1:N转换问题需要写N遍，造成重复冗余代码。

譬如：输入是字符串，它可以转为任意数字类型，包括byte、short、int、long、double等等，如果用Converter来转换的话每个类型都得写个转换器，想想都麻烦有木有。

Spring早早就考虑到了该场景，提供了相应的接口来处理，它就是`ConverterFactory<S, R>`。

### ConverterFactory ###

从名称上看它代表一个转换工厂：可以将对象S转换为R的所有**子类型**，从而形成1:N的关系。

> 该接口描述为xxxFactory是非常合适的，很好的表达了1:N的关系

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

它同样也是个函数式接口。该接口的实现类并不多，Spring Framework共提供了5个内建实现（访问权限全部为default）：  
![在这里插入图片描述][20201213213445555.png_pic_center]  
以StringToNumberConverterFactory为例看看实现的套路：

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作为Converter的工厂，对Converter进行包装，从而达到屏蔽内部实现的目的，对使用者友好，这不正是工厂模式的优点么，符合xxxFactory的语义。但你需要清除的是，工厂内部实现其实也是通过众多if else之类的去完成的，本质上并无差异。

#### 代码示例 ####

/** * ConverterFactory：1:N */
    @Test
    public 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.Integer
    class java.lang.Double
    class java.lang.Byte

关注点：数字类型的字符串，是可以被转换为任意Java中的数字类型的，`String(1) -> Number(N)`。这便就是ConverterFactory的功劳，它能处理这一类转换问题。

#### 不足 ####

既然有了1:1、1:N，自然就有N:N。比如集合转换、数组转换、Map到Map的转换等等，这些N:N的场景，就需要借助下一个接口GenericConverter来实现。

### GenericConverter ###

它是一个**通用的**转换接口，用于在两个或多个类型之间进行转换。相较于前两个，这是**最灵活**的SPI转换器接口，但也是**最复杂**的。

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;
    	}
    }

该接口并非函数式接口，虽然方法不多但稍显复杂。现对出现的几个类型做简单介绍：

*  `ConvertiblePair`：维护sourceType和targetType的POJO
    
     *  getConvertibleTypes()方法返回此Pair的**Set集合**。由此也能看出该转换器是可以支持N:N的（大多数情况下只写一对值而已，也有写多对的）
 *  `TypeDescriptor`：类型描述。该类专用于Spring的类型转换场景，用于描述from or to的类型
    
     *  比单独的Type类型强大，内部借助了ResolvableType来解决泛型议题

GenericConverter的内置实现也比较多，部分截图如下：  
![在这里插入图片描述][20201213224800371.png_pic_center]

> `ConditionalGenericConverter`是GenericConverter和条件接口ConditionalConverter的组合，作用是在执行GenericConverter转换时增加一个**前置条件判断**方法。

<table> 
 <thead> 
  <tr> 
   <th>转换器</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArrayToArrayConverter</td> 
   <td>数组转数组Object[] -&gt; Object[]</td> 
   <td>[“1”,“2”] -&gt; [1,2]</td> 
  </tr> 
  <tr> 
   <td>ArrayToCollectionConverter</td> 
   <td>数组转集合 Object[] -&gt; Collection</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>CollectionToCollectionConverter</td> 
   <td>数组转集合 Collection -&gt; Collection</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>StringToCollectionConverter</td> 
   <td>字符串转集合String -&gt; Collection</td> 
   <td>1,2 -&gt; [1,2]</td> 
  </tr> 
  <tr> 
   <td>StringToArrayConverter</td> 
   <td>字符串转数组String -&gt; Array</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>MapToMapConverter</td> 
   <td>Map -&gt; Map(需特别注意：key和value都支持转换才行)</td> 
   <td>略</td> 
  </tr> 
  <tr> 
   <td>CollectionToStringConverter</td> 
   <td>集合转字符串Collection -&gt; String</td> 
   <td>[1,2] -&gt; 1,2</td> 
  </tr> 
  <tr> 
   <td>ArrayToStringConverter</td> 
   <td>委托给CollectionToStringConverter完成</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td><code>--</code></td> 
   <td><code>--</code></td> 
   <td><code>--</code></td> 
  </tr> 
  <tr> 
   <td><strong>StreamConverter</strong></td> 
   <td>集合/数组 <code>&lt;-&gt;</code> Stream互转</td> 
   <td>集合/数组类型 -&gt; Stream类型</td> 
  </tr> 
  <tr> 
   <td><strong>IdToEntityConverter</strong></td> 
   <td>ID-&gt;Entity的转换</td> 
   <td>传入任意类型ID -&gt; 一个Entity实例</td> 
  </tr> 
  <tr> 
   <td><strong>ObjectToObjectConverter</strong></td> 
   <td>很复杂的对象转换，任意对象之间</td> 
   <td>obj -&gt; obj</td> 
  </tr> 
  <tr> 
   <td><strong>FallbackObjectToStringConverter</strong></td> 
   <td>上个转换器的兜底，调用Obj.toString()转换</td> 
   <td>obj -&gt; String</td> 
  </tr> 
 </tbody> 
</table>

> 说明：分割线下面的4个转换器比较特殊，字面上不好理解其实际作用，比较“高级”。它们如果能被运用在日常工作中可以**事半功弎**，因此放在在下篇文章专门给你介绍

下面以CollectionToCollectionConverter为例分析此转换器的“复杂”之处：

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));
    	}
    }

这是唯一构造器，必须传入ConversionService：元素与元素之间的转换是依赖于conversionService转换服务去完成的，最终完成集合到集合的转换。

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

判断能否转换的依据：集合里的**元素与元素之间**是否能够转换，底层依赖于`ConversionService#canConvert()`这个API去完成判断。

接下来再看**最复杂**的转换方法：

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);
    	}

该转换步骤稍微有点复杂，我帮你屡清楚后有这几个关键步骤：

1.  快速返回：对于特殊情况，做快速返回处理
    
    1.  若目标元素类型是**源**元素类型的子类型（或相同），就没有转换的必要了（copyRequired = false）
    2.  若源集合为空，或者目标集合**没指定泛型**，也不需要做转换动作
        
        1.  源集合为空，还转换个啥
        2.  目标集合没指定泛型，那就是Object，因此可以接纳一切，还转换个啥
2.  若没有触发快速返回。给目标创建一个**新集合**，然后把source的元素**一个一个的**放进新集合里去，这里又分为两种处理case
    
    1.  若新集合（目标集合）没有指定泛型类型（那就是Object），就直接putAll即可，并不需要做类型转换
    2.  若新集合（目标集合指定了泛型类型），就**遍历**源集合委托`conversionService.convert()`对元素一个一个的转

#### 代码示例 ####

以CollectionToCollectionConverter做示范：`List<String> -> Set<Integer>`

@Test
    public 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]
    true
    class java.util.LinkedHashSet
    [1, 2, 3, 4]

关注点：target最终使用的是LinkedHashSet来存储，这结果和`CollectionFactory#createCollection`该API的实现逻辑是相关（Set类型默认创建的是LinkedHashSet实例）。

#### 不足 ####

如果说它的优点是功能强大，能够处理复杂类型的转换（PropertyEditor和前2个接口都只能转换**单元素**类型），那么缺点就是使用、自定义实现起来比较复杂。这不**官方**也给出了使用指导意见：在Converter/ConverterFactory接口能够满足条件的情况下，可不使用此接口就不使用。

### ConditionalConverter ###

条件接口，@since 3.2。它可以为Converter、GenericConverter、ConverterFactory转换增加一个**前置判断条件**。

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

该接口的实现，截图如下：  
![在这里插入图片描述][20201214075212339.png_pic_center]  
可以看到，只有通用转换器GenericConverter和它进行了**合体**。这也很容易理解，作为通用的转换器，加个前置判断将更加严谨和更安全。对于专用的转换器如Converter，它已明确规定了转换的类型，自然就不需要做前置判断喽。

# ✍总结 #

本文详细介绍了Spring新一代的类型转换接口，类型转换作为Spring的基石，其重要性可见一斑。

PropertyEditor作为Spring早期使用“转换器”，因存在众多设计缺陷自Spring 3.0起被新一代转换接口所取代，主要有：

1.  `Converter<S, T>`：Source -> Target类型转换接口，适用于1:1转换
2.  `ConverterFactory<S, R>`：Source -> R类型转换接口，适用于1:N转换
3.  `GenericConverter`：更为通用的类型转换接口，适用于N:N转换

下篇文章将针对于GenericConverter的几个特殊实现撰专文为你讲解，你也知道做难事必有所得，做难事才有可能破局、破圈，欢迎保持关注。

--------------------

### ✔✔✔推荐阅读✔✔✔ ###

【Spring类型转换】系列：

*  [1. 揭秘Spring类型转换 - 框架设计的基石][1. _Spring_ -]
 *  [2. Spring早期类型转换，基于PropertyEditor实现][2. Spring_PropertyEditor]
 *  [3. 搞定收工，PropertyEditor就到这][Link 1]

【Jackson】系列：

*  [1. 初识Jackson – 世界上最好的JSON库][1. _Jackson _ _JSON]
 *  [2. 妈呀，Jackson原来是这样写JSON的][2. _Jackson_JSON]
 *  [3. 懂了这些，方敢在简历上说会用Jackson写JSON][3. _Jackson_JSON]
 *  [4. JSON字符串是如何被解析的？JsonParser了解一下][4. JSON_JsonParser]
 *  [5. JsonFactory工厂而已，还蛮有料，这是我没想到的][5. JsonFactory]
 *  [6. 二十不惑，ObjectMapper使用也不再迷惑][6. _ObjectMapper]
 *  [7. Jackson用树模型处理JSON是必备技能，不信你看][7. Jackson_JSON]

【数据校验Bean Validation】系列：

*  [1. 不吹不擂，第一篇就能提升你对Bean Validation数据校验的认知][1. _Bean Validation]
 *  [2. Bean Validation声明式校验方法的参数、返回值][2. Bean Validation]
 *  [3. 站在使用层面，Bean Validation这些标准接口你需要烂熟于胸][3. _Bean Validation]
 *  [4. Validator校验器的五大核心组件，一个都不能少][4. Validator]
 *  [5. Bean Validation声明式验证四大级别：字段、属性、容器元素、类][5. Bean Validation]
 *  [6. 自定义容器类型元素验证，类级别验证（多字段联合验证）][6.]

【新特性】系列：

*  [IntelliJ IDEA 2020.3正式发布，年度最后一个版本很讲武德][IntelliJ IDEA 2020.3]
 *  [IntelliJ IDEA 2020.2正式发布，诸多亮点总有几款能助你提效][IntelliJ IDEA 2020.2]
 *  IntelliJ IDEA 2020.1正式发布，你要的Almost都在这！
 *  [Spring Framework 5.3.0正式发布，在云原生路上继续发力][Spring Framework 5.3.0]
 *  [Spring Boot 2.4.0正式发布，全新的配置文件加载机制（不向下兼容）][Spring Boot 2.4.0]
 *  [Spring改变版本号命名规则：此举对非英语国家很友好][Spring]
 *  [JDK15正式发布，划时代的ZGC同时宣布转正][JDK15_ZGC]

【程序人生】系列：

*  [蚂蚁金服上市了，我不想努力了][Link 2]
 *  [如果程序员和产品经理都用凡尔赛文学对话…][Link 3]
 *  [程序人生 | 春风得意马蹄疾，一日看尽长安花][Link 4]

还有诸如【Spring配置类】【Spring-static】【Spring数据绑定】【Spring Cloud Netflix】【Feign】【Ribbon】【Hystrix】…更多原创专栏，关注`BAT的乌托邦`回复`专栏`二字即可全部获取，分享、成长，拒绝浅藏辄止。

> 有些专栏**已完结**，有些正在**连载中**，期待你的关注、共同进步

--------------------

# ♥关注A哥♥ #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx1056342982</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

[2020121707475621.png_pic_center]: /images/20221120/2b100f81412640608da8a8bd33837b04.png
[https_www.yourbatman.cn]: https://www.yourbatman.cn
[Link 1]: https://mp.weixin.qq.com/s/--UO3pH1nxTW3f5nQvEnkg
[20201217074252478.png_pic_center]: https://img-blog.csdnimg.cn/20201217074252478.png#pic_center
[20201213211505110.png_pic_center]: https://img-blog.csdnimg.cn/20201213211505110.png#pic_center
[20201213213445555.png_pic_center]: https://img-blog.csdnimg.cn/20201213213445555.png#pic_center
[20201213224800371.png_pic_center]: https://img-blog.csdnimg.cn/20201213224800371.png#pic_center
[20201214075212339.png_pic_center]: https://img-blog.csdnimg.cn/20201214075212339.png#pic_center
[1. _Spring_ -]: https://mp.weixin.qq.com/s/5daOOdhIFqrGbpgtnuQMNw
[2. Spring_PropertyEditor]: https://mp.weixin.qq.com/s/Afu8YYyREoynAXS6YrJe7g
[1. _Jackson _ _JSON]: https://mp.weixin.qq.com/s/iqSN4HUoIdX0kGcSdnD7EA
[2. _Jackson_JSON]: https://mp.weixin.qq.com/s/p6cwP2BVrC8VxkN-T3uAxg
[3. _Jackson_JSON]: https://mp.weixin.qq.com/s/ZHb3P06IC4xElHwJqDepxw
[4. JSON_JsonParser]: https://mp.weixin.qq.com/s/syAOETfEawiGItaQO35mLA
[5. JsonFactory]: https://mp.weixin.qq.com/s/0ZaDYb_ueFLbvOf3FbetfQ
[6. _ObjectMapper]: https://mp.weixin.qq.com/s/VYy1QVeFLRkciymFHueb5w
[7. Jackson_JSON]: https://mp.weixin.qq.com/s/hPRdt-6sHt4rZaW2_jhdWQ
[1. _Bean Validation]: https://mp.weixin.qq.com/s/g04HMhrjbvbPn1Mb9JYa5g
[2. Bean Validation]: https://mp.weixin.qq.com/s/-KeOCq2rsXCvrqD8HYHSpQ
[3. _Bean Validation]: https://mp.weixin.qq.com/s/MQjXG0cg8domRtwf3ArvHw
[4. Validator]: https://mp.weixin.qq.com/s/jzOv67ZTSx2rByj0aeUTgw
[5. Bean Validation]: https://mp.weixin.qq.com/s/6_7gZ9jmQcDSRiARO6D-yw
[6.]: https://mp.weixin.qq.com/s/MN-_JCGnsEWpPJs9xQ_qZA
[IntelliJ IDEA 2020.3]: https://mp.weixin.qq.com/s/vNnfKEGRm7R3PN_lCtXJDA
[IntelliJ IDEA 2020.2]: https://mp.weixin.qq.com/s/8voJSbmcBbdfNUCUBIcKcA
[Spring Framework 5.3.0]: https://mp.weixin.qq.com/s/Sw6EqAY0DmF-p2qPoaetUg
[Spring Boot 2.4.0]: https://mp.weixin.qq.com/s/KywpJkLDHZbZTxUf4WFxhw
[Spring]: https://mp.weixin.qq.com/s/ZoUG9h1TndW2QpnPyGeIQA
[JDK15_ZGC]: https://mp.weixin.qq.com/s/3QaiUGzj5nW2N4Aipm47PQ
[Link 2]: https://mp.weixin.qq.com/s/oEShE0fiHSGG8D89NRQYGw
[Link 3]: https://mp.weixin.qq.com/s/SZUJ0sy4vM7UH10pk6NM3g
[Link 4]: https://mp.weixin.qq.com/s/PGIFtpI7aZaxY7es0F6C6Q
[BAT]: https://img-blog.csdnimg.cn/20200710160552549.gif