Spring MVC: jak przeprowadzić walidację?

Są dwa sposoby walidacji danych wejściowych użytkownika: adnotacje i dziedziczenie klasy walidatora Springa. W prostych przypadkach adnotacje są ładne. Jeśli potrzebujesz złożonych walidacji (takich jak Walidacja między polami, np. pole" zweryfikuj adres e-mail") lub jeśli twój model jest sprawdzany w wielu miejscach w aplikacji z różnymi regułami lub jeśli nie masz możliwości modyfikowania obiektu modelu poprzez umieszczanie na nim adnotacji, walidator oparty na dziedziczeniu Springa jest dobrym rozwiązaniem. Pokażę przykłady obu.

Rzeczywista część walidacji jest taka sama niezależnie od tego, jakiego typu walidacji używasz:

RequestMapping(value="fooPage", method = RequestMethod.POST)
public String processSubmit(@Valid @ModelAttribute("foo") Foo foo, BindingResult result, ModelMap m) {
    if(result.hasErrors()) {
        return "fooPage";
    }
    ...
    return "successPage";
}

Jeśli używasz adnotacji, twoja klasa Foo może wyglądać następująco:

public class Foo {

    @NotNull
    @Size(min = 1, max = 20)
    private String name;

    @NotNull
    @Min(1)
    @Max(110)
    private Integer age;

    // getters, setters
}

Adnotacje powyżej to javax.validation.constraints adnotacje. Możesz również użyć Hibernate ' s org.hibernate.validator.constraints, ale wygląda na to, że nie używasz Hibernate.

Alternatywnie, jeśli zaimplementujesz walidator Springa, utworzysz klasę w następujący sposób:

public class FooValidator implements Validator {

    @Override
    public boolean supports(Class<?> clazz) {
        return Foo.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {

        Foo foo = (Foo) target;

        if(foo.getName() == null) {
            errors.rejectValue("name", "name[emptyMessage]");
        }
        else if(foo.getName().length() < 1 || foo.getName().length() > 20){
            errors.rejectValue("name", "name[invalidLength]");
        }

        if(foo.getAge() == null) {
            errors.rejectValue("age", "age[emptyMessage]");
        }
        else if(foo.getAge() < 1 || foo.getAge() > 110){
            errors.rejectValue("age", "age[invalidAge]");
        }
    }
}

Jeśli używasz powyższego walidatora, musisz również powiązać walidator ze sterownikiem sprężyny (nie jest to konieczne, jeśli używasz adnotacji):

@InitBinder("foo")
protected void initBinder(WebDataBinder binder) {
    binder.setValidator(new FooValidator());
}

Zobacz też Spring docs .

Chciałbym rozszerzyć miłą odpowiedź Jerome ' a Dalberta. Znalazłem bardzo łatwo napisać własne walidatory adnotacji w JSR-303 sposób. Nie ograniczasz się do walidacji "jedno pole". Możesz utworzyć własną adnotację na poziomie tekstu i mieć złożoną walidację(patrz przykłady poniżej). Wolę ten sposób, ponieważ nie potrzebuję mieszać różnych typów walidacji (Spring i JSR-303) jak Jerome. Również te walidatory są "świadome wiosny", więc możesz użyć @ Inject/ @ Autowire z box.

Przykład walidacji obiektu niestandardowego:

@Target({ TYPE, ANNOTATION_TYPE })
@Retention(RUNTIME)
@Constraint(validatedBy = { YourCustomObjectValidator.class })
public @interface YourCustomObjectValid {

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

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

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

public class YourCustomObjectValidator implements ConstraintValidator<YourCustomObjectValid, YourCustomObject> {

    @Override
    public void initialize(YourCustomObjectValid constraintAnnotation) { }

    @Override
    public boolean isValid(YourCustomObject value, ConstraintValidatorContext context) {

        // Validate your complex logic 

        // Mark field with error
        ConstraintViolationBuilder cvb = context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate());
        cvb.addNode(someField).addConstraintViolation();

        return true;
    }
}

@YourCustomObjectValid
public YourCustomObject {
}

Przykład równości pól generycznych:

import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

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 = { FieldsEqualityValidator.class })
public @interface FieldsEquality {

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

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

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

    /**
     * Name of the first field that will be compared.
     * 
     * @return name
     */
    String firstFieldName();

    /**
     * Name of the second field that will be compared.
     * 
     * @return name
     */
    String secondFieldName();

    @Target({ TYPE, ANNOTATION_TYPE })
    @Retention(RUNTIME)
    public @interface List {
        FieldsEquality[] value();
    }
}




