20191105 《Spring5高级编程》笔记-第10章

第10章 使用类型转换和格式化进行验证

在应用程序开发中，数据验证通常与转换和格式化一起被提及。因为数据源的格式很可能与应用程序中所使用的格式不同。

名词缩写：

SPI(Service Provider Interface)：服务提供接口

10.1 依赖项

<!--validation-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

10.4 Spring类型转换介绍

在Spring3中，引入了一个通用类型转换系统，该系统位于org.springframework.core.convert包中。除了提供PropertyEditor所支持的替代方法之外，还可以配置类型转换系统，从而在任何Java类型和POJO之间进行转换（PropertyEditor专注于将属性文件中的String表示转换为Java类型）。

10.4.1 实现自定义转换器

使用PropertyEditor

//-----JavaBean-----------------//
@Data
public class Singer {
    private String firstName;
    private String lastName;
    private DateTime birthDate;
    private URL personalSite;
}

//-----PropertyEdito相关-----------------//
public class DateTimeEditorRegistrar implements PropertyEditorRegistrar {
    private DateTimeFormatter dateTimeFormatter;

    public DateTimeEditorRegistrar(String dateFormatPattern) {
        dateTimeFormatter = DateTimeFormat.forPattern(dateFormatPattern);
    }

    @Override
    public void registerCustomEditors(PropertyEditorRegistry registry) {
        registry.registerCustomEditor(DateTime.class, new DateTimeEditor(dateTimeFormatter));
    }

    private static class DateTimeEditor extends PropertyEditorSupport {
        private DateTimeFormatter dateTimeFormatter;

        public DateTimeEditor(DateTimeFormatter dateTimeFormatter) {
            this.dateTimeFormatter = dateTimeFormatter;
        }

        @Override
        public void setAsText(String text) throws IllegalArgumentException {
            setValue(DateTime.parse(text, dateTimeFormatter));
        }
    }
}

//-----XML配置-----------------//
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
">

    <context:annotation-config/>

    <context:property-placeholder location="classpath:chapter10/editor.properties"/>

    <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer"
          p:propertyEditorRegistrars-ref="propertyEditorRegistrarsList"/>

    <util:list id="propertyEditorRegistrarsList">
        <bean class="study.hwj.chapter10.editor.DateTimeEditorRegistrar">
            <constructor-arg value="${date.format.pattern}"/>
        </bean>
    </util:list>

    <bean id="eric" class="study.hwj.chapter10.entities.Singer" p:firstName="Eric" p:lastName="Clapton"
          p:birthDate="1945-03-30" p:personalSite="http://www.ericclapton.com"></bean>

    <bean id="countrySinger" class="study.hwj.chapter10.entities.Singer"
          p:firstName="${countrySinger.firstName}" p:lastName="${countrySinger.lastName}"
          p:birthDate="${countrySinger.birthDate}" p:personalSite="${countrySinger.personalSite}"></bean>
</beans>

//-----属性配置-----------------//
date.format.pattern=yyyy-MM-dd

countrySinger.firstName=John
countrySinger.lastName=Mayer
countrySinger.birthDate=1997-10-16
countrySinger.personalSite=http://johnmayer.com/

//-----测试程序-----------------//
@Slf4j
public class PropEditorDemo {
    public static void main(String[] args) {
        GenericXmlApplicationContext ctx = new GenericXmlApplicationContext("classpath:chapter10/ac_editor.xml");

        Singer eric = ctx.getBean("eric", Singer.class);
        log.info("Eric==={}", eric);

        Singer countrySinger = ctx.getBean("countrySinger", Singer.class);
        log.info("countrySinger==={}", countrySinger);
    }
}

10.4.2 配置ConversionService

使用ConversionService

//-----Converter-----------------//
public class StringToDateTimeConverter implements Converter<String, DateTime> {
    private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";
    private DateTimeFormatter dateFormat;
    private String datePattern = DEFAULT_DATE_PATTERN;

    public String getDatePattern() {
        return datePattern;
    }

    public void setDatePattern(String datePattern) {
        this.datePattern = datePattern;
    }

    @PostConstruct
    public void init() {
        System.out.println("StringToDateTimeConverter...init...");
        dateFormat = DateTimeFormat.forPattern(datePattern);
    }

    @Override
    public DateTime convert(String source) {
        return dateFormat.parseDateTime(source);
    }
}

//-----Java配置类-----------------//
@PropertySource("classpath:chapter10/editor.properties")
@Configuration
public class ConversionConfig {
    @Value("${date.format.pattern}")
    private String dateFormatPattern;

