web-dev-qa-db-ja.com

プリミティブのコレクションのHibernate検証

私は次のようなことができるようになりたいです：

@Email
public List<String> getEmailAddresses()
{
   return this.emailAddresses;
}

つまり、リストの各アイテムをメールアドレスとして検証する必要があります。もちろん、このようなコレクションに注釈を付けることはできません。

これを行う方法はありますか？

javacollectionsbean-validationhibernate-validator
37
scrotty

JSR-303もHibernate Validatorも、コレクションの各要素を検証できる既製の制約はありません。

この問題に対処する1つの可能な解決策は、カスタム@ValidCollection制約と対応するバリデーター実装ValidCollectionValidatorを作成することです。

コレクションの各要素を検証するには、Validator内のValidCollectionValidatorのインスタンスが必要です。そのようなインスタンスを取得するには、ConstraintValidatorFactoryのカスタム実装が必要です。

次の解決策が好きかどうかを確認してください...

単に、

  • これらすべてのJavaクラスをコピーして貼り付けます（そして関連するクラスをインポートします）;
  • クラスパスにvalidation-api、hibenate-validator、slf4j-log4j12、およびtestng jarを追加します。
  • テストケースを実行します。

ValidCollection

    public @interface ValidCollection {

    Class<?> elementType();

    /* Specify constraints when collection element type is NOT constrained 
     * validator.getConstraintsForClass(elementType).isBeanConstrained(); */
    Class<?>[] constraints() default {};

    boolean allViolationMessages() default true;

    String message() default "{ValidCollection.message}";

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

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

}

ValidCollectionValidator

    public class ValidCollectionValidator implements ConstraintValidator<ValidCollection, Collection>, ValidatorContextAwareConstraintValidator {

    private static final Logger logger = LoggerFactory.getLogger(ValidCollectionValidator.class);

    private ValidatorContext validatorContext;

    private Class<?> elementType;
    private Class<?>[] constraints;
    private boolean allViolationMessages;

    @Override
    public void setValidatorContext(ValidatorContext validatorContext) {
        this.validatorContext = validatorContext;
    }

    @Override
    public void initialize(ValidCollection constraintAnnotation) {
        elementType = constraintAnnotation.elementType();
        constraints = constraintAnnotation.constraints();
        allViolationMessages = constraintAnnotation.allViolationMessages();
    }

    @Override
    public boolean isValid(Collection collection, ConstraintValidatorContext context) {
        boolean valid = true;

        if(collection == null) {
            //null collection cannot be validated
            return false;
        }

        Validator validator = validatorContext.getValidator();

        boolean beanConstrained = validator.getConstraintsForClass(elementType).isBeanConstrained();

        for(Object element : collection) {
            Set<ConstraintViolation<?>> violations = new HashSet<ConstraintViolation<?>> ();

            if(beanConstrained) {
                boolean hasValidCollectionConstraint = hasValidCollectionConstraint(elementType);
                if(hasValidCollectionConstraint) {
                    // elementType has @ValidCollection constraint
                    violations.addAll(validator.validate(element));
                } else {
                    violations.addAll(validator.validate(element));
                }
            } else {
                for(Class<?> constraint : constraints) {
                    String propertyName = constraint.getSimpleName();
                    propertyName = Introspector.decapitalize(propertyName);
                    violations.addAll(validator.validateValue(CollectionElementBean.class, propertyName, element));
                }
            }

            if(!violations.isEmpty()) {
                valid = false;
            }

            if(allViolationMessages) { //TODO improve
                for(ConstraintViolation<?> violation : violations) {
                    logger.debug(violation.getMessage());
                    ConstraintViolationBuilder violationBuilder = context.buildConstraintViolationWithTemplate(violation.getMessage());
                    violationBuilder.addConstraintViolation();
                }
            }

        }

        return valid;
    }

    private boolean hasValidCollectionConstraint(Class<?> beanType) {
        BeanDescriptor beanDescriptor = validatorContext.getValidator().getConstraintsForClass(beanType);
        boolean isBeanConstrained = beanDescriptor.isBeanConstrained();
        if(!isBeanConstrained) {
            return false;
        }
        Set<ConstraintDescriptor<?>> constraintDescriptors = beanDescriptor.getConstraintDescriptors(); 
        for(ConstraintDescriptor<?> constraintDescriptor : constraintDescriptors) {
            if(constraintDescriptor.getAnnotation().annotationType().getName().equals(ValidCollection.class.getName())) {
                return true;
            }
        }
        Set<PropertyDescriptor> propertyDescriptors = beanDescriptor.getConstrainedProperties();
        for(PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            constraintDescriptors = propertyDescriptor.getConstraintDescriptors();
            for(ConstraintDescriptor<?> constraintDescriptor : constraintDescriptors) {
                if(constraintDescriptor.getAnnotation().annotationType().getName().equals(ValidCollection.class.getName())) {
                    return true;
                }
            }    
        }
        return false;
    }

}