import java.lang.reflect.Field;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ReflectionUtils;

public class FieldsEqualityValidator implements ConstraintValidator<FieldsEquality, Object> {

    private static final Logger log = LoggerFactory.getLogger(FieldsEqualityValidator.class);

    private String firstFieldName;
    private String secondFieldName;

    @Override
    public void initialize(FieldsEquality constraintAnnotation) {
        firstFieldName = constraintAnnotation.firstFieldName();
        secondFieldName = constraintAnnotation.secondFieldName();
    }

    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        if (value == null)
            return true;

        try {
            Class<?> clazz = value.getClass();

            Field firstField = ReflectionUtils.findField(clazz, firstFieldName);
            firstField.setAccessible(true);
            Object first = firstField.get(value);

            Field secondField = ReflectionUtils.findField(clazz, secondFieldName);
            secondField.setAccessible(true);
            Object second = secondField.get(value);

            if (first != null && second != null && !first.equals(second)) {
                    ConstraintViolationBuilder cvb = context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate());
          cvb.addNode(firstFieldName).addConstraintViolation();

          ConstraintViolationBuilder cvb = context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate());
          cvb.addNode(someField).addConstraintViolation(secondFieldName);

                return false;
            }
        } catch (Exception e) {
            log.error("Cannot validate fileds equality in '" + value + "'!", e);
            return false;
        }

        return true;
    }
}

@FieldsEquality(firstFieldName = "password", secondFieldName = "confirmPassword")
public class NewUserForm {

    private String password;

    private String confirmPassword;

}

Jeśli masz taką samą logikę obsługi błędów dla różnych programów obsługi metod, to skończysz z wieloma programami obsługi z następującym wzorem kodu:

if (validation.hasErrors()) {
  // do error handling
}
else {
  // do the actual business logic
}

Załóżmy, że tworzysz usługi RESTful i chcesz zwrócić {[3] } wraz z komunikatami o błędach dla każdego przypadku błędu walidacji. Następnie część obsługi błędów będzie taka sama dla każdego punktu końcowego REST, który wymaga walidacji. Powtarzanie tej samej logiki w każdym handlerze nie jest takie suche ish!

Jeden sposobem na rozwiązanie tego problemu jest upuszczenie natychmiastowej BindingResult po każdym do walidacji. Twój opiekun będzie wyglądał tak:

@RequestMapping(...)
public Something doStuff(@Valid Somebean bean) { 
    // do the actual business logic
    // Just the else part!
}

W ten sposób, jeśli wiązana fasola nie była ważna, MethodArgumentNotValidException zostanie rzucona do wiosny. Można zdefiniować ControllerAdvice, który obsługuje ten wyjątek z tą samą logiką obsługi błędów:

@ControllerAdvice
public class ErrorHandlingControllerAdvice {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public SomeErrorBean handleValidationError(MethodArgumentNotValidException ex) {
        // do error handling
        // Just the if part!
    }
}

Nadal można zbadać podstawowe BindingResult za pomocą getBindingResult metody MethodArgumentNotValidException.

Znajdź pełny przykład walidacji Spring Mvc

import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import com.technicalkeeda.bean.Login;

public class LoginValidator implements Validator {
    public boolean supports(Class aClass) {
        return Login.class.equals(aClass);
    }

    public void validate(Object obj, Errors errors) {
        Login login = (Login) obj;
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "userName",
                "username.required", "Required field");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "userPassword",
                "userpassword.required", "Required field");
    }
}


public class LoginController extends SimpleFormController {
    private LoginService loginService;

    public LoginController() {
        setCommandClass(Login.class);
        setCommandName("login");
    }

    public void setLoginService(LoginService loginService) {
        this.loginService = loginService;
    }

    @Override
    protected ModelAndView onSubmit(Object command) throws Exception {
        Login login = (Login) command;
        loginService.add(login);
        return new ModelAndView("loginsucess", "login", login);
    }
}

Umieść tę fasolę w klasie konfiguracji.

 @Bean
  public Validator localValidatorFactoryBean() {
    return new LocalValidatorFactoryBean();
  }

I wtedy możesz użyć

 <T> BindingResult validate(T t) {
    DataBinder binder = new DataBinder(t);
    binder.setValidator(validator);
    binder.validate();
    return binder.getBindingResult();
}

Do ręcznego walidacji fasoli. Następnie otrzymasz wszystkie wyniki w BindingResult i możesz stamtąd pobrać.