    /**
     * 将${date.format.pattern}解析成yyyy-MM-dd
     * @return
     */
    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }

    @Bean
    public Singer john(@Value("${countrySinger.firstName}") String firstName, @Value("${countrySinger.lastName}") String lastName, @Value("${countrySinger.birthDate}") DateTime birthDate, @Value("${countrySinger.personalSite}") URL personalSite) {
        Singer singer = new Singer();
        singer.setFirstName(firstName);
        singer.setLastName(lastName);
        singer.setBirthDate(birthDate);
        singer.setPersonalSite(personalSite);
        return singer;
    }

    @Bean
    public ConversionServiceFactoryBean conversionService() {
        ConversionServiceFactoryBean conversionServiceFactoryBean = new ConversionServiceFactoryBean();
        Set<Converter> convs = new HashSet<>();
        convs.add(converter());
        conversionServiceFactoryBean.setConverters(convs);
        return conversionServiceFactoryBean;
    }

    @Bean
    public StringToDateTimeConverter converter() {
        StringToDateTimeConverter conv = new StringToDateTimeConverter();
        conv.setDatePattern(dateFormatPattern);
        return conv;
    }
}

//-----测试程序-----------------//
public class ConvServDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ConversionConfig.class);
        Singer john = ctx.getBean("john", Singer.class);
        System.out.println(john);
        ctx.close();
    }
}

通过使用类ConversionServiceFactoryBean声明一个conversionService bean，从而指示Spring使用类型转换系统，如果没有定义转换服务bean，Spring将使用基于PropertyEditor的系统。
默认情况下，类型转换服务支持常用类型的转换，包括字符串、数字、枚举、集合、映射等。还支持基于PropertyEditor的系统将String转换为Java类型。

ConversionService接口的默认实现为org.springframework.core.convert.support.DefaultConversionService

容器添加PropertyEditor支持在refresh()的prepareBeanFactory(beanFactory);
容器添加ConversionService支持在refresh()的finishBeanFactoryInitialization(beanFactory);

10.4.3 任意类型之间的转换

//-----定义Converter -----------------//
public class SingerToAnotherSingerConverter implements Converter<Singer, AnotherSinger> {
    @Override
    public AnotherSinger convert(Singer singer) {
        AnotherSinger anotherSinger = new AnotherSinger();
        anotherSinger.setFirstName(singer.getLastName());
        anotherSinger.setLastName(singer.getFirstName());
        anotherSinger.setBirthDate(singer.getBirthDate());
        anotherSinger.setPersonalSite(singer.getPersonalSite());
        return anotherSinger;
    }
}

//-----Java配置类 -----------------//
@Configuration
public class ConvertObjectConfig {

    @Bean
    public Singer john() throws MalformedURLException {
        Singer singer = new Singer();
        singer.setFirstName("John");
        singer.setLastName("Mayer");
        singer.setBirthDate(converter().convert("1977-10-16"));
        singer.setPersonalSite(new URL("http://johnmayer.com/"));
        return singer;
    }

    @Bean
    public ConversionServiceFactoryBean conversionService() {
        ConversionServiceFactoryBean conversionServiceFactoryBean = new ConversionServiceFactoryBean();
        Set<Converter> convs = new HashSet<>();
        convs.add(converter());
        convs.add(singerConverter());
        conversionServiceFactoryBean.setConverters(convs);
        return conversionServiceFactoryBean;
    }

    @Bean
    public StringToDateTimeConverter converter() {
        return new StringToDateTimeConverter();
    }

    @Bean
    public SingerToAnotherSingerConverter singerConverter() {
        return new SingerToAnotherSingerConverter();
    }
}

//-----测试程序-----------------//
public class ConvertObjectDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ConvertObjectConfig.class);

        Singer john = ctx.getBean("john", Singer.class);

        System.out.println(john);

        ConversionService conversionService = ctx.getBean(ConversionService.class);

        // 对象转换
        AnotherSinger anotherSinger = conversionService.convert(john, AnotherSinger.class);

        System.out.println(anotherSinger);

        // 字符串转数组
        String[] stringArray = conversionService.convert("a,b,c", String[].class);
        System.out.println(Arrays.toString(stringArray));

        // List转Set
        ImmutableList<String> list = ImmutableList.of("d", "e", "f");
        HashSet setString = conversionService.convert(list, HashSet.class);

        System.out.println(setString);
    }
}

10.5 Spring中的字段格式化

除类型转换系统外，Spring带来另一个重要功能 Formatter SPI 帮助配置字段格式化。
在 Formatter SPI 中，实现格式化器的主要接口是 org.springframework.format.Formatter 。Spring提供了一些常用类型的实现。