ValidatorContextAwareConstraintValidator

public interface ValidatorContextAwareConstraintValidator {

    void setValidatorContext(ValidatorContext validatorContext);

}

CollectionElementBean

    public class CollectionElementBean {

    /* add more properties on-demand */
    private Object notNull;
    private String notBlank;
    private String email;

    protected CollectionElementBean() {
    }

    @NotNull
    public Object getNotNull() { return notNull; }
    public void setNotNull(Object notNull) { this.notNull = notNull; }

    @NotBlank
    public String getNotBlank() { return notBlank; }
    public void setNotBlank(String notBlank) { this.notBlank = notBlank; }

    @Email
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

}

ConstraintValidatorFactoryImpl

public class ConstraintValidatorFactoryImpl implements ConstraintValidatorFactory {

    private ValidatorContext validatorContext;

    public ConstraintValidatorFactoryImpl(ValidatorContext nativeValidator) {
        this.validatorContext = nativeValidator;
    }

    @Override
    public <T extends ConstraintValidator<?, ?>> T getInstance(Class<T> key) {
        T instance = null;

        try {
            instance = key.newInstance();
        } catch (Exception e) { 
            // could not instantiate class
            e.printStackTrace();
        }

        if(ValidatorContextAwareConstraintValidator.class.isAssignableFrom(key)) {
            ValidatorContextAwareConstraintValidator validator = (ValidatorContextAwareConstraintValidator) instance;
            validator.setValidatorContext(validatorContext);
        }

        return instance;
    }

}

従業員

public class Employee {

    private String firstName;
    private String lastName;
    private List<String> emailAddresses;

    @NotNull
    public String getFirstName() { return firstName; }
    public void setFirstName(String firstName) { this.firstName = firstName; }

    public String getLastName() { return lastName; }
    public void setLastName(String lastName) { this.lastName = lastName; }

    @ValidCollection(elementType=String.class, constraints={Email.class})
    public List<String> getEmailAddresses() { return emailAddresses; }
    public void setEmailAddresses(List<String> emailAddresses) { this.emailAddresses = emailAddresses; }

}

チーム

public class Team {

    private String name;
    private Set<Employee> members;

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    @ValidCollection(elementType=Employee.class)
    public Set<Employee> getMembers() { return members; }
    public void setMembers(Set<Employee> members) { this.members = members; }

}

ShoppingCart

public class ShoppingCart {

    private List<String> items;

    @ValidCollection(elementType=String.class, constraints={NotBlank.class})
    public List<String> getItems() { return items; }
    public void setItems(List<String> items) { this.items = items; }

}

ValidCollectionTest

public class ValidCollectionTest {

    private static final Logger logger = LoggerFactory.getLogger(ValidCollectionTest.class);

    private ValidatorFactory validatorFactory;

    @BeforeClass
    public void createValidatorFactory() {
        validatorFactory = Validation.buildDefaultValidatorFactory();
    }

    private Validator getValidator() {
        ValidatorContext validatorContext = validatorFactory.usingContext();
        validatorContext.constraintValidatorFactory(new ConstraintValidatorFactoryImpl(validatorContext));
        Validator validator = validatorContext.getValidator();
        return validator;
    }

    @Test
    public void beanConstrained() {
        Employee se = new Employee();
        se.setFirstName("Santiago");
        se.setLastName("Ennis");
        se.setEmailAddresses(new ArrayList<String> ());
        se.getEmailAddresses().add("segmail.com");
        Employee me = new Employee();
        me.setEmailAddresses(new ArrayList<String> ());
        me.getEmailAddresses().add("[email protected]");

        Team team = new Team();
        team.setMembers(new HashSet<Employee>());
        team.getMembers().add(se);
        team.getMembers().add(me);

        Validator validator = getValidator();

        Set<ConstraintViolation<Team>> violations = validator.validate(team);
        for(ConstraintViolation<Team> violation : violations) {
            logger.info(violation.getMessage());
        }
    }

    @Test
    public void beanNotConstrained() {
        ShoppingCart cart = new ShoppingCart();
        cart.setItems(new ArrayList<String> ());
        cart.getItems().add("JSR-303 Book");
        cart.getItems().add("");

        Validator validator = getValidator();

        Set<ConstraintViolation<ShoppingCart>> violations = validator.validate(cart, Default.class);
        for(ConstraintViolation<ShoppingCart> violation : violations) {
            logger.info(violation.getMessage());
        }
    }

}

