Spring的@Value注入复杂类型(通过@value注入自定义类型)

之前写了一篇关于spring的@value注入的文章《介绍两种springboot读取yml文件中配置数组的方法》。

里面列出了@value和@configurationproperties的对比，其中有一条是写的@value不支持复杂类型封装（数组、map、对象等）。

但是后来有小伙伴留言说他用@value测试的时候，是可以注入的数组和集合的。于是我就跟着做了一些测试，发现确实可以。但是只有在以，分割的字符串的时候才可以。

为什么用，分割的字符串可以注入数组？于是我就去一步一步的断点去走了一遍@value注入属性的过程，才发现了根本原因。

@value不支持复杂类型封装（数组、map、对象等）这个说法确实是有问题的，不够严谨，因为在特殊情况下，是可以注入复杂类型的。

先来梳理一下@value对属性的注入流程

先交代一下我们的代码：

一个yml文件a.yml

test: a,b,c,d

一个bean a.java

@component@propertysource(value = {"classpath:a.yml"},ignoreresourcenotfound = true, encoding = "utf-8")public class a {@value("${test}")private string[] test;public void test(){system.out.println("test:"+arrays.tostring(test));system.out.println("长度："+test.length);}}

main方法：

@configuration@componentscan("com.kinyang")public class helloapp {public static void main(string[] args) {annotationconfigapplicationcontext ac = new annotationconfigapplicationcontext(helloapp.class);a bean = ac.getbean(a.class);bean.test();}}

ok！下面开始分析

1、从autowiredannotationbeanpostprocessor后置处理说起

过多的spring初始化bean的流程就不说了，我们直接定位到bean的属性注入的后置处理器autowiredannotationbeanpostprocessor。