10.5.1 实现自定义格式化器

扩展 org.springframework.format.support.FormattingConversionServiceFactoryBean 类并提供自定义格式化器。 FormattingConversionServiceFactoryBean 是一个工厂类，可以方便的访问底层 FormattingConversionService 类（该类支持类型转换系统），以及根据每个字段类型所定义的格式化规则完成字段格式化。

FormattingConversionService 是 ConversionService 的实现类。

//------定义FormattingConversionServiceFactoryBean子类-------------------------//
@Component("conversionService")
public class ApplicationConversionServiceFactoryBean extends FormattingConversionServiceFactoryBean {
    private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";
    private DateTimeFormatter dateTimeFormatter;
    private String datePattern = DEFAULT_DATE_PATTERN;

    private Set<Formatter<?>> formatters = new HashSet<>();

    public String getDatePattern() {
        return datePattern;
    }

    @Autowired(required = false)
    public void setDatePattern(String datePattern) {
        this.datePattern = datePattern;
    }

    @PostConstruct
    public void init() {
        dateTimeFormatter = DateTimeFormat.forPattern(datePattern);
        formatters.add(getDateTimeFormatter());
        setFormatters(formatters);
    }

    public Formatter<DateTime> getDateTimeFormatter() {
        return new Formatter<DateTime>() {
            @Override
            public DateTime parse(String text, Locale locale) throws ParseException {
                System.out.println(text);
                return dateTimeFormatter.parseDateTime(text);
            }

            @Override
            public String print(DateTime dateTime, Locale locale) {
                return dateTimeFormatter.print(dateTime);
            }
        };
    }
}

//------定义Java配置类-------------------------//
@Configuration
@Import({ApplicationConversionServiceFactoryBean.class})
public class FormatterConfig {
    @Autowired
    private ApplicationConversionServiceFactoryBean conversionService;

    @Bean
    public Singer john() throws MalformedURLException, ParseException {
        Singer singer = new Singer();
        singer.setFirstName("John");
        singer.setLastName("Mayer");
        singer.setPersonalSite(new URL("http://johnmayer.com"));
        singer.setBirthDate(conversionService.getDateTimeFormatter().parse("1977-10-16", Locale.ENGLISH));
        return singer;
    }
}

//------测试程序-------------------------//
public class ConvFormatServDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(FormatterConfig.class);

        Singer john = ctx.getBean("john", Singer.class);
        System.out.println(john);

        ConversionService conversionService = ctx.getBean("conversionService", ConversionService.class);
        System.out.println(conversionService.convert(john.getBirthDate(), String.class));
    }
}

10.6 Spring中的验证

Spring支持两种主要类型的验证。第一种验证类型是由Spring提供的，可以通过实现 org.springframework.validation.Validator 接口来创建自定义验证器。另一种类型是通过Spring对JSR-349（Bean Validation）的支持实现的。

10.6.1 使用Spring Validator接口

//-----------定义Validator--------//
@Configuration
@Component("singerValidator")
public class SingerValidator implements Validator {

    @Override
    public boolean supports(Class<?> clazz) {
        return Singer.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        ValidationUtils.rejectIfEmpty(errors, "firstName", "firstName.empty");
    }
}

//-----------测试程序--------//
public class SpringValidatorDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SingerValidator.class);

        Singer singer = new Singer();
        singer.setFirstName(null);
        singer.setLastName("Mayer");

        SingerValidator singerValidator = ctx.getBean("singerValidator", SingerValidator.class);
        BeanPropertyBindingResult result = new BeanPropertyBindingResult(singer, "John");

        ValidationUtils.invokeValidator(singerValidator, singer, result);

        List<ObjectError> errors = result.getAllErrors();
        errors.forEach(System.out::println);

    }
}

10.6.2 使用JSR-349 Bean Validation

Spring4开始对JSR-349（Bean Validation）提供全面支持。Bean Validation API在包 javax.validation.constraints 中以Java注解的形式定义了一组可应用于域对象的约束。另外，可以使用注解开发和应用自定义验证器（例如，类级验证器）。

通过使用Bean Validation API，可以避免耦合到特定的验证服务提供程序。

10.6.3 在Spring中配置Bean Validation支持

为了在Spring的ApplicationContext中配置对Bean Validation API的支持，可以在Spring的配置中定义一个类型为 org.springframework.validation.beanvalidation.LocalValidatorFactoryBean 的bean。

注意区分：javax.validation.Validator 和 org.springframework.validation.Validator

// -------定义要验证的JavaBean，加上验证注解---------------------------- //
@Data
public class VSinger {

    @NotNull
    @Size(min = 2, max = 60)
    private String firstName;