出力

02:16:37,581  INFO main validation.ValidCollectionTest:66 - {ValidCollection.message}
02:16:38,303  INFO main validation.ValidCollectionTest:66 - may not be null
02:16:39,092  INFO main validation.ValidCollectionTest:66 - not a well-formed email address

02:17:46,460  INFO main validation.ValidCollectionTest:81 - may not be empty
02:17:47,064  INFO main validation.ValidCollectionTest:81 - {ValidCollection.message}

注：- Beanに制約がある場合は、@ValidCollection制約のconstraints属性を指定しないでください。 Beanに制約がない場合は、constraints属性が必要です。

55
dira

私はこれを元の回答にコメントするほどの高い評判はありませんが、おそらく JSR-308 が最終リリース段階にあり、この問題に対処するとき、この質問に注目する価値があります解放されます！ただし、少なくともJava 8が必要です。

唯一の違いは、検証アノテーションが型宣言内に入るということです。

//@Email
public List<@Email String> getEmailAddresses()
{
   return this.emailAddresses;
}

あなたが探している他の人のために、この情報をどこに置くのが最善だと思うかを教えてください。ありがとう！

追伸詳細については、 これをチェックSO投稿 をチェックしてください。

20
daniel.caspers

Javaアノテーション自体の制限により、_@EachElement_のような汎用ラッパーアノテーションを記述して制約アノテーションをラップすることはできません。ただし、デリゲートする汎用制約バリデータークラスを記述できます。既存の制約バリデーターに対するすべての要素の実際の検証すべての制約に対してラッパーアノテーションを記述する必要がありますが、バリデーターは1つだけです。

このアプローチは jirutka/validator-collection で実装しました（Maven Centralで利用可能）。例えば：

_@EachSize(min = 5, max = 255)
List<String> values;
_

このライブラリーを使用すると、any検証制約の「疑似制約」を簡単に作成して、追加のバリデーターや不要なラッパーを作成することなく、単純型のコレクションに注釈を付けることができますすべてのコレクションのクラス。 EachX制約は、すべての標準Bean検証制約とHibernate固有の制約でサポートされています。

独自の_@EachAwesome_制約に_@Awesome_を作成するには、注釈クラスをコピーして貼り付け、_@Constraint_注釈を@Constraint(validatedBy = CommonEachValidator.class)で置き換え、注釈@EachConstraint(validateAs = Awesome.class)を追加します。それで全部です！

_// common boilerplate
@Documented
@Retention(RUNTIME)
@Target({METHOD, FIELD, ANNOTATION_TYPE})
// this is important!
@EachConstraint(validateAs = Awesome.class)
@Constraint(validatedBy = CommonEachValidator.class)
public @interface EachAwesome {

    // copy&paste all attributes from Awesome annotation here
    String message() default "";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    String someAttribute();
}
_

編集：ライブラリの現在のバージョン用に更新されました。

15
Jakub Jirutka

Becomputer06からの素晴らしい回答に感謝します。しかし、次の注釈をValidCollection定義に追加する必要があると思います。

@Target( { ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = ValidCollectionValidator.class)

また、値がbecomputer06の方法で渡されないため、プリミティブ型ラッパーのコレクションをどう処理して、@ Size、@ Min、@ Maxなどの注釈を制約するかはまだわかりません。

もちろん、アプリケーションのすべてのケースに対してカスタム制約アノテーションを作成できますが、いずれにしても、これらのアノテーションのプロパティをCollectionElementBeanに追加する必要があります。そしてそれは十分に悪い解決策のようです。

4
Sergey Morozov

JSR-303には、組み込み制約のターゲットタイプを拡張する機能があります。 7.1.2。XMLでの制約定義のオーバーライド を参照してください。

ConstraintValidator<Email, List<String>>を実装すると、プリミティブバリデーターに委任して、指定された回答と同じことを実行できます。その後、モデル定義を保持し、@EmailにList<String>を適用できます。

1
Markus Malkusch

非常に簡単な回避策が可能です。代わりに、単純な値プロパティをラップするクラスのコレクションを検証できます。これを機能させるには、コレクションで@Validアノテーションを使用する必要があります。

例：

public class EmailAddress {

  @Email
  String email;

  public EmailAddress(String email){
    this.email = email;
  }
}

public class Foo {

  /* Validation that works */
  @Valid
  List<EmailAddress> getEmailAddresses(){
    return this.emails.stream().map(EmailAddress::new).collect(toList());
  }

}
0
aux