Walidacja między polami za pomocą walidatora hibernacji (JSR 303)

236

Czy w Hibernacji Validator 4.x jest implementacja (lub inna implementacja) walidacji między polami? Jeśli nie, jaki jest najczystszy sposób na wdrożenie walidatora między polami?

Na przykład, w jaki sposób można użyć interfejsu API do sprawdzenia poprawności dwóch właściwości komponentu bean (takich jak sprawdzenie poprawności pola hasła zgodnego z polem weryfikacji hasła).

W adnotacjach oczekiwałbym czegoś takiego:

public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  @Equals(property="pass")
  private String passVerify;
}
Bradhouse
źródło
1
Zobacz stackoverflow.com/questions/2781771/..., aby uzyskać bezpieczne dla klasy i odbijające rozwiązanie API (imo bardziej eleganckie) na poziomie klasy.
Karl Richter,

Odpowiedzi:

282

Każde ograniczenie pola powinno być obsługiwane przez odrębną adnotację walidatora, lub innymi słowy, nie jest sugerowana praktyka, aby sprawdzanie adnotacji walidacji jednego pola względem innych pól; Walidacja między polami powinna odbywać się na poziomie klasy. Ponadto JSR-303 Sekcja 2.2 preferowanym sposobem wyrażania wielu walidacji tego samego typu jest lista adnotacji. Umożliwia to określenie komunikatu o błędzie dla każdego dopasowania.

Na przykład sprawdzanie poprawności wspólnego formularza:

@FieldMatch.List({
        @FieldMatch(first = "password", second = "confirmPassword", message = "The password fields must match"),
        @FieldMatch(first = "email", second = "confirmEmail", message = "The email fields must match")
})
public class UserRegistrationForm  {
    @NotNull
    @Size(min=8, max=25)
    private String password;

    @NotNull
    @Size(min=8, max=25)
    private String confirmPassword;

    @NotNull
    @Email
    private String email;

    @NotNull
    @Email
    private String confirmEmail;
}

Adnotacja:

package constraints;

import constraints.impl.FieldMatchValidator;

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.TYPE;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Target;

/**
 * Validation annotation to validate that 2 fields have the same value.
 * An array of fields and their matching confirmation fields can be supplied.
 *
 * Example, compare 1 pair of fields:
 * @FieldMatch(first = "password", second = "confirmPassword", message = "The password fields must match")
 * 
 * Example, compare more than 1 pair of fields:
 * @FieldMatch.List({
 *   @FieldMatch(first = "password", second = "confirmPassword", message = "The password fields must match"),
 *   @FieldMatch(first = "email", second = "confirmEmail", message = "The email fields must match")})
 */
@Target({TYPE, ANNOTATION_TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy = FieldMatchValidator.class)
@Documented
public @interface FieldMatch
{
    String message() default "{constraints.fieldmatch}";

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

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

    /**
     * @return The first field
     */
    String first();

    /**
     * @return The second field
     */
    String second();

    /**
     * Defines several <code>@FieldMatch</code> annotations on the same element
     *
     * @see FieldMatch
     */
    @Target({TYPE, ANNOTATION_TYPE})
    @Retention(RUNTIME)
    @Documented
            @interface List
    {
        FieldMatch[] value();
    }
}

The Validator:

package constraints.impl;

import constraints.FieldMatch;
import org.apache.commons.beanutils.BeanUtils;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class FieldMatchValidator implements ConstraintValidator<FieldMatch, Object>
{
    private String firstFieldName;
    private String secondFieldName;

    @Override
    public void initialize(final FieldMatch constraintAnnotation)
    {
        firstFieldName = constraintAnnotation.first();
        secondFieldName = constraintAnnotation.second();
    }

    @Override
    public boolean isValid(final Object value, final ConstraintValidatorContext context)
    {
        try
        {
            final Object firstObj = BeanUtils.getProperty(value, firstFieldName);
            final Object secondObj = BeanUtils.getProperty(value, secondFieldName);

            return firstObj == null && secondObj == null || firstObj != null && firstObj.equals(secondObj);
        }
        catch (final Exception ignore)
        {
            // ignore
        }
        return true;
    }
}
Nicko
źródło
8
@AndyT: Na Apache Commons BeanUtils istnieje zewnętrzna zależność.
GaryF
7
@ScriptAssert nie pozwala zbudować komunikatu sprawdzającego z dostosowaną ścieżką. context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate()).addNode(secondFieldName).addConstraintViolation().disableDefaultConstraintViolation(); Daje możliwość podświetlenia właściwego pola (jeśli tylko JSF by go wspierało).
Peter Davis,
8
Użyłem powyżej próbki, ale nie wyświetla komunikatu o błędzie, jakie jest powiązanie w jsp? mam hasło i tylko potwierdzam, czy jest coś jeszcze potrzebnego? <form: hasło ścieżka = "hasło" /> <forma: błędy ścieżka = "hasło" cssClass = "errorz" /> <form: hasło ścieżka = "confirmPassword" /> <forma: błędy ścieżka = "confirmPassword" cssClass = " errorz "/>
Mahmoud Saleh
7
BeanUtils.getPropertyzwraca ciąg. Ten przykład prawdopodobnie miał użyć, PropertyUtils.getPropertyktóry zwraca obiekt.
SingleShot,
2
Ładna odpowiedź, ale uzupełniałem ją odpowiedzią na to pytanie: stackoverflow.com/questions/11890334/…
maxivis
164

