如何在春季数据休息中有条件地应用验证组？

Question

我有一个 spring data rest rest 带有基于属性的实体验证的实体类型的project 实体。我想使用当该属性设置为特定值时。

作为具体的示例，以以下实体类：

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.validation.constraints.NotNull;

@Entity
public class Animal {
    public enum Type { FLYING, OTHER }

    /**
     * Validation group.
     */
    public interface Flying {}

    @Id
    @GeneratedValue
    private Integer id;

    private Type type;

    @NotNull(groups = Flying.class)
    private Integer airSpeedVelocity;

    @NotNull
    private Integer weight;

    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }
    public Type getType() { return type; }
    public void setType(Type type) { this.type = type; }
    public Integer getAirSpeedVelocity() { return airSpeedVelocity; }
    public void setAirSpeedVelocity(Integer airSpeedVelocity) { this.airSpeedVelocity = airSpeedVelocity; }
    public Integer getWeight() { return weight; }
    public void setWeight(Integer weight) { this.weight = weight;}
}

当保存 Animal type 飞行时，我想验证 airspeedvelocity 是非null 。保存其他动物时，我不希望这种验证。

目前，我有验证允许在保存之前检查验证，因此如果对象无效，则返回400不良请求错误：

    @Bean
    public ValidatingRepositoryEventListener preSaveValidator(
            @Qualifier("defaultValidator") SmartValidator validator,
            ObjectFactory<PersistentEntities> persistentEntitiesFactory) {
        ValidatingRepositoryEventListener eventListener = 
                new ValidatingRepositoryEventListener(persistentEntitiesFactory);
        eventListener.addValidator("beforeCreate", validator);
        eventListener.addValidator("beforeSave", validator);
        return eventListener;
    }
}

请求：

{ "type": "FLYING" }

当前400错误响应：

{
    "errors": [
        {
            "entity": "Animal",
            "property": "weight",
            "invalidValue": null,
            "message": "must not be null"
        }
    ]
}

所需的400错误响应：

{
    "errors": [
        {
            "entity": "Animal",
            "property": "airSpeedVelocity",
            "invalidValue": null,
            "message": "must not be null"
        },
        {
            "entity": "Animal",
            "property": "weight",
            "invalidValue": null,
            "message": "must not be null"
        }
    ]
}

我如何执行此条件验证，应用程序应用程序飞行验证组当请求实体为动物其中 type == flage ？

Answer 1

一种解决方案是使用自定义的验证器自动检查输入类型，必要时自动应用自定义验证组：

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mapping.context.PersistentEntities;
import org.springframework.data.rest.core.event.ValidatingRepositoryEventListener;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.SmartValidator;

import javax.validation.groups.Default;

@Configuration
public class RestRepositoryValidatorConfig {
    @Bean
    public ValidatingRepositoryEventListener preSaveValidator(
            AnimalValidationGroupAwareValidator validator,
            ObjectFactory<PersistentEntities> persistentEntitiesFactory) {
        ValidatingRepositoryEventListener eventListener =
                new ValidatingRepositoryEventListener(persistentEntitiesFactory);
        eventListener.addValidator("beforeCreate", validator);
        eventListener.addValidator("beforeSave", validator);
        return eventListener;
    }

    @Component
    public static class AnimalValidationGroupAwareValidator
            implements SmartValidator {
        private final SmartValidator delegate;

        public AnimalValidationGroupAwareValidator(
                @Qualifier("defaultValidator") SmartValidator delegate) {
            this.delegate = delegate;
        }

        @Override
        public boolean supports(Class<?> clazz) {
            return true;
        }

        @Override
        public void validate(Object target, Errors errors,
                             Object... validationHints) {
            // If hints are overridden, use those instead
            delegate.validate(target, errors, validationHints);
        }

        @Override
        public void validate(Object target, Errors errors) {
            if (target instanceof Animal animal &&
                Animal.Type.FLYING.equals(animal.getType())) {
                delegate.validate(target, errors,
                        Animal.Flying.class, Default.class);
            } else {
                delegate.validate(target, errors);
            }
        }
    }
}

请注意，这还添加了 默认 验证组，因为否则也不会执行标准验证。

Answer 2

Hibernate验证 可用于根据对象状态动态定义默认验证组。

per

Hibernate验证器还为默认组序列的动态重新定义提供了一个SPI，具体取决于对象状态。

为此，您需要实现接口 defaultGroupsequenceProvider 并通过 @groupsequenceProvider notation。

在这种情况下，可以创建 defaultGroupSequenceProvider ，该使用 flying group（加上标准默认组）时，当对象的 type> type 属性是飞行，否则标准默认组。

import org.hibernate.validator.spi.group.DefaultGroupSequenceProvider;
import java.util.List;

public class AnimalTypeGroupSequenceProvider
        implements DefaultGroupSequenceProvider<Animal> {
    @Override
    public List<Class<?>> getValidationGroups(Animal object) {
        if (object != null && object.getType() == Animal.Type.FLYING) {
            return List.of(Animal.Flying.class, Animal.class);
        } else {
            return List.of(Animal.class);
        }
    }
}

import org.hibernate.validator.group.GroupSequenceProvider;
import javax.persistence.Entity;

@GroupSequenceProvider(AnimalTypeGroupSequenceProvider.class)
@Entity
public class Animal {
   // ...
}