验证实体而不保存它

Question

我有实体

@Entity
public class MyEntity {
    @Column(name = "field", nullable = false, length = 10)
    private String field;
}

我如何验证它field不再是 10 个字符而不保存它？

Answer 1

使用bean验证：

@Entity
public class MyEntity {

    @Size(max = 10)
    @Column(name = "field", nullable = false, length = 10)
    private String field;
}

@Length(max = 10)或者也可以使用hibernate 特定的注释。

然后，您可以使用验证器对象验证实体：

public class DemoApplication {

    public static void main(String[] args) {

        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        MyEntity myEntity = new MyEntity();
        Set<ConstraintViolation<MyEntity>> constraintViolations = validator.validate(myEntity));
    }
}

Answer 2

我创建了一个小实用程序类来解决这个问题。

public class HibernateValidator {

    private ConcurrentHashMap<Class, List<FieldConstraint>> constraints = new ConcurrentHashMap<>();

    public List<ValidationViolation> validate(Object entity) {
        List<FieldConstraint> constraints = getFieldConstraints(entity);

        return constraints.stream()
                .flatMap(x -> validate(entity, x))
                .collect(Collectors.toList());
    }

    private Stream<ValidationViolation> validate(Object entity, FieldConstraint x) {
        String value;
        try {
            x.getField().setAccessible(true);
            value = (String) x.getField().get(entity);
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Can't get value", e);
        }
        if (value != null && value.length() > x.getSize()) {
            return Stream.of(ValidationViolation.builder()
                    .fieldName(x.getField().getName())
                    .build());
        } else {
            return Stream.empty();
        }
    }

    private List<FieldConstraint> getFieldConstraints(Object entity) {
        return constraints.computeIfAbsent(entity.getClass(),
                clazz -> Stream.of(clazz.getDeclaredFields())
                        .filter(x -> x.getType().equals(String.class))
                        .flatMap(x -> {
                            Column annotation = x.getAnnotation(Column.class);
                            if (annotation == null) {
                                return Stream.empty();
                            } else {
                                return Stream.of(FieldConstraint.builder()
                                        .field(x)
                                        .size(annotation.length())
                                        .build());
                            }
                        })
                        .collect(Collectors.toList()));
    }

    @Data
    @Builder
    public static class ValidationViolation {
        private final String fieldName;
    }

    @Data
    @Builder
    private static class FieldConstraint {
        private final Field field;
        private final int size;
    }
}