Sugeruję inne możliwe rozwiązanie. Być może mniej elegancki, ale łatwiejszy!

public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  private String passVerify;

  @AssertTrue(message="passVerify field should be equal than pass field")
  private boolean isValid() {
    return this.pass.equals(this.passVerify);
  }
}

isValidMetoda jest wywoływana przez walidator automatycznie.

Alberthoven
źródło
12
Myślę, że to znowu mieszanka obaw. Istotą walidacji komponentu Bean jest eksternalizacja weryfikacji w ConstraintValidators. W takim przypadku masz część logiki sprawdzania poprawności w samym komponencie bean i część w ramach programu Validator. Droga jest ograniczona na poziomie klasy. Hibernate Validator oferuje teraz także @ScriptAssert, który ułatwia implementację wewnętrznych zależności komponentu bean.
Hardy
10
Powiedziałbym, że jest to bardziej eleganckie, nie mniej!
NickJ
8
Do tej pory uważam, że JSR firmy Bean Validation stanowi mieszankę obaw.
Dmitry Minkovsky,
3
@GaneshKrishnan Co zrobić, jeśli chcemy mieć kilka takich @AssertTruemetod? Czy obowiązuje jakaś konwencja nazewnictwa?
Stephane,
3
dlaczego nie jest to najlepsza odpowiedź
funky-
32

Dziwię się, że to nie jest dostępne po wyjęciu z pudełka. W każdym razie tutaj jest możliwe rozwiązanie.

Utworzyłem walidator na poziomie klasy, a nie na poziomie pola, jak opisano w pierwotnym pytaniu.

Oto kod adnotacji:

package com.moa.podium.util.constraints;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Target({TYPE, ANNOTATION_TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy = MatchesValidator.class)
@Documented
public @interface Matches {

  String message() default "{com.moa.podium.util.constraints.matches}";

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

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

  String field();

  String verifyField();
}

I sam walidator:

package com.moa.podium.util.constraints;

import org.mvel2.MVEL;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class MatchesValidator implements ConstraintValidator<Matches, Object> {

  private String field;
  private String verifyField;


  public void initialize(Matches constraintAnnotation) {
    this.field = constraintAnnotation.field();
    this.verifyField = constraintAnnotation.verifyField();
  }

  public boolean isValid(Object value, ConstraintValidatorContext context) {
    Object fieldObj = MVEL.getProperty(field, value);
    Object verifyFieldObj = MVEL.getProperty(verifyField, value);

    boolean neitherSet = (fieldObj == null) && (verifyFieldObj == null);

    if (neitherSet) {
      return true;
    }

    boolean matches = (fieldObj != null) && fieldObj.equals(verifyFieldObj);

    if (!matches) {
      context.disableDefaultConstraintViolation();
      context.buildConstraintViolationWithTemplate("message")
          .addNode(verifyField)
          .addConstraintViolation();
    }

    return matches;
  }
}

Zauważ, że użyłem MVEL do sprawdzenia właściwości sprawdzanego obiektu. Można to zastąpić standardowymi interfejsami API refleksji lub, jeśli jest to konkretna sprawdzana klasa, same metody akcesora.

Adnotacji @Matches można następnie użyć na fasoli w następujący sposób:

@Matches(field="pass", verifyField="passRepeat")
public class AccountCreateForm {

  @Size(min=6, max=50)
  private String pass;
  private String passRepeat;

  ...
}

Jako zastrzeżenie napisałem to w ciągu ostatnich 5 minut, więc prawdopodobnie nie usunąłem jeszcze wszystkich błędów. Zaktualizuję odpowiedź, jeśli coś pójdzie nie tak.

Bradhouse
źródło
1
To jest świetne i działa dla mnie, tyle że addNote jest przestarzałe i dostaję AbstractMethodError, jeśli zamiast tego użyję addPropertyNode. Google mi tu nie pomaga. Jakie rozwiązanie Czy brakuje gdzieś zależności?
Paul Grenyer,
29

W Hibernacji Validator 4.1.0. Polecam użycie @ScriptAssert . Wyjście z JavaDoc:

Wyrażenia skryptowe można pisać w dowolnym języku skryptowym lub wyrażeniowym, dla którego silnik zgodny z JSR 223 („Scripting for the JavaTM Platform”) można znaleźć w ścieżce klas.

Uwaga: ocena jest wykonywana przez „ silnik ” skryptowy działający na maszynie wirtualnej Java, dlatego po stronie serwera Java, a nie po stronie klienta, jak stwierdzono w niektórych komentarzach.

Przykład:

@ScriptAssert(lang = "javascript", script = "_this.passVerify.equals(_this.pass)")
public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  private String passVerify;
}