    private String lastName;

    @NotNull
    private Genre genre;

    private Gender gender;
}

// -------定义Service类---------------------------- //
@Service
public class SingerValidationService {
    @Autowired
    private Validator validator;

    public Set<ConstraintViolation<VSinger>> validateSinger(VSinger singer) {
        return validator.validate(singer);
    }
}

// -------定义Java配置类---------------------------- //
@Configuration
@Import({SingerValidationService.class})
public class ValidatorConfig {
    @Bean
    public LocalValidatorFactoryBean validator() {
        return new LocalValidatorFactoryBean();
    }
}

// -------测试程序---------------------------- //
public class Jsr349Demo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ValidatorConfig.class);

        SingerValidationService service = ctx.getBean(SingerValidationService.class);

        VSinger singer = new VSinger();
        singer.setFirstName("J");
        singer.setLastName("Mayer");
        singer.setGenre(null);

        validateSinger(singer, service);

        ctx.close();
    }

    private static void validateSinger(VSinger singer, SingerValidationService service) {
        Set<ConstraintViolation<VSinger>> violations = service.validateSinger(singer);
        listViolations(violations);
    }

    private static void listViolations(Set<ConstraintViolation<VSinger>> violations) {
        violations.forEach(violation -> {
            System.out.println("Validation error for property: 【" + violation.getPropertyPath() + "】 with value: 【" + violation.getInvalidValue() + "】 with error message: 【" + violation.getMessage() + "】");
        });
    }
}

10.6.4 创建自定义验证器

除了进行属性级验证之外，还可以应用类级验证。在Bean Validation API中，开发一个自定义验证器分两步。第一步是为验证器创建要给注解类型；第二步是开发实现验证逻辑的类。

第一步：
注解类型包含三个属性：

• message属性定义违反约束条件时返回的消息（或错误代码。也可以在注解中提供默认消息。
• group属性指定适用的验证组。可以将验证器分配给不同的组，并对特定组执行验证。
• payload属性指定其他有效载荷对象（即实现了javax.validation.Payload 接口的类）。它允许将附加消息附加到约束上（例如，有效载荷对象可以指明违反约束的严重性）。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Constraint(validatedBy = CountrySingerValidator.class)
public @interface CheckCountrySinger {
    String message() default "Country Singer should have gender and xxx";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

第二步：

public class CountrySingerValidator implements ConstraintValidator<CheckCountrySinger, VSinger> {
    @Override
    public void initialize(CheckCountrySinger constraintAnnotation) {

    }

    @Override
    public boolean isValid(VSinger singer, ConstraintValidatorContext context) {
        if (singer.getGenre() != null && (singer.isCountrySinger() && (singer.getLastName() == null || singer.getGender() == null))) {
            return false;
        }
        return true;
    }
}

10.7 使用AssertTrue进行自定义验证

除了实现自定义验证器外，在 Bean Validation API 中应用自定义验证的另一种方法是使用 @AssertTrue 和 @AssertFalse 注解。

@Data
public class VSinger {

    @NotNull
    @Size(min = 2, max = 60)
    private String firstName;

    private String lastName;

    @NotNull
    private Genre genre;

    private Gender gender;

    @AssertTrue(message = "AssertTrue xxx")
    public boolean isCountrySinger(){
        if (genre != null && (genre == Genre.COUNTRY && (getLastName() == null || getGender() == null))) {
            return false;
        }
        return false;
    }
}

10.8 自定义验证的注意事项

对于JSR-349中的自定义验证，应该使用哪种方法：自定义验证器还是@AssertTure注解？
通常，@AssertTure方法实现起来更简单，可以在域对象的代码中看到验证规则。但是，对于具有更复杂逻辑的验证器（例如，需要注入一个服务类，访问数据库并检查有效值），实现自定义验证器是不错的方法，因为你可能并不像将服务层对象添加到域对象中。而且，自定义验证器可以在相似的域对象中重用。

10.9 决定使用哪种验证API

Spring的Validator接口以及JSR-349（Bean Validation API），更应该使用JSR-349（Bean Validation API）。
主要原因：

• JSR-349是JEE标准，得到很多前后端框架的广泛支持。
• JSR-349提供了标准验证API隐藏了底层提供程序，不受限于特定的提供程序。
• Spring从版本4开始与JSR-349紧密集成。例如，在Spring MVC Web 控制器中，可以使用@Valid注解（javax.validation.Valid）来注解入参，Spring 将在数据绑定过程中自动调用JSR-349验证。
• 如果使用的是JPA2，那么提供程序会在吃就会之前自动对实体执行JSR-349验证。