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

随着更新版本的Hibernate的发布，我注意到我们现在可以通过编程的方式定义约束条件，并想知道我是否可以使用这种方法动态地定义约束条件。我是否正确使用编程约束定义？

本质上我的“DynamicValidator”是这样的，到目前为止（UnsupportedOperationExceptions对于我不确定在这个时候的方法）：

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(); 
    } 

}

我担心的是，我基本上是生成新的验证每次我想验证一个对象。那还好吗？我的直觉告诉我，我应该重新使用一个验证器，但它似乎并不像我可以配置一个验证器后创建。

来源

2014-09-29 kennyg

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

你的直觉是正确的。特别是ValidatorFactory实例应该被缓存。他们创造起来相当昂贵。同样，通过重新构建，您实际上需要一遍又一遍地创建约束元数据，并且无法确保以其他方式缓存的元数据。

我想技术上你在做什么是可能的，但我会建议反对它，特别是如果表现是你的担忧之一。

你的实际用例是什么？

来源

2014-09-30 13:17:54 Hardy

我想在运行时/动态重用并将约束应用于bean属性。主要是因为一个约束可能取决于另一个领域。比如要求结束日期在bean实例的开始日期之后。 – kennyg 2014-09-30 13:37:02

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

回答

相关问题