分享、成长,拒绝浅藏辄止。关注公众号【
BAT的乌托邦】,回复关键字
专栏
有Spring技术栈、中间件等小而美的
原创专栏供以免费学习。本文已被
https://www.yourbatman.cn 收录。
✍前言
你好,我是YourBatman。
上篇文章 大篇幅把Spring全新一代类型转换器介绍完了,已经至少能够考个及格分。在介绍Spring众多内建的转换器里,我故意留下一个尾巴,放在本文专门撰文讲解。
为了让自己能在“拥挤的人潮中”显得不(更)一(突)样(出),A哥特意准备了这几个特殊的转换器助你破局,穿越拥挤的人潮,踏上Spring已为你制作好的高级赛道。
版本约定
- Spring Framework:5.3.1
- Spring Boot:2.4.0
✍正文
本文的焦点将集中在上文留下的4个类型转换器上。
- StreamConverter:将Stream流与集合/数组之间的转换,必要时转换元素类型
这三个比较特殊,属于“最后的”“兜底类”类型转换器:
- ObjectToObjectConverter:通用的将原对象转换为目标对象(通过工厂方法or构造器)
IdToEntityConverter
:本文重点。给个ID自动帮你兑换成一个Entity对象- FallbackObjectToStringConverter:将任何对象调用
toString()
转化为String类型。当匹配不到任何转换器时,它用于兜底
默认转换器注册情况
Spring新一代类型转换内建了非常多的实现,这些在初始化阶段大都被默认注册进去。注册点在DefaultConversionService
提供的一个static静态工具方法里:
static静态方法具有与 实例无关性,我个人觉得把该static方法放在一个xxxUtils里统一管理会更好,放在具体某个组件类里反倒容易产生语义上的误导性
DefaultConversionService:
public static void addDefaultConverters(ConverterRegistry converterRegistry) {
// 1、添加标量转换器(和数字相关)
addScalarConverters(converterRegistry);
// 2、添加处理集合的转换器
addCollectionConverters(converterRegistry);
// 3、添加对JSR310时间类型支持的转换器
converterRegistry.addConverter(new ByteBufferConverter((ConversionService) converterRegistry));
converterRegistry.addConverter(new StringToTimeZoneConverter());
converterRegistry.addConverter(new ZoneIdToTimeZoneConverter());
converterRegistry.addConverter(new ZonedDateTimeToCalendarConverter());
// 4、添加兜底转换器(上面处理不了的全交给这几个哥们处理)
converterRegistry.addConverter(new ObjectToObjectConverter());
converterRegistry.addConverter(new IdToEntityConverter((ConversionService) converterRegistry));
converterRegistry.addConverter(new FallbackObjectToStringConverter());
converterRegistry.addConverter(new ObjectToOptionalConverter((ConversionService) converterRegistry));
}
}
该静态方法用于注册全局的、默认的转换器们,从而让Spring有了基础的转换能力,进而完成绝大部分转换工作。为了方便记忆这个注册流程,我把它绘制成图供以你保存:
特别强调:转换器的注册顺序非常重要,这决定了通用转换器的匹配结果(谁在前,优先匹配谁)。
针对这幅图,你可能还会有疑问:
JSR310转换器只看到TimeZone、ZoneId等转换,怎么没看见更为常用的LocalDate、LocalDateTime等这些类型转换呢?难道Spring默认是不支持的?
- 答:当然不是。 这么常见的场景Spring怎能会不支持呢?不过与其说这是类型转换,倒不如说是格式化更合适。所以会在后3篇文章格式化章节在作为重中之重讲述
一般的Converter都见名之意,但StreamConverter有何作用呢?什么场景下会生效
- 答:本文讲述
对于兜底的转换器,有何含义?这种极具通用性的转换器作用为何
- 答:本文讲述
StreamConverter
用于实现集合/数组类型到Stream类型的互转,这从它支持的Set
集合也能看出来:
@Override
public Set getConvertibleTypes() {
Set convertiblePairs = new HashSet();
convertiblePairs.add(new ConvertiblePair(Stream.class, Collection.class));
convertiblePairs.add(new ConvertiblePair(Stream.class, Object[].class));
convertiblePairs.add(new ConvertiblePair(Collection.class, Stream.class));
convertiblePairs.add(new ConvertiblePair(Object[].class, Stream.class));
return convertiblePairs;
}
它支持的是双向的匹配规则:
代码示例
/**
* {@link StreamConverter}
*/
@Test
public void test2() {
System.out.println("----------------StreamConverter---------------");
ConditionalGenericConverter converter = new StreamConverter(new DefaultConversionService());
TypeDescriptor sourceTypeDesp = TypeDescriptor.valueOf(Set.class);
TypeDescriptor targetTypeDesp = TypeDescriptor.valueOf(Stream.class);
boolean matches = converter.matches(sourceTypeDesp, targetTypeDesp);
System.out.println("是否能够转换:" + matches);
// 执行转换
Object convert = converter.convert(Collections.singleton(1), sourceTypeDesp, targetTypeDesp);
System.out.println(convert);
System.out.println(Stream.class.isAssignableFrom(convert.getClass()));
}
运行程序,输出:
----------------StreamConverter---------------
是否能够转换:true
java.util.stream.ReferencePipeline$Head@5a01ccaa
true
关注点:底层依旧依赖DefaultConversionService
完成元素与元素之间的转换。譬如本例Set -> Stream的实际步骤为:
也就是说任何集合/数组类型是先转换为中间状态的List,最终调用list.stream()
转换为Stream流的;若是逆向转换先调用source.collect(Collectors.
把Stream转为List后,再转为具体的集合or数组类型。
说明:若source是数组类型,那底层实际使用的就是ArrayToCollectionConverter,注意举一反三
使用场景
StreamConverter它的访问权限是default,我们并不能直接使用到它。通过上面介绍可知Spring默认把它注册进了注册中心里,因此面向使用者我们直接使用转换服务接口ConversionService便可。
@Test
public void test3() {
System.out.println("----------------StreamConverter使用场景---------------");
ConversionService conversionService = new DefaultConversionService();
Stream result = conversionService.convert(Collections.singleton(1), Stream.class);
// 消费
result.forEach(System.out::println);
// result.forEach(System.out::println); //stream has already been operated upon or closed
}
运行程序,输出:
----------------StreamConverter使用场景---------------
1
再次特别强调:流只能被读(消费)一次。
因为有了ConversionService
提供的强大能力,我们就可以在基于Spring/Spring Boot做二次开发时使用它,提高系统的通用性和容错性。如:当方法入参是Stream类型时,你既可以传入Stream类型,也可以是Collection类型、数组类型,是不是瞬间逼格高了起来。
兜底转换器
按照添加转换器的顺序,Spring在最后添加了4个通用的转换器用于兜底,你可能平时并不关注它,但它实时就在发挥着它的作用。
ObjectToObjectConverter
将源对象转换为目标类型,非常的通用:Object -> Object:
@Override
public Set getConvertibleTypes() {
return Collections.singleton(new ConvertiblePair(Object.class, Object.class));
}
虽然它支持的是Object -> Object,看似没有限制但其实是有约定条件的:
@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
return (sourceType.getType() != targetType.getType() &&
hasConversionMethodOrConstructor(targetType.getType(), sourceType.getType()));
}
是否能够处理的判断逻辑在于hasConversionMethodOrConstructor
方法,直译为:是否有转换方法或者构造器。代码详细处理逻辑如下截图:
此部分逻辑可分为两个part来看:
- part1:从缓存中拿到Member,直接判断Member的可用性,可用的话迅速返回
- part2:若part1没有返回,就执行三部曲,尝试找到一个合适的Member,然后放进缓存内(若没有就返回null)
part1:快速返回流程
当不是首次进入处理时,会走快速返回流程。也就是第0步isApplicable
判断逻辑,有这几个关注点:
- Member包括Method或者Constructor
- Method:若是static静态方法,要求方法的第1个入参类型必须是源类型sourceType;若不是static方法,则要求源类型sourceType必须是
method.getDeclaringClass()
的子类型/相同类型 - Constructor:要求构造器的第1个入参类型必须是源类型sourceType
创建目标对象的实例,此转换器支持两种方式:
- 通过工厂方法/实例方法创建实例(
method.invoke(source)
) - 通过构造器创建实例(
ctor.newInstance(source)
)
以上case,在下面均会给出代码示例。
part2:三部曲流程
对于首次处理的转换,就会进入到详细的三部曲逻辑:通过反射尝试找到合适的Member用于创建目标实例,也就是上图的1、2、3步。
step1:determineToMethod,从sourceClass
里找实例方法,对方法有如下要求:
- 方法名必须叫
"to" + targetClass.getSimpleName()
,如toPerson()
- 方法的访问权限必须是public
- 该方法的返回值必须是目标类型或其子类型
step2:determineFactoryMethod,找静态工厂方法,对方法有如下要求:
- 方法名必须为
valueOf(sourceClass)
或者of(sourceClass)
或者from(sourceClass)
- 方法的访问权限必须是public
step3:determineFactoryConstructor,找构造器,对构造器有如下要求:
- 存在一个参数,且参数类型是sourceClass类型的构造器
- 构造器的访问权限必须是public
特别值得注意的是:此转换器不支持Object.toString()方法将sourceType转换为java.lang.String。对于toString()支持,请使用下面介绍的更为兜底的FallbackObjectToStringConverter
。
代码示例
- 实例方法
// sourceClass
@Data
public class Customer {
private Long id;
private String address;
public Person toPerson() {
Person person = new Person();
person.setId(getId());
person.setName("YourBatman-".concat(getAddress()));
return person;
}
}
// tartgetClass
@Data
public class Person {
private Long id;
private String name;
}
书写测试用例:
@Test
public void test4() {
System.out.println("----------------ObjectToObjectConverter---------------");
ConditionalGenericConverter converter = new ObjectToObjectConverter();
Customer customer = new Customer();
customer.setId(1L);
customer.setAddress("Peking");
Object convert = converter.convert(customer, TypeDescriptor.forObject(customer), TypeDescriptor.valueOf(Person.class));
System.out.println(convert);
// ConversionService方式(实际使用方式)
ConversionService conversionService = new DefaultConversionService();
Person person = conversionService.convert(customer, Person.class);
System.out.println(person);
}
运行程序,输出:
----------------ObjectToObjectConverter---------------
Person(id=1, name=YourBatman-Peking)
Person(id=1, name=YourBatman-Peking)
- 静态工厂方法
// sourceClass
@Data
public class Customer {
private Long id;
private String address;
}
// targetClass
@Data
public class Person {
private Long id;
private String name;
/**
* 方法名称可以是:valueOf、of、from
*/
public static Person valueOf(Customer customer) {
Person person = new Person();
person.setId(customer.getId());
person.setName("YourBatman-".concat(customer.getAddress()));
return person;
}
}
测试用例完全同上,再次运行输出:
----------------ObjectToObjectConverter---------------
Person(id=1, name=YourBatman-Peking)
Person(id=1, name=YourBatman-Peking)
方法名可以为valueOf、of、from
任意一种,这种命名方式几乎是业界不成文的规矩,所以遵守起来也会比较容易。但是:建议还是注释写好,防止别人重命名而导致转换生效。
- 构造器
基本同静态工厂方法示例,略
使用场景
基于本转换器可以完成任意对象 -> 任意对象的转换,只需要遵循方法名/构造器默认的一切约定即可,在我们平时开发书写转换层时是非常有帮助的,借助ConversionService
可以解决这一类问题。
对于Object -> Object的转换,另外一种方式是自定义
Converter
,然后注册到注册中心。至于到底选哪种合适,这就看具体应用场景喽,本文只是多给你一种选择
IdToEntityConverter
Id(S) --> Entity(T)。通过调用静态查找方法将实体ID兑换为实体对象。Entity里的该查找方法需要满足如下条件find[EntityName]([IdType])
:
- 必须是static静态方法
- 方法名必须为
find + entityName
。如Person类的话,那么方法名叫findPerson
- 方法参数列表必须为1个
- 返回值类型必须是Entity类型
说明:此方法可以不必是public,但建议用public。这样即使JVM的Security安全级别开启也能够正常访问
支持的转换Pair如下:ID和Entity都可以是任意类型,能转换就成
@Override
public Set getConvertibleTypes() {
return Collections.singleton(new ConvertiblePair(Object.class, Object.class));
}
判断是否能执行准换的条件是:存在符合条件的find方法,且source可以转换为ID类型(注意source能转换成id类型就成,并非目标类型哦)
@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
Method finder = getFinder(targetType.getType());
return (finder != null
&& this.conversionService.canConvert(sourceType, TypeDescriptor.valueOf(finder.getParameterTypes()[0])));
}
根据ID定位到Entity实体对象简直太太太常用了,运用好此转换器的提供的能力,或许能让你事半功倍,大大减少重复代码,写出更优雅、更简洁、更易于维护的代码。
代码示例
Entity实体:准备好符合条件的findXXX方法
@Data
public class Person {
private Long id;
private String name;
/**
* 根据ID定位一个Person实例
*/
public static Person findPerson(Long id) {
// 一般根据id从数据库查,本处通过new来模拟
Person person = new Person();
person.setId(id);
person.setName("YourBatman-byFindPerson");
return person;
}
}
应用IdToEntityConverter,书写示例代码:
@Test
public void test() {
System.out.println("----------------IdToEntityConverter---------------");
ConditionalGenericConverter converter = new IdToEntityConverter(new DefaultConversionService());
TypeDescriptor sourceTypeDesp = TypeDescriptor.valueOf(String.class);
TypeDescriptor targetTypeDesp = TypeDescriptor.valueOf(Person.class);
boolean matches = converter.matches(sourceTypeDesp, targetTypeDesp);
System.out.println("是否能够转换:" + matches);
// 执行转换
Object convert = converter.convert("1", sourceTypeDesp, targetTypeDesp);
System.out.println(convert);
}
运行程序,正常输出:
----------------IdToEntityConverter---------------
是否能够转换:true
Person(id=1, name=YourBatman-byFindPerson)
示例效果为:传入字符串类型的“1”,就能返回得到一个Person实例。可以看到,我们传入的是字符串类型的的1,而方法入参id类型实际为Long类型,但因为它们能完成String -> Long转换,因此最终还是能够得到一个Entity实例的。
使用场景
这个使用场景就比较多了,需要使用到findById()
的地方都可以通过它来代替掉。如:
Controller层:
@GetMapping("/ids/{id}")
public Object getById(@PathVariable Person id) {
return id;
}
@GetMapping("/ids")
public Object getById(@RequestParam Person id) {
return id;
}
Tips:在Controller层这么写我并不建议,因为语义上没有对齐,势必在代码书写过程中带来一定的麻烦。
Service层:
@Autowired
private ConversionService conversionService;
public Object findById(String id){
Person person = conversionService.convert(id, Person.class);
return person;
}
Tips:在Service层这么写,我个人觉得还是OK的。用类型转换的领域设计思想代替了自上而下的过程编程思想。
FallbackObjectToStringConverter
通过简单的调用Object#toString()
方法将任何支持的类型转换为String类型,它作为底层兜底。
@Override
public Set getConvertibleTypes() {
return Collections.singleton(new ConvertiblePair(Object.class, String.class));
}
该转换器支持CharSequence/StringWriter等类型,以及所有ObjectToObjectConverter.hasConversionMethodOrConstructor(sourceClass, String.class)
的类型。
说明:ObjectToObjectConverter不处理任何String类型的转换,原来都是交给它了
代码示例
略。
ObjectToOptionalConverter
将任意类型转换为一个Optional
类型,它作为最最最最最底部的兜底,稍微了解下即可。
代码示例
@Test
public void test5() {
System.out.println("----------------ObjectToOptionalConverter---------------");
ConversionService conversionService = new DefaultConversionService();
Optional result = conversionService.convert(Arrays.asList(2), Optional.class);
System.out.println(result);
}
运行程序,输出:
----------------ObjectToOptionalConverter---------------
Optional[[2]]
使用场景
一个典型的应用场景:在Controller中可传可不传的参数中,我们不仅可以通过@RequestParam(required = false) Long id
来做,还是可以这么写:@RequestParam Optional
。
✍总结
本文是对上文介绍Spring全新一代类型转换机制的补充,因为关注得人较少,所以才有机会突破。
针对于Spring注册转换器,需要特别注意如下几点:
- 注册顺序很重要。先注册,先服务(若支持的话)
默认情况下,Spring会注册大量的内建转换器,从而支持String/数字类型转换、集合类型转换,这能解决协议层面的大部分转换问题。
- 如Controller层,输入的是JSON字符串,可用自动被封装为数字类型、集合类型等等
- 如@Value注入的是String类型,但也可以用数字、集合类型接收
对于复杂的对象 -> 对象类型的转换,一般需要你自定义转换器,或者参照本文的标准写法完成转换。总之:Spring提供的ConversionService
专注于类型转换服务,是一个非常非常实用的API,特别是你正在做基于Spring二次开发的情况下。
当然喽,关于ConversionService
这套机制还并未详细介绍,如何使用?如何运行?如何扩展?带着这三个问题,咱们下篇见。
✔✔✔推荐阅读✔✔✔
【Spring类型转换】系列:
- 1. 揭秘Spring类型转换 - 框架设计的基石
- 2. Spring早期类型转换,基于PropertyEditor实现
- 3. 搞定收工,PropertyEditor就到这
- 4. 上新了Spring,全新一代类型转换机制
【Jackson】系列:
- 1. 初识Jackson -- 世界上最好的JSON库
- 2. 妈呀,Jackson原来是这样写JSON的
- 3. 懂了这些,方敢在简历上说会用Jackson写JSON
- 4. JSON字符串是如何被解析的?JsonParser了解一下
- 5. JsonFactory工厂而已,还蛮有料,这是我没想到的
- 6. 二十不惑,ObjectMapper使用也不再迷惑
- 7. Jackson用树模型处理JSON是必备技能,不信你看
【数据校验Bean Validation】系列:
- 1. 不吹不擂,第一篇就能提升你对Bean Validation数据校验的认知
- 2. Bean Validation声明式校验方法的参数、返回值
- 3. 站在使用层面,Bean Validation这些标准接口你需要烂熟于胸
- 4. Validator校验器的五大核心组件,一个都不能少
- 5. Bean Validation声明式验证四大级别:字段、属性、容器元素、类
- 6. 自定义容器类型元素验证,类级别验证(多字段联合验证)
【新特性】系列:
- IntelliJ IDEA 2020.3正式发布,年度最后一个版本很讲武德
- IntelliJ IDEA 2020.2正式发布,诸多亮点总有几款能助你提效
- [IntelliJ IDEA 2020.1正式发布,你要的Almost都在这!]()
- Spring Framework 5.3.0正式发布,在云原生路上继续发力
- Spring Boot 2.4.0正式发布,全新的配置文件加载机制(不向下兼容)
- Spring改变版本号命名规则:此举对非英语国家很友好
- JDK15正式发布,划时代的ZGC同时宣布转正
【程序人生】系列:
还有诸如【Spring配置类】【Spring-static】【Spring数据绑定】【Spring Cloud Netflix】【Feign】【Ribbon】【Hystrix】...更多原创专栏,关注BAT的乌托邦
回复专栏
二字即可全部获取,也可加我fsx1056342982
,交个朋友。
有些 已完结,有些 连载中。我是A哥(YourBatman),咱们下期再见