20220507 Core - 3. Validation, Data Binding, and Type Conversion
概览
将验证视为业务逻辑有其利弊,Spring 提供了一种不排除任何一种验证(和数据绑定)设计。具体来说,验证不应该绑定到 web 层,应该易于本地化,并且应该可以插入任何可用的验证器。考虑到这些问题,Spring 提供了一个 Validator
,它在应用程序的每一层都是基本的、有用的。
数据绑定对于让用户输入动态绑定到应用程序的域模型(或用于处理用户输入的任何对象)非常有用。Spring 提供了 DataBinder
来实现这一点。
Validator
和 DataBinder
组成了验证包,主要用于但不限于 web 层。
BeanWrapper
是 Spring 框架中的基本概念,并在很多地方被使用。但是,您可能不需要直接使用 BeanWrapper
。如果您打算使用它,那么在尝试将数据绑定到对象时很可能会使用它。
DataBinder
和较低级别 BeanWrapper
都使用 PropertyEditorSupport
实现来解析和格式化属性值。PropertyEditor
和 PropertyEditorSupport
是 JavaBeans 规范的一部分。
Spring 3 引入了一个提供通用类型转换工具的 core.convert
包,以及一个用于格式化 UI 字段值的更高级别的 format
包。您可以将这些包用作 PropertyEditorSupport
实现的更简单替代方案。
Spring 通过设置基础设施和 Spring 自己的 Validator
契约的适配器支持 Java Bean 验证。应用程序可以全局启用一次 Bean 验证,并将其专门用于所有验证需求。在 web 层,应用程序可以进一步为每个 DataBinder
注册控制器本地的 Spring Validator
实例,这对于插入自定义验证逻辑非常有用。
使用 Spring 的 Validator
接口进行验证
Spring 具有一个可用于验证对象的 Validator
接口。Validator
接口通过使用 Errors
对象来工作,在验证时,验证器可以向 Errors
对象报告验证失败。
以 Person 对象为例:
public class Person {
private String name;
private int age;
// the usual getters and setters...
}
通过实现 org.springframework.validation.Validator
接口的以下两个方法为类提供验证行为:
supports(Class)
:Validator
支持验证所提供的Class
实例吗?validate(Object, org.springframework.validation.Errors)
:验证给定的对象,并在验证错误的情况下向给定的Errors
对象注册错误对象。
实现 Validator
相当简单,Spring Framework 还提供了帮助程序类 ValidationUtils
。以下示例 Validator
为 Person
实例实现:
public class PersonValidator implements Validator {
@Override
public boolean supports(Class<?> clazz) {
return Person.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
ValidationUtils.rejectIfEmpty(errors, "name", "name.empty");
Person p = (Person) target;
if (p.getAge() < 0) {
errors.rejectValue("age", "negative value");
} else if (p.getAge() > 110) {
errors.rejectValue("age", "too.darn.old");
}
}
}
虽然实现 Validator
类来验证富对象中的每个嵌套对象是可以的,但最好将每个嵌套对象类的验证逻辑封装在其自己的 Validator
实现中。
“富”对象的一个简单示例 Customer
是由两个 String
属性(第一个和第二个名称)和一个复杂 Address
对象组成的 。Address
对象可以独立于 Customer
对象使用,因此已经实现了一个不同的 AddressValidator
。如果您希望 CustomerValidator
复用 AddressValidator
类中包含的逻辑,您可以在 CustomerValidator
中进行依赖注入或实例化 AddressValidator
,如以下示例所示:
public class CustomerValidator implements Validator {
private final Validator addressValidator;
public CustomerValidator(Validator addressValidator) {
if (addressValidator == null) {
throw new IllegalArgumentException("The supplied [Validator] is " +
"required and must not be null.");
}
if (!addressValidator.supports(Address.class)) {
throw new IllegalArgumentException("The supplied [Validator] must " +
"support the validation of [Address] instances.");
}
this.addressValidator = addressValidator;
}
/**
* This Validator validates Customer instances, and any subclasses of Customer too
*/
public boolean supports(Class clazz) {
return Customer.class.isAssignableFrom(clazz);
}
public void validate(Object target, Errors errors) {
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "field.required");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "surname", "field.required");
Customer customer = (Customer) target;
try {
errors.pushNestedPath("address");
ValidationUtils.invokeValidator(this.addressValidator, customer.getAddress(), errors);
} finally {
errors.popNestedPath();
}
}
}
验证错误会报告给传递给验证器的 Errors
对象。在 Spring Web MVC 的情况下,可以使用 <spring:bind/>
标签来检查错误消息,但是也可以自己检查 Errors
对象。
参考源码
org.springframework.validation.Validator
org.springframework.validation.ValidationUtils
将错误代码解析为错误消息
当您调用(直接或间接,例如通过使用 ValidationUtils
类)rejectValue
或 Errors
接口中的其他 reject
方法时,底层实现不仅会注册您传入的代码,还会注册一些额外的错误代码。MessageCodesResolver
确定 Errors
接口注册的错误代码。默认情况下, 使用 DefaultMessageCodesResolver
,它不仅使用您提供的代码注册消息,还注册包含您传递给拒绝方法的字段名称的消息。因此,如果您使用 rejectValue("age", "too.darn.old")
拒绝字段,除了代码 too.darn.old
之外,Spring 还会注册 too.darn.old.age
和 too.darn.old.age.int
(第一个包括字段名称,第二个包括字段的类型)。这样做是为了方便开发人员在定位错误消息时提供帮助。
org.springframework.validation.MessageCodesResolver
org.springframework.validation.DefaultMessageCodesResolver
Bean 操作和 BeanWrapper
org.springframework.beans
包符合 JavaBeans 标准。JavaBean 是具有默认无参数构造函数的类,并且遵循命名约定,其中命名 bingoMadness
的属性将具有 setter 方法 setBingoMadness(..)
和 getter 方法 getBingoMadness()
。
bean 包中一个非常重要的类是 BeanWrapper
接口及其实现 BeanWrapperImpl
。BeanWrapper
提供了
- 设置和获取属性值、获取属性描述符和查询属性以确定它们是否可读或可写的功能
- 提供对嵌套属性的支持,允许将子属性上的属性设置为无限深度
- 支持添加标准 JavaBeans
PropertyChangeListeners
和VetoableChangeListeners
的功能,而无需在目标类中支持代码 - 提供了对设置索引属性的支持
BeanWrapper
通常不直接由应用程序代码使用,而是由 DataBinder
和 BeanFactory
使用。
BeanWrapper
的工作方式部分由其名称表示:它包装一个 bean 以对该 bean 执行操作,例如设置和检索属性。
org.springframework.beans.BeanWrapper
设置和获取基本和嵌套属性
设置和获取属性是通过 BeanWrapper
的 setPropertyValue
和 getPropertyValue
的重载方法变体完成的。
属性示例:
表达式 | 解释 |
---|---|
name |
指示属性 name 对应的方法,getName() 、 isName() 、 setName(..) |
account.name |
指示属性 account 的嵌套属性 name ,getAccount().setName() 、 getAccount().getName() |
account[2] |
指示索引属性 account 的第三个元素。索引属性可能是的 array ,list 或其它有序集合 |
account[COMPANYNAME] |
指示由 Map 属性 account 的 COMPANYNAME 键索引的映射条目的值 |
以下两个示例类使用 BeanWrapper
来获取和设置属性:
public class Company {
private String name;
private Employee managingDirector;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Employee getManagingDirector() {
return this.managingDirector;
}
public void setManagingDirector(Employee managingDirector) {
this.managingDirector = managingDirector;
}
}
public class Employee {
private String name;
private float salary;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public float getSalary() {
return salary;
}
public void setSalary(float salary) {
this.salary = salary;
}
}
以下代码片段展示了如何检索和操作实例化 Companies
和 Employees
的某些属性的一些示例:
BeanWrapper company = new BeanWrapperImpl(new Company());
// setting the company name..
company.setPropertyValue("name", "Some Company Inc.");
// ... can also be done like this:
PropertyValue value = new PropertyValue("name", "Some Company Inc.");
company.setPropertyValue(value);
// ok, let's create the director and tie it to the company:
BeanWrapper jim = new BeanWrapperImpl(new Employee());
jim.setPropertyValue("name", "Jim Stravinsky");
company.setPropertyValue("managingDirector", jim.getWrappedInstance());
// retrieving the salary of the managingDirector through the company
Float salary = (Float) company.getPropertyValue("managingDirector.salary");
内置 PropertyEditor
实现
java.beans.PropertyEditor
Spring 使用 PropertyEditor
来实现 Object
和 String
之间的转换。例如, Date
可以以人类可读的方式表示(如 String
: '2007-14-09'
),而我们仍然可以将人类可读的形式转换回原始日期(或者,更好的是,将以人类可读的形式输入的任何日期转换回 Date
对象)。这种行为可以通过注册 java.beans.PropertyEditor
类型的自定义编辑器来实现 。在特定的 IoC 容器或 BeanWrapper
上注册自定义编辑器,使其了解如何将属性转换为所需类型。
在 Spring 中使用属性编辑的几个示例:
- 在 bean 上设置属性是通过使用
PropertyEditor
实现来完成的。当使用String
作为在XML文件中声明的某个 bean 的属性值时,Spring(如果相应属性的 setter 方法有Class
参数)ClassEditor
会尝试将该参数解析为Class
对象。 - Spring 的 MVC 框架中解析 HTTP 请求参数是通过使用各种
PropertyEditor
实现来完成的,可以在CommandController
的所有子类中手动绑定这些实现
Spring 有许多内置的 PropertyEditor
实现。它们都位于 org.springframework.beans.propertyeditors
包中。大多数(但不是全部)默认情况下由 BeanWrapperImpl
注册 。在属性编辑器可以某种方式配置的情况下,您仍然可以注册自己的变体来覆盖默认变体。
下表描述了 Spring 提供的各种 PropertyEditor
实现:
Class | 解释 |
---|---|
ByteArrayPropertyEditor |
字节数组的编辑器。将字符串转换为其相应的字节表示。默认情况下由 BeanWrapperImpl 注册 |
ClassEditor |
将代表类的字符串解析为实际类,反之亦然。如果找不到类,则会抛出 IllegalArgumentException 。默认情况下由 BeanWrapperImpl 注册 |
CustomBooleanEditor |
Boolean 的自定义属性编辑器。默认情况下由 BeanWrapperImpl 注册,但可以通过将其自定义实例注册为自定义编辑器来覆盖 |
CustomCollectionEditor |
集合的属性编辑器,将任何源 Collection 转换为给定的目标 Collection 类型 |
CustomDateEditor |
java.util.Date 的自定义属性编辑器 ,支持自定义 DateFormat 。默认未注册。必须根据需要使用适当的格式进行用户注册。 |
CustomNumberEditor |
Number 的自定义子类属性编辑器,如 Integer ,Long ,Float 或 Double 。默认情况下由 BeanWrapperImpl 注册,但可以通过将其自定义实例注册为自定义编辑器来覆盖 |
FileEditor |
将字符串解析为 java.io.File 对象。默认情况下由 BeanWrapperImpl 注册 |
InputStreamEditor |
单向属性编辑器,可以接受一个字符串并生成(通过中间 ResourceEditor 和 Resource )InputStream 以便可以将 InputStream 属性直接设置为字符串。注意,默认不会为您关闭 InputStream 。默认情况下由 BeanWrapperImpl 注册 |
LocaleEditor |
可以将字符串解析为 Locale 对象,反之亦然(字符串格式为 [language]_[country]_[variant] ,与 Locale 的 toString() 方法相同)。也接受空格作为分隔符,作为下划线的替代品。默认情况下由 BeanWrapperImpl 注册 |
PatternEditor |
可以将字符串解析为 java.util.regex.Pattern 对象,反之亦然 |
PropertiesEditor |
可以将字符串(使用 java.util.Properties 类的 javadoc 中定义的格式进行格式化 )转换为 Properties 对象。默认情况下由 BeanWrapperImpl 注册 |
StringTrimmerEditor |
修剪字符串的属性编辑器。允许将空字符串转换为 null 值。默认情况下未注册,必须是用户注册的 |
URLEditor |
可以将 URL 的字符串表示解析为实际 URL 对象。默认情况下由 BeanWrapperImpl 注册 |
Spring 使用 java.beans.PropertyEditorManager
为可能需要的属性编辑器设置搜索路径。搜索路径还包括 sun.bean.editors
,其中包括 Font
,Color
和大多数基本类型的 PropertyEditor
实现。
另请注意,如果标准 JavaBeans 基础结构 PropertyEditor
与它们处理的类在同一个包中并且与该类具有相同的名称,那么标准 JavaBeans 基础结构会自动发现 Editor
类(无需显式注册它们)。例如,可以具有以下类和包结构,这足以使 SomethingEditor
类被识别并用作 Something
类型属性的 PropertyEditor
。
com
chank
pop
Something
SomethingEditor // the PropertyEditor for the Something class
请注意,您也可以在此处使用标准 BeanInfo
JavaBeans 机制。以下示例使用 BeanInfo
机制显式注册一个或多个具有关联类属性的 PropertyEditor
实例:
com
chank
pop
Something
SomethingBeanInfo // the BeanInfo for the Something class
SomethingBeanInfo
类将 CustomNumberEditor
与 Something
类的 age
属性相关联:
public class SomethingBeanInfo extends SimpleBeanInfo {
public PropertyDescriptor[] getPropertyDescriptors() {
try {
final PropertyEditor numberPE = new CustomNumberEditor(Integer.class, true);
PropertyDescriptor ageDescriptor = new PropertyDescriptor("age", Something.class) {
@Override
public PropertyEditor createPropertyEditor(Object bean) {
return numberPE;
}
};
return new PropertyDescriptor[] { ageDescriptor };
}
catch (IntrospectionException ex) {
throw new Error(ex.toString());
}
}
}
注册额外的自定义 PropertyEditor
实现
将 bean 属性设置为字符串值时,Spring IoC 容器使用标准 JavaBeans PropertyEditor
实现将这些字符串转换为属性的复杂类型。Spring 预先注册了许多自定义 PropertyEditor
实现。此外,Java 的标准 JavaBeans PropertyEditor
查找机制允许对 PropertyEditor
类进行适当命名并将其放置在与它提供支持的类相同的包中,以便可以自动找到它。
如果需要注册其他自定义PropertyEditors
,可以使用几种机制。通常不推荐的方法是使用 ConfigurableBeanFactory
接口的 registerCustomEditor()
方法。另一种(稍微方便一点)机制是使用一个特殊的 bean 工厂后处理器,称为 CustomEditorConfigurer
。尽管您可以将 bean 工厂后处理器与 BeanFactory
实现一起使用,但 CustomEditorConfigurer
具有嵌套的属性设置,因此我们强烈建议您将其与 ApplicationContext
一起使用 ,您可以以与其他 bean 类似的方式部署它,并且可以自动检测和应用。
注意,所有 bean 工厂和应用程序上下文都会通过使用 BeanWrapper
来处理属性转换,自动使用许多内置属性编辑器。此外,ApplicationContext
还可以覆盖或添加其他编辑器,以适合特定应用上下文类型的方式处理资源查找。
使用示例
public class ExoticType {
private String name;
public ExoticType(String name) {
this.name = name;
}
}
public class DependsOnExoticType {
private ExoticType type;
public void setType(ExoticType type) {
this.type = type;
}
}
<bean id="sample" class="example.DependsOnExoticType">
<property name="type" value="aNameForExoticType"/>
</bean>
public class ExoticTypeEditor extends PropertyEditorSupport {
public void setAsText(String text) {
setValue(new ExoticType(text.toUpperCase()));
}
}
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="customEditors">
<map>
<entry key="example.ExoticType" value="example.ExoticTypeEditor"/>
</map>
</property>
</bean>
使用 PropertyEditorRegistrar
使用 Spring 容器注册属性编辑器的另一种机制是创建和使用 PropertyEditorRegistrar
。当您需要在多种不同情况下使用同一组属性编辑器时,此接口特别有用。您可以编写相应的注册器并重复使用它。 PropertyEditorRegistrar
与 PropertyEditorRegistry
接口一起工作,Spring BeanWrapper
和 DataBinder
实现 PropertyEditorRegistry
接口 。PropertyEditorRegistrar
与 CustomEditorConfigurer
结合使用特别方便,它公开了一个属性 setPropertyEditorRegistrars(..)
,以这种方式添加到 PropertyEditorRegistrar
的实例。
CustomEditorConfigurer
可以很容易地与DataBinder
和 Spring MVC 控制器一起使用。此外,它避免了在自定义编辑器上进行同步的需要:PropertyEditorRegistrar
将为每个 bean 创建过程尝试创建新的 PropertyEditor
实例。
创建您自己的 PropertyEditorRegistrar
实现:
public final class CustomPropertyEditorRegistrar implements PropertyEditorRegistrar {
public void registerCustomEditors(PropertyEditorRegistry registry) {
// it is expected that new PropertyEditor instances are created
registry.registerCustomEditor(ExoticType.class, new ExoticTypeEditor());
// you could register as many custom property editors as are required here...
}
}
org.springframework.beans.support.ResourceEditorRegistrar
可以作为实现自定义的参考
配置 CustomEditorConfigurer
并将 CustomPropertyEditorRegistrar
实例注入其中:
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="propertyEditorRegistrars">
<list>
<ref bean="customPropertyEditorRegistrar"/>
</list>
</property>
</bean>
<bean id="customPropertyEditorRegistrar"
class="com.foo.editors.spring.CustomPropertyEditorRegistrar"/>
对于使用 Spring MVC 框架来说,PropertyEditorRegistrars
与数据绑定 Controllers
结合使用会非常方便。以下示例在 initBinder(..)
方法的实现中使用了 PropertyEditorRegistrar
:
public final class RegisterUserController extends SimpleFormController {
private final PropertyEditorRegistrar customPropertyEditorRegistrar;
public RegisterUserController(PropertyEditorRegistrar propertyEditorRegistrar) {
this.customPropertyEditorRegistrar = propertyEditorRegistrar;
}
protected void initBinder(HttpServletRequest request,
ServletRequestDataBinder binder) throws Exception {
this.customPropertyEditorRegistrar.registerCustomEditors(binder);
}
// other methods to do with registering a User
}
这种 PropertyEditor
注册方式可以得到简洁的代码(其实现 initBinder(..)
只有一行),并且可以将常见的 PropertyEditor
注册代码封装在一个类中,然后根据需要在多个 Controllers
类之间共享 。
Spring 类型转换
Spring 3 引入了 core.convert
包,它提供了一个通用类型转换系统。系统定义一个 SPI 来实现类型转换逻辑,定义一个 API 在运行时执行类型转换。在 Spring 容器中,您可以使用此系统作为 PropertyEditor
实现的替代方案,将外部化的 bean 属性值字符串转换为所需的属性类型。您还可以在应用程序中需要进行类型转换的任何位置使用公共 API 。
转换器 SPI - Converter
用于实现类型转换逻辑的 SPI 是简单而 强类型 的
package org.springframework.core.convert.converter;
public interface Converter<S, T> {
T convert(S source);
}
要创建自己的转换器,请实现 Converter
接口并参数化为您要转换的类型 S
和您要转换到的类型 T
。如果需要将 S
集合或数组转换为 T
的数组或集合,您也可以透明地应用此类转换器,前提是委托数组或集合转换器也已注册(默认情况下是 DefaultConversionService
)。
对于每次调用 convert(S)
,源参数保证不为空。如果转换失败,Converter
可能会抛出任何未经检查的异常。具体来说,它应该抛出一个 IllegalArgumentException
来报告无效的源值。注意确保您的 Converter
实现是线程安全的。
为方便起见,core.convert.support
包中提供了几个转换器实现。包括从字符串到数字和其他常见类型的转换器。以下显示了 StringToInteger
类,这是一个典型的 Converter
实现:
package org.springframework.core.convert.support;
final class StringToInteger implements Converter<String, Integer> {
public Integer convert(String source) {
return Integer.valueOf(source);
}
}
org.springframework.core.convert.converter.Converter
使用 ConverterFactory
当您 需要集中整个类层次结构的转换逻辑 时(例如,从 String
转换为 Enum
对象时),您可以实现 ConverterFactory
package org.springframework.core.convert.converter;
public interface ConverterFactory<S, R> {
<T extends R> Converter<S, T> getConverter(Class<T> targetType);
}
将 S
参数化为您要转换的类型,并将 R
参数化为可以转换为的类范围的基类型。然后实现 getConverter(Class)
,其中 T
是 R
的子类。
举例: StringToEnumConverterFactory
package org.springframework.core.convert.support;
final class StringToEnumConverterFactory implements ConverterFactory<String, Enum> {
public <T extends Enum> Converter<String, T> getConverter(Class<T> targetType) {
return new StringToEnumConverter(targetType);
}
private final class StringToEnumConverter<T extends Enum> implements Converter<String, T> {
private Class<T> enumType;
public StringToEnumConverter(Class<T> enumType) {
this.enumType = enumType;
}
public T convert(String source) {
return (T) Enum.valueOf(this.enumType, source.trim());
}
}
}
org.springframework.core.convert.converter.ConverterFactory
使用 GenericConverter
具有比 Converter
更灵活但类型更弱的签名,GenericConverter
支持在多个源类型和目标类型之间进行转换。此外,GenericConverter
提供可用的源字段和目标字段上下文,您可以在实现转换逻辑时使用。上下文允许类型转换由字段注解或在字段签名上声明的泛型信息驱动。
GenericConverter
的接口定义:
package org.springframework.core.convert.converter;
public interface GenericConverter {
public Set<ConvertiblePair> getConvertibleTypes();
Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
}
要实现 GenericConverter
,getConvertibleTypes()
必须返回支持的源、目标类型对。然后实现 convert(Object, TypeDescriptor, TypeDescriptor)
以包含您的转换逻辑。源 TypeDescriptor
提供对包含要转换的值的源字段的访问。目标 TypeDescriptor
提供对要设置转换值的目标字段的访问。
一个很好的 GenericConverter
例子是在 Java 数组和集合之间转换的转换器,ArrayToCollectionConverter
内省声明目标集合类型的字段以解析集合的元素类型。这使得在目标字段上设置集合之前,源数组中的每个元素都可以转换为集合元素类型。
因为 GenericConverter
是一个更复杂的 SPI 接口,应该只在需要时使用它。Converter
和 ConverterFactory
可以满足基本的类型转换需求。
org.springframework.core.convert.converter.GenericConverter
使用 ConditionalGenericConverter
有时,您希望仅 在特定条件成立时运行 Converter
。例如,您可能希望仅在目标字段上存在特定注解时才运行 Converter
,或者您可能只想在目标类上定义了特定方法(例如 static valueOf
方法)时才运行 Converter
。 ConditionalGenericConverter
是 GenericConverter
和 ConditionalConverter
接口的并集 ,可让您定义此类自定义匹配条件:
public interface ConditionalConverter {
boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType);
}
public interface ConditionalGenericConverter extends GenericConverter, ConditionalConverter {
}
一个很好的 ConditionalGenericConverter
例子是 IdToEntityConverter
,它在持久实体标识符和实体引用之间进行转换。IdToEntityConverter
仅当目标实体类型声明静态查找器方法(例如,findAccount(Long)
)时,此类才可能匹配 。您可以在在 matches(TypeDescriptor, TypeDescriptor)
方法里实现查找逻辑。
org.springframework.core.convert.converter.ConditionalGenericConverter
ConversionService
API
ConversionService
定义了一个统一的 API ,用于在运行时执行类型转换逻辑。转换器通常在以下外观接口后运行:
package org.springframework.core.convert;
public interface ConversionService {
boolean canConvert(Class<?> sourceType, Class<?> targetType);
<T> T convert(Object source, Class<T> targetType);
boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType);
Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
}
大多数 ConversionService
实现还实现了 ConverterRegistry
,它提供了一个用于注册转换器的 SPI 。在内部,ConversionService
实现委托其注册的转换器执行类型转换逻辑。
ConfigurableConversionService
接口同时继承了 ConversionService
和 ConverterRegistry
core.convert.support
包中提供了一个健壮的 ConversionService
实现。GenericConversionService
是适用于大多数环境的通用实现。ConversionServiceFactory
提供了一个方便的工厂来创建通用 ConversionService
配置。
org.springframework.core.convert.ConversionService
org.springframework.core.convert.converter.ConverterRegistry
org.springframework.core.convert.support.ConfigurableConversionService
org.springframework.core.convert.support.GenericConversionService
org.springframework.core.convert.support.ConversionServiceFactory
配置 ConversionService
ConversionService
是一个无状态对象,旨在在应用程序启动时实例化,然后在多个线程之间共享。在 Spring 应用程序中,您通常为每个 Spring 容器(或 ApplicationContext
)配置一个 ConversionService
实例。Spring 在框架需要执行类型转换时使用 ConversionService
。您还可以将 ConversionService
注入任何 bean 并直接调用它。
如果没有在 Spring 中注册 ConversionService
,则使用原始的基于 PropertyEditor
系统。
要向 Spring 注册默认的 ConversionService
,请添加 id
为 conversionService
的 bean 定义:
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"/>
默认 ConversionService
可以在字符串、数字、枚举、集合、映射和其他常见类型之间进行转换。
要使用您自己的自定义转换器补充或覆盖默认转换器,请设置 converters
属性,属性值可以实现任何的 Converter
,ConverterFactory
或者 GenericConverter
接口。
<bean id="conversionService"
class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="example.MyCustomConverter"/>
</set>
</property>
</bean>
在 Spring MVC 应用程序中使用 ConversionService
也很常见。
在某些情况下,您可能希望在转换期间应用格式化。使用 FormattingConversionServiceFactoryBean
的详细信息见 FormatterRegistry
SPI
org.springframework.context.support.ConversionServiceFactoryBean
org.springframework.core.convert.support.DefaultConversionService
org.springframework.format.support.FormattingConversionServiceFactoryBean
以编程方式使用 ConversionService
要以编程方式使用 ConversionService
实例,可以像注入任何其他 bean 一样注入对它的引用。
@Service
public class MyService {
public MyService(ConversionService conversionService) {
this.conversionService = conversionService;
}
public void doIt() {
this.conversionService.convert(...)
}
}
对于大多数用例,可以使用 convert
方法指定的 targetType
,但它不适用于更复杂的类型,例如参数化元素的集合。例如,如果要以编程方式将 Integer
的 List
转换为 String
的 List
,则需要提供源类型和目标类型的正式定义。
幸运的是,TypeDescriptor
提供了各种选项来使操作变得简单,如以下示例所示:
DefaultConversionService cs = new DefaultConversionService();
List<Integer> input = ...
cs.convert(input,
TypeDescriptor.forObject(input), // List<Integer> type descriptor
TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class)));
注意,DefaultConversionService
自动注册了适用于大多数环境的转换器。这包括集合转换器、标量转换器以及基本的 Object
到 String
转换器。可以使用 DefaultConversionService
类上的静态方法 addDefaultConverters
向任何 ConverterRegistry
注册相同的转换器。
值类型的转换器可重用于数组和集合,因此无需创建特定的转换器来将 S
的 Collection
转换为 T
的 Collection
,前提是标准集合处理是合适的。
org.springframework.core.convert.support.DefaultConversionService
Spring 属性格式化( Format )
core.convert
是一个通用类型转换系统。它提供了一个统一的 ConversionService
API 以及一个强类型的 Converter
SPI,用于实现从一种类型到另一种类型的转换逻辑。Spring 容器使用此系统绑定 bean 属性值。此外,Spring Expression Language( SpEL)和 DataBinder
都使用此系统绑定字段值。例如,当 SpEL 需要将 Short
强制转换为 Long
以完成 expression.setValue(Object bean,Object value)
尝试时。
考虑典型客户端环境(例如 Web 或桌面应用程序)的类型转换要求。在此类环境中,您通常会转换 String
为支持客户端回发过程,以及转换 String
为支持视图渲染过程。此外,您经常需要本地化 String
值。 Converter
SPI 不直接解决此类格式要求。为了直接解决这些问题,Spring 3 引入了一个方便的 Formatter
SPI,它为客户端环境的 PropertyEditor
实现提供了一个简单而健壮的替代方案。
通常,当您需要实现通用类型转换逻辑时可以使用 Converter
SPI ,例如,在 java.util.Date
和 Long
之间进行转换。当您在客户端环境(例如 Web 应用程序)中工作并且 需要解析和打印本地化的字段值时 ,您可以使用 Formatter
SPI。
ConversionService
为 Converter
和 Formatter
两个 SPI 提供统一的类型转换 API 。
Formatter
SPI
实现字段格式化逻辑的 Formatter
SPI 简单且 强类型
package org.springframework.format;
public interface Formatter<T> extends Printer<T>, Parser<T> {
}
package org.springframework.format;
public interface Printer<T> {
String print(T fieldValue, Locale locale);
}
package org.springframework.format;
import java.text.ParseException;
import java.util.Locale;
public interface Parser<T> {
T parse(String clientValue, Locale locale) throws ParseException;
}
注意确保 Formatter
实现是线程安全的。
为了方便起见,format
子包提供了几种 Formatter
实现。number
包提供 NumberStyleFormatter
、CurrencyStyleFormatter
和 PercentStyleFormatter
使用 java.text.NumberFormat
来格式化 Number
对象。 datetime
包提供了 DateFormatter
使用 java.text.DateFormat
格式化 java.util.Date
对象。
参考实现:org.springframework.format.datetime.DateFormatter
org.springframework.format.Formatter
注解驱动的格式化( AnnotationFormatterFactory
)
字段格式可以通过字段类型或注解进行配置。要将注解绑定到 Formatter
,请实现 AnnotationFormatterFactory
。
AnnotationFormatterFactory
接口的定义:
package org.springframework.format;
public interface AnnotationFormatterFactory<A extends Annotation> {
Set<Class<?>> getFieldTypes();
Printer<?> getPrinter(A annotation, Class<?> fieldType);
Parser<?> getParser(A annotation, Class<?> fieldType);
}
要创建实现,请执行以下操作:参数化要与格式逻辑关联的字段 annotationType
,例如 org.springframework.format.annotation.DateTimeFormat
,getFieldTypes()
返回可以使用注解的字段类型,getPrinter()
返回 Printer
以打印带注解字段的值。getParser()
返回 Parser
来解析带注解字段的clientValue
。
以下示例 AnnotationFormatterFactory
实现将 @NumberFormat
注解绑定到格式化程序以指定数字样式或模式:
public final class NumberFormatAnnotationFormatterFactory
implements AnnotationFormatterFactory<NumberFormat> {
public Set<Class<?>> getFieldTypes() {
return new HashSet<Class<?>>(asList(new Class<?>[] {
Short.class, Integer.class, Long.class, Float.class,
Double.class, BigDecimal.class, BigInteger.class }));
}
public Printer<Number> getPrinter(NumberFormat annotation, Class<?> fieldType) {
return configureFormatterFrom(annotation, fieldType);
}
public Parser<Number> getParser(NumberFormat annotation, Class<?> fieldType) {
return configureFormatterFrom(annotation, fieldType);
}
private Formatter<Number> configureFormatterFrom(NumberFormat annotation, Class<?> fieldType) {
if (!annotation.pattern().isEmpty()) {
return new NumberStyleFormatter(annotation.pattern());
} else {
Style style = annotation.style();
if (style == Style.PERCENT) {
return new PercentStyleFormatter();
} else if (style == Style.CURRENCY) {
return new CurrencyStyleFormatter();
} else {
return new NumberStyleFormatter();
}
}
}
}
要触发格式化,您可以使用 @NumberFormat
注解字段,如下例所示:
public class MyModel {
@NumberFormat(style=Style.CURRENCY)
private BigDecimal decimal;
}
格式化注解 API
org.springframework.format.annotation
包中存在可移植的格式注解 API 。您可以使用 @NumberFormat
格式化 Number
属性,如 Double
和 Long
,使用 @DateTimeFormat
以格式化 java.util.Date
,java.util.Calendar
,Long
(毫秒时间戳)以及 JSR-310 java.time
。
以下示例使用 @DateTimeFormat
将 java.util.Date
格式化为 ISO 日期 ( yyyy-MM-dd
):
public class MyModel {
@DateTimeFormat(iso=ISO.DATE)
private Date date;
}
FormatterRegistry
SPI
FormatterRegistry
是用于注册格式化程序和转换器的 SPI 。 FormattingConversionService
是适用于大多数环境的 FormatterRegistry
实现。您可以以编程方式或声明方式将此变体配置为 Spring bean ,例如使用 FormattingConversionServiceFactoryBean
。由于此实现还实现了ConversionService
,您可以直接配置它以与 Spring DataBinder
和 Spring 表达式语言 ( SpEL ) 一起使用。
package org.springframework.format;
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);
}
FormatterRegistry
SPI 允许您集中配置格式化规则,而不是在控制器中重复配置。例如,您可能希望强制所有日期字段以某种方式格式化,或者具有特定注解的字段以某种方式格式化。使用共享的 FormatterRegistry
,您只需定义一次这些规则,并在需要格式化时应用它们。
org.springframework.format.FormatterRegistry
FormatterRegistrar
SPI
FormatterRegistrar
是一个 SPI,用于通过 FormatterRegistry
注册格式化程序和转换器。
package org.springframework.format;
public interface FormatterRegistrar {
void registerFormatters(FormatterRegistry registry);
}
在为给定的格式类别(例如日期格式)注册多个相关的转换器和格式化器时,FormatterRegistrar
很有用。在声明式注册不足的情况下,它也很有用。例如,当格式化程序需要在与其自身 <T>
不同的特定字段类型下进行索引时, 或者在注册 Printer
/ Parser
对时。
在 Spring MVC 中配置格式化
请参阅 Spring MVC 章节中的 转换和格式化
配置全局日期和时间格式
默认情况下,没有 @DateTimeFormat
注解的日期和时间字段使用 DateFormat.SHORT
样式从字符串转换。可以通过定义自己的全局格式来更改此设置。
为此,请确保 Spring 不注册默认格式化器。相反,请在以下帮助下手动注册格式化程序:
org.springframework.format.datetime.standard.DateTimeFormatterRegistrar
org.springframework.format.datetime.DateFormatterRegistrar
以下 Java 配置注册了一个全局 yyyyMMdd
格式:
@Configuration
public class AppConfig {
@Bean
public FormattingConversionService conversionService() {
// Use the DefaultFormattingConversionService but do not register defaults
DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService(false);
// Ensure @NumberFormat is still supported
conversionService.addFormatterForFieldAnnotation(new NumberFormatAnnotationFormatterFactory());
// Register JSR-310 date conversion with a specific global format
DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
registrar.setDateFormatter(DateTimeFormatter.ofPattern("yyyyMMdd"));
registrar.registerFormatters(conversionService);
// Register date conversion with a specific global format
DateFormatterRegistrar registrar = new DateFormatterRegistrar();
registrar.setFormatter(new DateFormatter("yyyyMMdd"));
registrar.registerFormatters(conversionService);
return conversionService;
}
}
如果您更喜欢基于 XML 的配置,则可以使用 FormattingConversionServiceFactoryBean
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd>
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<property name="registerDefaultFormatters" value="false" />
<property name="formatters">
<set>
<bean class="org.springframework.format.number.NumberFormatAnnotationFormatterFactory" />
</set>
</property>
<property name="formatterRegistrars">
<set>
<bean class="org.springframework.format.datetime.standard.DateTimeFormatterRegistrar">
<property name="dateFormatter">
<bean class="org.springframework.format.datetime.standard.DateTimeFormatterFactoryBean">
<property name="pattern" value="yyyyMMdd"/>
</bean>
</property>
</bean>
</set>
</property>
</bean>
</beans>
请注意,在 Web 应用程序中配置日期和时间格式时有一些额外的注意事项。请参阅 WebMVC 转换和格式化 或 WebFlux 转换和格式化
Java Bean 验证
Spring Framework 提供对 Java Bean Validation API 的支持。
需要引入相关依赖
<!-- validation -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
Bean 验证概述
Bean Validation 通过约束声明和 Java 应用程序的元数据提供了一种通用的验证方式。要使用它,可以使用声明性验证约束注解域模型属性,然后由运行时强制执行。有内置约束,您也可以定义自己的自定义约束。
public class PersonForm {
private String name;
private int age;
}
public class PersonForm {
@NotNull
@Size(max=64)
private String name;
@Min(0)
private int age;
}
Bean Validation 验证器然后根据声明的约束验证此类的实例。有关 API 的一般信息,请参阅 Bean 验证 。有关特定约束,请参阅 Hibernate Validator 文档。
配置 Bean 验证提供程序
Spring 完全支持 Bean Validation API ,包括将 Bean Validation 提供者引导为 Spring bean 。这使您可以在应用中任何需要验证的地方注入 javax.validation.ValidatorFactory
或 javax.validation.Validator
您可以使用 LocalValidatorFactoryBean
将默认验证器配置为 Spring bean ,如以下示例所示:
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
@Configuration
public class AppConfig {
@Bean
public LocalValidatorFactoryBean validator() {
return new LocalValidatorFactoryBean();
}
}
前面示例中的基本配置通过使用其默认引导机制触发 bean 验证进行初始化。Bean Validation 提供程序,例如 Hibernate Validator,出现在类路径中会被自动检测到。
org.springframework.validation.beanvalidation.LocalValidatorFactoryBean
注入 Validator
LocalValidatorFactoryBean
实现了 javax.validation.ValidatorFactory
和 javax.validation.Validator
以及 Spring 的 org.springframework.validation.Validator
。您可以将这些接口中的任何一个的引用注入到需要调用验证逻辑的 bean 中。
如果您更喜欢直接使用 Bean Validation API,您可以注入一个 javax.validation.Validator
引用,如以下示例所示:
import javax.validation.Validator;
@Service
public class MyService {
@Autowired
private Validator validator;
}
如果您的 bean 需要 Spring Validation API,可以注入 org.springframework.validation.Validator
引用,如以下示例所示:
import org.springframework.validation.Validator;
@Service
public class MyService {
@Autowired
private Validator validator;
}
javax.validation.Validator
org.springframework.validation.Validator
配置自定义约束
每个 bean 验证约束由两部分组成:
@Constraint
注解声明约束和注解的可配置属性- 实现约束行为的
javax.validation.ConstraintValidator
接口的实现
为了将声明与实现相关联,每个 @Constraint
注解引用一个相应的 ConstraintValidator
实现类。在运行时,当域模型中遇到约束注解时,ConstraintValidatorFactory
将实例化引用的实现。
默认情况下,LocalValidatorFactoryBean
配置了 SpringConstraintValidatorFactory
使用 Spring 创建 ConstraintValidator
实例。这让您的自定义 ConstraintValidators
可以像其他 bean 一样从依赖注入中受益。
下面的示例显示了一个自定义的 @Constraint
声明,相关联的 ConstraintValidator
是使用 Spring 依赖注入的实现:
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy=MyConstraintValidator.class)
public @interface MyConstraint {
}
import javax.validation.ConstraintValidator;
public class MyConstraintValidator implements ConstraintValidator {
@Autowired;
private Foo aDependency;
// ...
}
ConstraintValidator
实现可以像任何其他 Spring bean 一样 @Autowired
它的依赖项 。
javax.validation.Constraint
javax.validation.ConstraintValidator
Spring 驱动的方法验证
可以通过 MethodValidationPostProcessor
bean 定义将 Bean Validation 1.1(以及作为自定义扩展的 Hibernate Validator 4.3)支持的方法验证功能集成到 Spring 上下文中 :
import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
@Configuration
public class AppConfig {
@Bean
public MethodValidationPostProcessor validationPostProcessor() {
return new MethodValidationPostProcessor();
}
}
<bean class="org.springframework.validation.beanvalidation.MethodValidationPostProcessor"/>
为了符合 Spring 驱动的方法验证的条件,所有目标类都需要使用 Spring 的 @Validated
注解进行注解,它也可以选择声明要使用的验证组。
方法验证依赖于围绕目标类的 AOP 代理,即接口方法的 JDK 动态代理或 CGLIB 代理。代理的使用存在某些限制,其中一些在 理解 AOP 代理中 进行了描述 。
注意:始终在代理类上使用方法和访问器;直接对属性进行访问将不起作用。
org.springframework.validation.beanvalidation.MethodValidationPostProcessor
org.springframework.validation.annotation.Validated
其他配置选项
大多数情况下默认 LocalValidatorFactoryBean
配置就足够了。对于各种 Bean 验证构造,有许多配置选项,从消息插值到遍历解析。
配置 DataBinder
从 Spring 3 开始,您可以使用 Validator
配置 DataBinder
实例,可以通过调用 binder.validate()
来调用 Validator
。任何验证 Errors
都会自动添加到绑定器( Binder )的 BindingResult
以下示例显示了如何在绑定到目标对象后以编程方式使用 DataBinder
来调用验证逻辑:
Foo target = new Foo();
DataBinder binder = new DataBinder(target);
binder.setValidator(new FooValidator());
// bind to the target object
binder.bind(propertyValues);
// validate the target object
binder.validate();
// get BindingResult that includes any validation errors
BindingResult results = binder.getBindingResult();
您还可以通过 dataBinder.addValidators
和 dataBinder.replaceValidators
配置具有多个 Validator
实例的 DataBinder
。这在将全局配置的 bean 验证与在 DataBinder
实例上本地配置的 Spring Validator
结合使用时非常有用。请参阅 Spring MVC 验证配置
Spring MVC 3 验证
请参阅 Spring MVC 章节中的 Validation