lub z krótszym aliasem i zerowo bezpieczny:

@ScriptAssert(lang = "javascript", alias = "_",
    script = "_.passVerify != null && _.passVerify.equals(_.pass)")
public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  private String passVerify;
}

lub z Javą 7+ null-safe Objects.equals():

@ScriptAssert(lang = "javascript", script = "Objects.equals(_this.passVerify, _this.pass)")
public class MyBean {
  @Size(min=6, max=50)
  private String pass;

  private String passVerify;
}

Niemniej jednak nie ma nic złego w rozwiązaniu sprawdzania poprawności na poziomie klasy niestandardowej @Matches .

Wytrzymały
źródło
1
Ciekawe rozwiązanie, czy naprawdę używamy tutaj javascript, aby przeprowadzić tę weryfikację? To wydaje się przesadą, ponieważ adnotacja w języku Java powinna być w stanie to osiągnąć. Dla moich dziewiczych oczu zaproponowane powyżej rozwiązanie Nicko nadal wydaje się czystsze zarówno z punktu widzenia użyteczności (jego adnotacja jest łatwa do odczytania i dość funkcjonalna vs. nieeleganckie javascript-> referencje java), jak i z punktu widzenia skalowalności (zakładam, że istnieje rozsądny narzut obsłużyć javascript, ale może Hibernacja przynajmniej buforuje skompilowany kod?). Jestem ciekawy, dlaczego tak byłoby preferowane.
David Parks,
2
Zgadzam się, że implementacja Nicko jest przyjemna, ale nie widzę nic budzącego zastrzeżenia w używaniu JS jako języka wyrażeń. Java 6 zawiera Rhino do takich aplikacji. Lubię @ScriptAssert, ponieważ działa po prostu bez konieczności tworzenia adnotacji i walidatora za każdym razem, gdy mam nowy typ testu do wykonania.
4
Jak już powiedziano, nic nie jest z walidatorem na poziomie klasy. ScriptAssert to tylko alternatywa, która nie wymaga pisania niestandardowego kodu. Nie powiedziałem, że jest to preferowane rozwiązanie ;-)
Hardy
Świetna odpowiedź, ponieważ potwierdzenie hasła nie jest kluczową weryfikacją, dlatego można to zrobić po stronie klienta
peterchaula,
19

Sprawdzanie poprawności między polami można wykonać, tworząc niestandardowe ograniczenia.

Przykład: - Porównaj hasło i potwierdź pola Hasło instancji użytkownika.

CompareStrings