此类中的processinjection（）方法中完成了bean 中@autowired、@inject、 @value 注解的解析并注入的功能。

 此方法中完成了bean 中@autowired、@inject、 @value 注解的解析并注入的功能public void processinjection(object bean) throws beancreationexception {class<?> clazz = bean.getclass();///  找到 类上所有的需要自动注入的元素// （把@autowired、@inject、 @value注解的字段和方法包装成injectionmetadata类的对象返回）injectionmetadata metadata = findautowiringmetadata(clazz.getname(), clazz, null);try {metadata.inject(bean, null, null);}catch (beancreationexception ex) {throw ex;}catch (throwable ex) {throw new beancreationexception("injection of autowired dependencies failed for class [" + clazz + "]", ex);}}

2、接着进入injectionmetadata的inject()方法

inject（）方法就是一个循环上面一步解析出来的注解信息，注解的方法或者字段包装后的对象是injectedelement类型的类，injectedelement是一个抽象类，他的实现主要有两个：对注解字段生成的是autowiredfieldelement类，对注解方法生成的是autowiredmethodelement类。

我们这里只分析@value注解字段的注入流程，所以下一步会进到autowiredfieldelement类的inject()方法.

此方法就两大步骤：

获取要注入的value通过反射，把值去t字段上

其中获取要注入的value过程比较复杂，第二步t值就两行代码搞定

具体逻辑看下面代码上我写的注释

protected void inject(object bean, @nullable string beanname, @nullable propertyvalues pvs) throws throwable {field field = (field) this.member;object value;if (this.cached) {/// 优先从缓存中获取value = resolvedcachedargument(beanname, this.cachedfieldvalue);}el {///缓存中没有的话，走下面的逻辑处理dependencydescriptor desc = new dependencydescriptor(field, this.required);desc.tcontainingclass(bean.getclass());t<string> autowiredbeannames = new linkedhasht<>(1);asrt.state(beanfactory != null, "no beanfactory available");  这个对我们今天讨论的问题很关键  获取一个 类型转换器typeconverter typeconverter = beanfactory.gettypeconverter();try {///   获取值（重点，这里把一个typeconverter传进去了）value = beanfactory.resolvedependency(desc, beanname, autowiredbeannames, typeconverter);///  经过上面的方法返回来的 value 就是要注入的值了///  通过断点调试，我们可以发现我们在配置文件yml中配置的 “a,b,c,d”字符串已经变成了一个string[]数组}catch (beanxception ex) {throw new unsatisfieddependencyexception(null, beanname, new injectionpoint(field), ex);}synchronized (this) {..... 这里不是我们本次讨论的重点所以就去掉了}}if (value != null) { 这里就是第二步，赋值reflectionutils.makeaccessible(field);field.t(bean, value);}}}

从上面代码来看，所有重点就都落到了这行代码

value = beanfactory.resolv创业时代 演员表edependency(desc, beanname, autowiredbeannames, typeconverter);

推断下来resolvedependency方法里应该是读取配置文件字符串，然后将字符串用，分割转换了数组。

那么具体怎么转换的呢？我们继续跟进！

进入resolvedependency（）方法，里面逻辑很简单做了一些判断，真正实现其实是doresolvedependency（）方法，进行跟进。

根据@value注解，从配置文件a.yml中解析出配置的内容：“a,b,c,d”

到这里我们得到值还是配置文件配置的字符串，并没有变成我们想要的string[]字符串数组类型。

我们继续往下走，下面是获取一个typeconverter类型转换器，这里的类型转换器是上面传进来的，具体类型simpletypeconverter类。

然后通过这个类型转换器的convertifnecessary方法把，我们的字符串”a,b,c,d”转换成了string[]数组。

所以我们现在知道了，我们从配置文件获取到的值，通过了spring转换器，调用了convertifnecessary方法后，进行了类型自动转换。那么这转换器到底是怎么进行工作的呢？

继续研究~~

那接下来要研究的就是spring的typeconverter的工作原理问题了

首先我们这里知道了外面传进来的那个转换器是一个叫simpletypeconverter 的转换器。

这转换器是org.springframework.beans.factory.support.abstractbeanfactory#gettypeconverter方法得到的

@overridepublic typeconverter gettypeconverter() {typeconverter customconverter = getcustomtypeconverter();if (customconverter != null) {return customconverter;}el {/// 如果没有 用户自定的typeconverter 那就用 默认的simpletypeconverter吧// build default typeconverter, registering custom editors.simpletypeconverter typeconverter = new simpletypeconverter(); 注册一些默认的conversionrvicetypeconverter.tconversionrvice(getconversionrvice());  再注册一些默认的customeditorsregistercustomeditors(typeconverter);return typeconverter;}}

默认的simpletypeconverter里面注册了一些转换器，从debug过程我们可以看到默认是注入了12个propertyeditor

这12个propertyeditor是在哪注入的呢？大家可以看registercustomeditors(typeconverter)方法，这里就不展开了，我直接说了，是通过resourceeditorregistrar类注入进去的。

@overridepublic void registercustomeditors(propertyeditorregistry registry) {resourceeditor baeditor = new resourceeditor(this.resourceloader, this.propertyresolver);doregistereditor(registry, resource.class, baeditor);doregistereditor(registry, contextresource.class, baeditor);doregistereditor(registry, inputstream.class, new inputstreameditor(baeditor));doregistereditor(registry, inputsource.class, new inputsourceeditor(baeditor));doregistereditor(registry, file.class, new fileeditor(baeditor));doregistereditor(registry, path.class, new patheditor(baeditor));doregistereditor(registry, reader.class, new readereditor(baeditor));doregistereditor(registry, url.class, new urleditor(baeditor));classloader classloader = this.resourceloader.getclassloader();doregistereditor(registry, uri.class, new urieditor(classloader));doregistereditor(registry, class.class, new clasditor(classloader));doregistereditor(registry, class[].class, new classarrayeditor(classloader));if (this.resourceloader instanceof resourcepatternresolver) {doregistereditor(registry, resource[].class,new resourcearraypropertyeditor((resourcepatternresolver) this.resourceloader, this.propertyresolver));}}

现在我们回到 simpletypeconverter 的convertifnecessary方法里去，这个方法其实是simpletypeconverter的父类typeconvertersupport的方法，而这个父类方法里调用的又是typeconverterdelegate类的convertifnecessary方法（一个比一个懒，哈哈哈就是自己不干活）

最后我们重点来分析typeconverterdelegate的convertifnecessary方法。

这个方法内容比较多，但是整体思路就是 根据最后想转换的类型，选择出对应的propertyeditor或者conversionrvice，然后进行类型转换。

从上面的看的注入的12个propertyeditor中，我们就可以看出来了，我们匹配到的是

这行代码doregistereditor(registry, class[].class, ne英文道歉信w classarrayeditor(classloader));注入的classarrayeditor。

所以我classarrayeditor这个类就可以了，这个类就很简单了，主要看tastext方法

public void tastext(string text) throws illegalargumentexception {if (stringutils.hastext(text)) {///  这里通过stringutils 把字符串，转换成 string数组string[] classnames = stringutils.commadelimitedlisttostringarray(text);class<?>[] class = new class<?>[classnames.length];for (int i = 0; i < classnames.length; i++) {string classname = classnames[i].trim();class[i] = classutils.resolveclassname(classname, this.classloader);}tvalue(class);}el {tvalue(null);}}

这个方法里通过

spring的字符串工具类stringutils的commadelimitedlisttostringarray(text)方法把字符串转换成了数组，方法里就是通过 “,” 进行分割的。

到此为止，我们知道了@value为什么可以把“,”分割的字符串注册到数组中了吧。

其实@value可以注入uri、class、file、resource等等类型，@value可以注入什么类型完全取决于能不能找到处理 string 到 注入类型的转换器。

上面列出来的12个其实不是全部默认的，系统还有47个其他的转换器，只不过是上面的12个优先级比较高而已，其实还有下面的40多个转换器，所以你看@value可以注入的类型还会很多的。

private void createdefaulteditors() {this.defaulteditors = new hashmap<>(64);// simple editors, without parameterization capabilities.// the jdk does not contain a default editor for any of the target types.this.defaulteditors.put(chart.class, new charteditor());this.defaulteditors.put(class.class, new clasditor());this.defaulteditors.put(class[].class, new classarrayeditor());this.defaulteditors.put(currency.class, new currencyeditor());this.defaulteditors.put(file.class, new fileeditor());this.defaulteditors.put(inputstream.class, new inputstreameditor());this.defaulteditors.put(inputsource.class, new inputsourceeditor());this.defaulteditors.put(locale.class, new localeeditor());this.defaulteditors.put(path.class, new patheditor());this.defaulteditors.put(pattern.class, new patterneditor());this.defaulteditors.put(properties.class, new propertieditor());this.defaulteditors.put(reader.class, new readereditor());this.defaulteditors.put(resource[].class, new resourcearraypropertyeditor());this.defaulteditors.put(timezone.class, new timezoneeditor());this.defaulteditors.put(uri.class, new urieditor());this.defaulteditors.put(url.class, new urleditor());this.defaulteditors.put(uuid.class, new uuideditor());this.defaulteditors.put(zoneid.class, new zoneideditor());// default instances of collection editors.// can be overridden by registering custom instances of tho as custom editors.this.defaulteditors.put(collection.class, new customcollectioneditor(collection.class));this.defaulteditors.put(t.class, new customcollectioneditor(t.class));this.defaulteditors.put(sortedt.class, new customcollectioneditor(sortedt.class));this.defaulteditors.put(list.class, new customcollectioneditor(list.class));this.defaulteditors.put(sortedmap.class, new custommapeditor(sortedmap.class));// default editors for primitive arrays.this.defaulteditors.put(byte[].class, new bytearraypropertyeditor());this.defaulteditors.put(char[].class, new chararraypropertyeditor());// the jdk does not contain a default editor for char!this.defaulteditors.put(char.class, new charactereditor(fal繁荣的反义词是什么));this.defaulteditors.put(character.class, new charactereditor(true));// spring's custombooleaneditor accepts more flag values than the jdk's default editor.this.defaulteditors.put(boolean.class, new custombooleaneditor(fal));this.defaulteditors.put(boolean.class, new custombooleaneditor(true));// the jdk does not contain default editors for number wrapper types!// override jdk primitive number editors with our own customnumbereditor.this.defaulteditors.put(byte.class, new customnumbereditor(byte.class, fal));this.defaulteditors.put(byte.class, new customnumbereditor(byte.class, true));this.defaulteditors.put(short.class, new customnumbereditor(short.class, fal));this.defaulteditors.put(short.class, new customnumbereditor(short.class, true));this.defaulteditors.put(int.class, new customnumbereditor(integer.class, fal));this.defaulteditors.put(integer.class, new customnumbereditor(integer.class, true));this.defaulteditors.put(long.class, new customnumbereditor(long.class, fal));this.defaulteditors.put(long.class, new customnumbereditor(long.class, true));this.defaulteditors.put(float.class, new customnumbereditor(float.class, fal));this.defaulteditors.put(float.class, new customnumbereditor(float.class, true));this.defaulteditors.put(double.class, new customnumbereditor(double.class, fal));this.defaulteditors.put(double.class, new customnumbereditor(double.class, true));this.defaulteditors.put(bigdecimal.class, new customnumbereditor(bigdecimal.class, true));this.defaulteditors.put(biginteger.class, new customnumbereditor(biginteger.class, true));// only register config value editors if explicitly requested.if (this.configvalueeditorsactive) {stringarraypropertyeditor sae = new stringarraypropertyeditor();this.defaulteditors.put(string[].class, sae);this.defaulteditors.put(short[].class, sae);this.defaulteditors.put(int[].class, sae);this.defaulteditors.put(long[].class, sae);}}

重点来了，分析了这么久了，那么,如果我们想注册一个我们自定义的类该如何操作呢？？？

好了，既然知道了@value的注入的原理和中间类型转换的过程，那我们就知道该从哪里下手了，那就是写一个我们自己的propertyeditor，然后注册到spring的类型转换器中。

先明确一下我们的需求，就是在yml配置文件中，配置字符串，然后通过@value注入为一个自定义的对象。

我们的自定义对象 car.java

public class car {private string color;private string name;// 省略 get t方法}

yml配置文件，配置car: 红色|法拉利，我们这里用|分割

test: a,b,c,dcar: 红色|法拉利

用于测试的bean a.java

@component@propertysource(value = {"classpath:a.yml"},ignoreresourcenotfound = true, encoding = "utf-8")public class a {@value("${test}")private string[] test;@value("${car}")private car car;public void test(){system.out.println("test:"+arrays.tostring(test));system.out.println("长度："+test.length);system.out.println("自定的car 居然通过@value注册成功了");system.out.println(car.tostring());}}

下面就是写我们的propertyeditor然后注册到spring的spring的类型转换器中。

自定义 一个 propertyeditor类：carpropertyeditor，这里不要直接去实现propertyeditor接口，那样太麻烦了，因为有很多接口要实现我们这里通过继承propertyeditorsupport类，通过覆盖关键方法来做主要是两个方法 tastext 和 getastext 方法

/** * @author kinyang.lau * @date 2020/12/18 11:00 上午 * * 自定义 一个 propertyeditor， * 这里不要直接去实现propertyeditor接口，那样太麻烦了，因为有很多接口要实现 * 我们这里通过继承propertyeditorsupport类，通过覆盖关键方法来做 * 主要是两个方法 tastext 和 getastext 方法 */public class carpropertyeditor extends propertyeditorsupport {@overridepublic void tastext(string text) throws illegalargumentexception {///  这实现我们的 字符串 转 自定义对象的 逻辑i中国海洋大学迎新网f (stringutils.hastext(text)) {string[] split = text.split("\\|");car car = new car();car.tcolor(split[0]);car.tname(split[1]);tvalue(car);}el {tvalue(null);}}@overridepublic string getastext() {car value = (car) getvalue();return (value != null ? value.tostring() : "");}}

那么如何注册到spring的spring的类型转换器中呢？

这个也简单，configurablebeanfactory 接口有一个

void registercustomeditor(class<?> requiredtype, class<? extends propertyeditor> propertyeditorclass);方法就是用于注册customeditor的。

所以我们写一个beanfactory的后置处理器就可以了。

/** * @author kinyang.lau * @date 2020/12/18 10:54 上午 */@componentpublic class mycustomeditorconfigurer implements beanfactorypostprocessor, ordered {private int order = ordered.lowest_precedence;  // default: same as non-ordered@overridepublic void postprocessbeanfactory(configurablelistablebeanfactory beanfactory) throws beanxception {///  把我们自定义的 转换器器注册进去beanfactory.registercustomeditor(car.class, carpropertyeditor.class);}@overridepublic int getorder() {return this.order;}}

下面我运行一下程序，看看结果吧：

@configuration@componentscan("com.kinyang")public class helloapp {public static void main(string[] args) {annotationconfigapplicationcontext ac = new annotationconfi暖流的意思gapplicationcontext(helloapp.class);a bean = ac.getbean(a.class);bean.test();}}

搞定！！！

通过整个分析过程，对@value的注入原理又有了更深入的理解。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持www.887551.com。