Java 我是否正确使用编程约束定义？

对于Hibernate的较新版本，我注意到我们现在可以通过编程来定义约束，我想知道是否可以使用这种方法来动态定义约束

基本上，我的DynamicValidator看起来是这样的：目前为止，我不确定的方法不支持操作异常：

public abstract class DynamicValidator implements Validator {

    private TypeConstraintMappingContext<?> constraintMappingContext;

    public <T> Set<ConstraintViolation<T>> validate(@Nonnull T object, Class<?>... groups) {
        Validator validator = configureValidator(object);
        return validator.validate(object, groups);
    }

    @Override
    public <T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, Class<?>... groups) {
        Validator validator = configureValidator(object);
        return validator.validateProperty(object, propertyName, groups);
    }

    protected void addConstraint(String property, ConstraintDef<?, ?> constraintDef) {
        constraintMappingContext.property(property, ElementType.METHOD).constraint(constraintDef);
    }

    protected void addConstraint(ConstraintDef<?, ?> constraintDef) {
        constraintMappingContext.constraint(constraintDef);
    }

    protected void addConstraintViolation(String property, String messageTemplate) {
        constraintMappingContext.property(property, ElementType.METHOD).constraint(new NotValidDef().message(messageTemplate));
    }

    protected abstract <T> void defineDynamicConstraints(@Nonnull T object);

    private <T> Validator configureValidator(@Nonnull T object) {
        HibernateValidatorConfiguration configuration = Validation.byProvider(HibernateValidator.class).configure();
        ConstraintMapping constraintMapping = configuration.createConstraintMapping();
        constraintMappingContext = constraintMapping.type(object.getClass());
        defineDynamicConstraints(object);
        return configuration.addMapping(constraintMapping).buildValidatorFactory().getValidator();
    }

    @Override
    public <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups) {
        throw new UnsupportedOperationException();
    }

    @Override
    public BeanDescriptor getConstraintsForClass(Class<?> clazz) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> T unwrap(Class<T> type) {
        throw new UnsupportedOperationException();
    }

    @Override
    public ExecutableValidator forExecutables() {
        throw new UnsupportedOperationException();
    }

}

我关心的是，每次我想要验证一个对象时，我实际上都在生成一个新的验证器。这样行吗？我的直觉告诉我，我应该重用单个验证器，但我似乎无法在创建后配置验证器

我的直觉告诉我应该重用一个验证器

你的直觉是对的。特别地，验证器工厂实例应该被缓存。它们的制作成本相当高。另外，通过不断地重新构建，您实际上需要一次又一次地创建约束元数据，而无法确保以其他方式缓存的元数据

我想从技术上来说，你所做的是可能的，但我会建议你不要这样做，尤其是如果性能是你关心的问题之一的话

---

您的实际用例是什么？

我希望在运行时/动态地重用和应用bean属性的约束。主要是因为一个约束可能依赖于另一个字段。例如，要求结束日期在bean实例的开始日期之后。