@Target({TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy=CompareStringsValidator.class)
@Documented
public @interface CompareStrings {
    String[] propertyNames();
    StringComparisonMode matchMode() default EQUAL;
    boolean allowNull() default false;
    String message() default "";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

StringComparisonMode

public enum StringComparisonMode {
    EQUAL, EQUAL_IGNORE_CASE, NOT_EQUAL, NOT_EQUAL_IGNORE_CASE
}

CompareStringsValidator

public class CompareStringsValidator implements ConstraintValidator<CompareStrings, Object> {

    private String[] propertyNames;
    private StringComparisonMode comparisonMode;
    private boolean allowNull;

    @Override
    public void initialize(CompareStrings constraintAnnotation) {
        this.propertyNames = constraintAnnotation.propertyNames();
        this.comparisonMode = constraintAnnotation.matchMode();
        this.allowNull = constraintAnnotation.allowNull();
    }

    @Override
    public boolean isValid(Object target, ConstraintValidatorContext context) {
        boolean isValid = true;
        List<String> propertyValues = new ArrayList<String> (propertyNames.length);
        for(int i=0; i<propertyNames.length; i++) {
            String propertyValue = ConstraintValidatorHelper.getPropertyValue(String.class, propertyNames[i], target);
            if(propertyValue == null) {
                if(!allowNull) {
                    isValid = false;
                    break;
                }
            } else {
                propertyValues.add(propertyValue);
            }
        }

        if(isValid) {
            isValid = ConstraintValidatorHelper.isValid(propertyValues, comparisonMode);
        }

        if (!isValid) {
          /*
           * if custom message was provided, don't touch it, otherwise build the
           * default message
           */
          String message = context.getDefaultConstraintMessageTemplate();
          message = (message.isEmpty()) ?  ConstraintValidatorHelper.resolveMessage(propertyNames, comparisonMode) : message;

          context.disableDefaultConstraintViolation();
          ConstraintViolationBuilder violationBuilder = context.buildConstraintViolationWithTemplate(message);
          for (String propertyName : propertyNames) {
            NodeBuilderDefinedContext nbdc = violationBuilder.addNode(propertyName);
            nbdc.addConstraintViolation();
          }
        }    

        return isValid;
    }
}

ConstraintValidatorHelper

public abstract class ConstraintValidatorHelper {

public static <T> T getPropertyValue(Class<T> requiredType, String propertyName, Object instance) {
        if(requiredType == null) {
            throw new IllegalArgumentException("Invalid argument. requiredType must NOT be null!");
        }
        if(propertyName == null) {
            throw new IllegalArgumentException("Invalid argument. PropertyName must NOT be null!");
        }
        if(instance == null) {
            throw new IllegalArgumentException("Invalid argument. Object instance must NOT be null!");
        }
        T returnValue = null;
        try {
            PropertyDescriptor descriptor = new PropertyDescriptor(propertyName, instance.getClass());
            Method readMethod = descriptor.getReadMethod();
            if(readMethod == null) {
                throw new IllegalStateException("Property '" + propertyName + "' of " + instance.getClass().getName() + " is NOT readable!");
            }
            if(requiredType.isAssignableFrom(readMethod.getReturnType())) {
                try {
                    Object propertyValue = readMethod.invoke(instance);
                    returnValue = requiredType.cast(propertyValue);
                } catch (Exception e) {
                    e.printStackTrace(); // unable to invoke readMethod
                }
            }
        } catch (IntrospectionException e) {
            throw new IllegalArgumentException("Property '" + propertyName + "' is NOT defined in " + instance.getClass().getName() + "!", e);
        }
        return returnValue; 
    }

    public static boolean isValid(Collection<String> propertyValues, StringComparisonMode comparisonMode) {
        boolean ignoreCase = false;
        switch (comparisonMode) {
        case EQUAL_IGNORE_CASE:
        case NOT_EQUAL_IGNORE_CASE:
            ignoreCase = true;
        }

        List<String> values = new ArrayList<String> (propertyValues.size());
        for(String propertyValue : propertyValues) {
            if(ignoreCase) {
                values.add(propertyValue.toLowerCase());
            } else {
                values.add(propertyValue);
            }
        }

        switch (comparisonMode) {
        case EQUAL:
        case EQUAL_IGNORE_CASE:
            Set<String> uniqueValues = new HashSet<String> (values);
            return uniqueValues.size() == 1 ? true : false;
        case NOT_EQUAL:
        case NOT_EQUAL_IGNORE_CASE:
            Set<String> allValues = new HashSet<String> (values);
            return allValues.size() == values.size() ? true : false;
        }

        return true;
    }

    public static String resolveMessage(String[] propertyNames, StringComparisonMode comparisonMode) {
        StringBuffer buffer = concatPropertyNames(propertyNames);
        buffer.append(" must");
        switch(comparisonMode) {
        case EQUAL:
        case EQUAL_IGNORE_CASE:
            buffer.append(" be equal");
            break;
        case NOT_EQUAL:
        case NOT_EQUAL_IGNORE_CASE:
            buffer.append(" not be equal");
            break;
        }
        buffer.append('.');
        return buffer.toString();
    }

    private static StringBuffer concatPropertyNames(String[] propertyNames) {
        //TODO improve concating algorithm
        StringBuffer buffer = new StringBuffer();
        buffer.append('[');
        for(String propertyName : propertyNames) {
            char firstChar = Character.toUpperCase(propertyName.charAt(0));
            buffer.append(firstChar);
            buffer.append(propertyName.substring(1));
            buffer.append(", ");
        }
        buffer.delete(buffer.length()-2, buffer.length());
        buffer.append("]");
        return buffer;
    }
}

Użytkownik

@CompareStrings(propertyNames={"password", "confirmPassword"})
public class User {
    private String password;
    private String confirmPassword;

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getConfirmPassword() { return confirmPassword; }
    public void setConfirmPassword(String confirmPassword) { this.confirmPassword =  confirmPassword; }
}

Test

    public void test() {
        User user = new User();
        user.setPassword("password");
        user.setConfirmPassword("paSSword");
        Set<ConstraintViolation<User>> violations = beanValidator.validate(user);
        for(ConstraintViolation<User> violation : violations) {
            logger.debug("Message:- " + violation.getMessage());
        }
        Assert.assertEquals(violations.size(), 1);
    }

Wynik Message:- [Password, ConfirmPassword] must be equal.

Używając ograniczenia walidacji CompareStrings, możemy również porównywać więcej niż dwie właściwości i mieszać dowolną z czterech metod porównywania ciągów.

ColorChoice

@CompareStrings(propertyNames={"color1", "color2", "color3"}, matchMode=StringComparisonMode.NOT_EQUAL, message="Please choose three different colors.")
public class ColorChoice {

    private String color1;
    private String color2;
    private String color3;
        ......
}

Test

ColorChoice colorChoice = new ColorChoice();
        colorChoice.setColor1("black");
        colorChoice.setColor2("white");
        colorChoice.setColor3("white");
        Set<ConstraintViolation<ColorChoice>> colorChoiceviolations = beanValidator.validate(colorChoice);
        for(ConstraintViolation<ColorChoice> violation : colorChoiceviolations) {
            logger.debug("Message:- " + violation.getMessage());
        }

Wynik Message:- Please choose three different colors.

Podobnie możemy mieć ograniczenia walidacji między polami CompareNumbers, CompareDates itp.

PS Nie testowałem tego kodu w środowisku produkcyjnym (chociaż testowałem go w środowisku deweloperskim), więc rozważ ten kod jako wydanie Milestone. Jeśli znajdziesz błąd, napisz miły komentarz. :)

dira
źródło
Podoba mi się to podejście, ponieważ jest bardziej elastyczne niż inne. Pozwala mi to zweryfikować więcej niż 2 pola pod kątem równości. Dobra robota!
Tauren
9

Wypróbowałem przykład Alberthovena (hibernacja-walidator 4.0.2.GA) i otrzymałem ValidationException: „Metody z adnotacjami muszą być zgodne z konwencją nazewnictwa JavaBeans. match () nie. ”też. Po zmianie nazwy metody z „dopasuj” na „isValid” to działa.

public class Password {

    private String password;

    private String retypedPassword;

    public Password(String password, String retypedPassword) {
        super();
        this.password = password;
        this.retypedPassword = retypedPassword;
    }

    @AssertTrue(message="password should match retyped password")
    private boolean isValid(){
        if (password == null) {
            return retypedPassword == null;
        } else {
            return password.equals(retypedPassword);
        }
    }

    public String getPassword() {
        return password;
    }

    public String getRetypedPassword() {
        return retypedPassword;
    }

}
Ralph
źródło
Działa to dla mnie poprawnie, ale nie wyświetlało komunikatu o błędzie. Czy to zadziałało i wyświetlał komunikat o błędzie dla Ciebie. W jaki sposób?
Tiny
1
@Tiny: Wiadomość powinna naruszać zasady zwrócone przez weryfikator. (Napisz test jednostkowy: stackoverflow.com/questions/5704743/... ). ALE komunikat sprawdzania poprawności należy do właściwości „isValid”. Dlatego komunikat zostanie wyświetlony w GUI tylko wtedy, gdy GUI pokaże problemy dla retypedPassword AND isValid (obok przepisanego hasła).
Ralph,
8

Jeśli korzystasz z Spring Framework, możesz do tego użyć Spring Expression Language (SpEL). Napisałem małą bibliotekę, która zapewnia walidator JSR-303 oparty na SpEL - dzięki temu sprawdzanie poprawności w wielu polach jest dziecinnie proste! Spójrz na https://github.com/jirutka/validator-spring .

Spowoduje to sprawdzenie długości i równości pól hasła.

@SpELAssert(value = "pass.equals(passVerify)",
            message = "{validator.passwords_not_same}")
public class MyBean {

    @Size(min = 6, max = 50)
    private String pass;

    private String passVerify;
}

Możesz również łatwo to zmodyfikować, aby zweryfikować pola hasła tylko wtedy, gdy oba nie są puste.

@SpELAssert(value = "pass.equals(passVerify)",
            applyIf = "pass || passVerify",
            message = "{validator.passwords_not_same}")
public class MyBean {

    @Size(min = 6, max = 50)
    private String pass;

    private String passVerify;
}
Jakub Jirutka
źródło
4

Podoba mi się pomysł Jakuba Jirutki, aby użyć Spring Expression Language. Jeśli nie chcesz dodawać kolejnej biblioteki / zależności (zakładając, że już korzystasz z Springa), oto uproszczona implementacja jego pomysłu.

Ograniczenie:

@Constraint(validatedBy=ExpressionAssertValidator.class)
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ExpressionAssert {
    String message() default "expression must evaluate to true";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    String value();
}

Walidator:

public class ExpressionAssertValidator implements ConstraintValidator<ExpressionAssert, Object> {
    private Expression exp;

    public void initialize(ExpressionAssert annotation) {
        ExpressionParser parser = new SpelExpressionParser();
        exp = parser.parseExpression(annotation.value());
    }

    public boolean isValid(Object value, ConstraintValidatorContext context) {
        return exp.getValue(value, Boolean.class);
    }
}

Zastosuj w ten sposób:

@ExpressionAssert(value="pass == passVerify", message="passwords must be same")
public class MyBean {
    @Size(min=6, max=50)
    private String pass;
    private String passVerify;
}
holmis83
źródło
3

Nie mam reputacji komentowania pierwszej odpowiedzi, ale chciałem dodać, że dodałem testy jednostkowe dla zwycięskiej odpowiedzi i mam następujące uwagi:

  • W przypadku podania błędnych nazw pierwszych lub pól pojawia się błąd sprawdzania poprawności, tak jakby wartości nie były zgodne. Nie daj się potknąć błędom pisowni np

@FieldMatch (first = " invalid FieldName1", second = "validFieldName2")

  • Walidator będzie akceptować równoważne typy danych, czyli te wszystkie przepustkę z FieldMatch:

private String stringField = "1";

private Integer integerField = new Integer (1)

int prywatny intField = 1;

  • Jeśli pola są typu obiektu, który nie implementuje wartości równej, sprawdzanie poprawności zakończy się niepowodzeniem.
Chanoch
źródło
2

Bardzo ładne rozwiązanie bradhouse. Czy jest jakiś sposób na zastosowanie adnotacji @Matches do więcej niż jednego pola?

EDYCJA: Oto rozwiązanie, które wymyśliłem, aby odpowiedzieć na to pytanie, zmodyfikowałem Ograniczenie, aby zaakceptować tablicę zamiast jednej wartości:

@Matches(fields={"password", "email"}, verifyFields={"confirmPassword", "confirmEmail"})
public class UserRegistrationForm  {

    @NotNull
    @Size(min=8, max=25)
    private String password;

    @NotNull
    @Size(min=8, max=25)
    private String confirmPassword;


    @NotNull
    @Email
    private String email;

    @NotNull
    @Email
    private String confirmEmail;
}

Kod adnotacji:

package springapp.util.constraints;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Target({TYPE, ANNOTATION_TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy = MatchesValidator.class)
@Documented
public @interface Matches {

  String message() default "{springapp.util.constraints.matches}";

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

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

  String[] fields();

  String[] verifyFields();
}

I wdrożenie:

package springapp.util.constraints;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

import org.apache.commons.beanutils.BeanUtils;

public class MatchesValidator implements ConstraintValidator<Matches, Object> {

    private String[] fields;
    private String[] verifyFields;

    public void initialize(Matches constraintAnnotation) {
        fields = constraintAnnotation.fields();
        verifyFields = constraintAnnotation.verifyFields();
    }

    public boolean isValid(Object value, ConstraintValidatorContext context) {

        boolean matches = true;

        for (int i=0; i<fields.length; i++) {
            Object fieldObj, verifyFieldObj;
            try {
                fieldObj = BeanUtils.getProperty(value, fields[i]);
                verifyFieldObj = BeanUtils.getProperty(value, verifyFields[i]);
            } catch (Exception e) {
                //ignore
                continue;
            }
            boolean neitherSet = (fieldObj == null) && (verifyFieldObj == null);
            if (neitherSet) {
                continue;
            }

            boolean tempMatches = (fieldObj != null) && fieldObj.equals(verifyFieldObj);

            if (!tempMatches) {
                addConstraintViolation(context, fields[i]+ " fields do not match", verifyFields[i]);
            }

            matches = matches?tempMatches:matches;
        }
        return matches;
    }

    private void addConstraintViolation(ConstraintValidatorContext context, String message, String field) {
        context.disableDefaultConstraintViolation();
        context.buildConstraintViolationWithTemplate(message).addNode(field).addConstraintViolation();
    }
}
McGin
źródło
Hmm Niepewny. Możesz spróbować utworzyć konkretne weryfikatory dla każdego pola potwierdzenia (aby miały różne adnotacje) lub zaktualizować adnotację @Matches, aby zaakceptować wiele par pól.
bradhouse
Dzięki bradhouse, wymyśliłem rozwiązanie i opublikowałem je powyżej. Potrzebne jest trochę pracy, aby zaspokoić, gdy przekazywana jest różna liczba argumentów, aby nie uzyskać wyjątków IndexOutOfBoundsExcept, ale są podstawy.
McGin
1

Musisz to nazwać jawnie. W powyższym przykładzie bradhouse dał ci wszystkie kroki, aby napisać niestandardowe ograniczenie.

Dodaj ten kod do klasy dzwoniącego.

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

Set<ConstraintViolation<yourObjectClass>> constraintViolations = validator.validate(yourObject);

w powyższym przypadku byłoby

Set<ConstraintViolation<AccountCreateForm>> constraintViolations = validator.validate(objAccountCreateForm);
Vishal
źródło
1

Wypróbuj Oval: http://oval.sourceforge.net/

Wygląda na to, że obsługuje OGNL, więc może możesz to zrobić w bardziej naturalny sposób

@Assert(expr = "_value ==_this.pass").
Mircea D.
źródło
1

Jesteście niesamowici. Naprawdę niesamowite pomysły. Najbardziej lubię te Alberthovena i McGina , więc postanowiłem połączyć oba te pomysły. I opracuj ogólne rozwiązanie dla wszystkich przypadków. Oto moje proponowane rozwiązanie.

@Documented
@Constraint(validatedBy = NotFalseValidator.class)
@Target({ElementType.METHOD, ElementType.FIELD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface NotFalse {


    String message() default "NotFalse";
    String[] messages();
    String[] properties();
    String[] verifiers();

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

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

}

public class NotFalseValidator implements ConstraintValidator<NotFalse, Object> {
    private String[] properties;
    private String[] messages;
    private String[] verifiers;
    @Override
    public void initialize(NotFalse flag) {
        properties = flag.properties();
        messages = flag.messages();
        verifiers = flag.verifiers();
    }

    @Override
    public boolean isValid(Object bean, ConstraintValidatorContext cxt) {
        if(bean == null) {
            return true;
        }

        boolean valid = true;
        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(bean);

        for(int i = 0; i< properties.length; i++) {
           Boolean verified = (Boolean) beanWrapper.getPropertyValue(verifiers[i]);
           valid &= isValidProperty(verified,messages[i],properties[i],cxt);
        }

        return valid;
    }

    boolean isValidProperty(Boolean flag,String message, String property, ConstraintValidatorContext cxt) {
        if(flag == null || flag) {
            return true;
        } else {
            cxt.disableDefaultConstraintViolation();
            cxt.buildConstraintViolationWithTemplate(message)
                    .addPropertyNode(property)
                    .addConstraintViolation();
            return false;
        }

    }



}

@NotFalse(
        messages = {"End Date Before Start Date" , "Start Date Before End Date" } ,
        properties={"endDateTime" , "startDateTime"},
        verifiers = {"validDateRange" , "validDateRange"})
public class SyncSessionDTO implements ControllableNode {
    @NotEmpty @NotPastDate
    private Date startDateTime;

    @NotEmpty
    private Date endDateTime;



    public Date getStartDateTime() {
        return startDateTime;
    }

    public void setStartDateTime(Date startDateTime) {
        this.startDateTime = startDateTime;
    }

    public Date getEndDateTime() {
        return endDateTime;
    }

    public void setEndDateTime(Date endDateTime) {
        this.endDateTime = endDateTime;
    }


    public Boolean getValidDateRange(){
        if(startDateTime != null && endDateTime != null) {
            return startDateTime.getTime() <= endDateTime.getTime();
        }

        return null;
    }

}
Szejk Abdul Wahid
źródło
0

Dokonałem niewielkiej adaptacji w rozwiązaniu Nicko, aby nie trzeba było używać biblioteki Apache Commons BeanUtils i zastąpić ją rozwiązaniem dostępnym już wiosną, dla tych, którzy używają tego, ponieważ mogę być prostszy:

import org.springframework.beans.BeanWrapper;
import org.springframework.beans.PropertyAccessorFactory;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class FieldMatchValidator implements ConstraintValidator<FieldMatch, Object> {

    private String firstFieldName;
    private String secondFieldName;

    @Override
    public void initialize(final FieldMatch constraintAnnotation) {
        firstFieldName = constraintAnnotation.first();
        secondFieldName = constraintAnnotation.second();
    }

    @Override
    public boolean isValid(final Object object, final ConstraintValidatorContext context) {

        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(object);
        final Object firstObj = beanWrapper.getPropertyValue(firstFieldName);
        final Object secondObj = beanWrapper.getPropertyValue(secondFieldName);

        boolean isValid = firstObj == null && secondObj == null || firstObj != null && firstObj.equals(secondObj);

        if (!isValid) {
            context.disableDefaultConstraintViolation();
            context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate())
                .addPropertyNode(firstFieldName)
                .addConstraintViolation();
        }

        return isValid;

    }
}
Pedro Bacchini
źródło
-1

Rozwiązanie z pytaniem: jak uzyskać dostęp do pola opisanego we właściwości adnotacji

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Match {

    String field();

    String message() default "";
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = MatchValidator.class)
@Documented
public @interface EnableMatchConstraint {

    String message() default "Fields must match!";

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

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

public class MatchValidator implements  ConstraintValidator<EnableMatchConstraint, Object> {

    @Override
    public void initialize(final EnableMatchConstraint constraint) {}

    @Override
    public boolean isValid(final Object o, final ConstraintValidatorContext context) {
        boolean result = true;
        try {
            String mainField, secondField, message;
            Object firstObj, secondObj;

            final Class<?> clazz = o.getClass();
            final Field[] fields = clazz.getDeclaredFields();

            for (Field field : fields) {
                if (field.isAnnotationPresent(Match.class)) {
                    mainField = field.getName();
                    secondField = field.getAnnotation(Match.class).field();
                    message = field.getAnnotation(Match.class).message();

                    if (message == null || "".equals(message))
                        message = "Fields " + mainField + " and " + secondField + " must match!";

                    firstObj = BeanUtils.getProperty(o, mainField);
                    secondObj = BeanUtils.getProperty(o, secondField);

                    result = firstObj == null && secondObj == null || firstObj != null && firstObj.equals(secondObj);
                    if (!result) {
                        context.disableDefaultConstraintViolation();
                        context.buildConstraintViolationWithTemplate(message).addPropertyNode(mainField).addConstraintViolation();
                        break;
                    }
                }
            }
        } catch (final Exception e) {
            // ignore
            //e.printStackTrace();
        }
        return result;
    }
}

I jak go używać ...? Lubię to:

@Entity
@EnableMatchConstraint
public class User {

    @NotBlank
    private String password;

    @Match(field = "password")
    private String passwordConfirmation;
}
zach
źródło