Spring MVC: Bagaimana cara melakukan validasi?

Saya ingin tahu apa cara terbersih dan terbaik untuk melakukan validasi formulir input pengguna. Saya telah melihat beberapa pengembang mengimplementasikan org.springframework.validation.Validator. Sebuah pertanyaan tentang itu: Saya melihatnya memvalidasi kelas. Apakah kelas harus diisi secara manual dengan nilai-nilai dari input pengguna, dan kemudian diteruskan ke validator?

Saya bingung tentang cara terbersih dan terbaik untuk memvalidasi input pengguna. Saya tahu tentang metode tradisional menggunakan request.getParameter()dan kemudian memeriksa secara manual nulls, tapi saya tidak ingin melakukan semua validasi di Controller. Beberapa saran bagus tentang bidang ini akan sangat dihargai. Saya tidak menggunakan Hibernate dalam aplikasi ini.

Dengan Spring MVC, ada 3 cara berbeda untuk melakukan validasi: menggunakan anotasi, secara manual, atau campuran keduanya. Tidak ada "cara terbersih dan terbaik" unik untuk memvalidasi, tetapi mungkin ada satu yang lebih cocok dengan proyek / masalah / konteks Anda.

Mari Punya Pengguna:

public class User {

    private String name;

    ...

}

Metode 1: Jika Anda memiliki Spring 3.x + dan validasi sederhana untuk dilakukan, gunakan javax.validation.constraintsanotasi (juga dikenal sebagai anotasi JSR-303).

public class User {

    @NotNull
    private String name;

    ...

}

Anda akan membutuhkan penyedia JSR-303 di perpustakaan Anda, seperti Hibernate Validator yang merupakan implementasi referensi (perpustakaan ini tidak ada hubungannya dengan database dan pemetaan relasional, itu hanya validasi :-).

Kemudian di controller Anda, Anda akan memiliki sesuatu seperti:

@RequestMapping(value="/user", method=RequestMethod.POST)
public createUser(Model model, @Valid @ModelAttribute("user") User user, BindingResult result){
    if (result.hasErrors()){
      // do something
    }
    else {
      // do something else
    }
}

Perhatikan @Valid: jika pengguna memiliki nama nol, result.hasErrors () akan benar.

Metode 2: Jika Anda memiliki validasi yang kompleks (seperti logika validasi bisnis besar, validasi bersyarat di berbagai bidang, dll.), Atau karena alasan tertentu Anda tidak dapat menggunakan metode 1, gunakan validasi manual. Ini adalah praktik yang baik untuk memisahkan kode pengontrol dari logika validasi. Jangan membuat kelas validasi Anda dari awal, Spring menyediakan org.springframework.validation.Validatorantarmuka praktis (sejak Spring 2).

Jadi katakanlah Anda punya

public class User {

    private String name;

    private Integer birthYear;
    private User responsibleUser;
    ...

}

dan Anda ingin melakukan validasi "kompleks" seperti: jika usia pengguna di bawah 18, pengguna yang bertanggung jawab tidak boleh nol dan usia pengguna yang bertanggung jawab harus di atas 21.

Anda akan melakukan sesuatu seperti ini

public class UserValidator implements Validator {

    @Override
    public boolean supports(Class clazz) {
      return User.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
      User user = (User) target;

      if(user.getName() == null) {
          errors.rejectValue("name", "your_error_code");
      }

      // do "complex" validation here

    }

}

Kemudian di controller Anda, Anda akan memiliki:

@RequestMapping(value="/user", method=RequestMethod.POST)
    public createUser(Model model, @ModelAttribute("user") User user, BindingResult result){
        UserValidator userValidator = new UserValidator();
        userValidator.validate(user, result);

        if (result.hasErrors()){
          // do something
        }
        else {
          // do something else
        }
}

Jika ada kesalahan validasi, result.hasErrors () akan benar.

Catatan: Anda juga dapat mengatur validator dalam metode @InitBinder pada controller, dengan "binder.setValidator (...)" (dalam hal ini campuran penggunaan metode 1 dan 2 tidak akan mungkin, karena Anda mengganti default validator). Atau Anda bisa instantiate di konstruktor default controller. Atau memiliki @ Component / @ Service UserValidator yang Anda masukkan (@Autowired) di controller Anda: sangat berguna, karena sebagian besar validator singletons + mengejek unit test menjadi lebih mudah + validator Anda dapat memanggil komponen Spring lainnya.

Metode 3: Mengapa tidak menggunakan kombinasi kedua metode? Validasi hal-hal sederhana, seperti atribut "nama", dengan anotasi (cepat dilakukan, ringkas, dan lebih mudah dibaca). Pertahankan validasi berat untuk validator (saat itu akan memakan waktu berjam-jam untuk kode anotasi validasi kustom kompleks, atau hanya ketika itu tidak mungkin untuk menggunakan anotasi). Saya melakukan ini pada proyek sebelumnya, itu bekerja seperti pesona, cepat & mudah.

Peringatan: Anda tidak boleh salah mengartikan penanganan validasi untuk penanganan pengecualian . Baca posting ini untuk mengetahui kapan menggunakannya.

Referensi :

• Posting blog yang sangat menarik tentang validasi kacang ( Tautan asli sudah mati)
• Posting blog bagus lainnya tentang validasi (Tautan asli sudah mati)
• Dokumentasi Spring terbaru tentang validasi

Ada dua cara untuk memvalidasi input pengguna: anotasi dan dengan mewarisi kelas Validator Musim Semi. Untuk kasus-kasus sederhana, penjelasannya bagus. Jika Anda memerlukan validasi kompleks (seperti validasi lintas-bidang, mis. Bidang "verifikasi alamat email"), atau jika model Anda divalidasi di banyak tempat dalam aplikasi Anda dengan aturan yang berbeda, atau jika Anda tidak memiliki kemampuan untuk memodifikasi memodelkan objek dengan menempatkan anotasi di atasnya, Validator berbasis warisan Spring adalah cara untuk pergi. Saya akan menunjukkan contoh keduanya.

Bagian validasi yang sebenarnya adalah sama, apa pun jenis validasinya yang Anda gunakan:

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";
}

Jika Anda menggunakan anotasi, Fookelas Anda mungkin terlihat seperti:

public class Foo {

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

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

    // getters, setters
}

Anotasi di atas adalah javax.validation.constraintsanotasi. Anda juga dapat menggunakan Hibernate org.hibernate.validator.constraints, tetapi sepertinya Anda tidak menggunakan Hibernate.

Atau, jika Anda menerapkan Validator Musim Semi, Anda akan membuat kelas sebagai berikut:

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]");
        }
    }
}

Jika menggunakan validator di atas, Anda juga harus mengikat validator ke controller Spring (tidak perlu jika menggunakan anotasi):

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

Lihat juga dokumen Spring .

Semoga itu bisa membantu.

Saya ingin menyampaikan jawaban yang bagus dari Jerome Dalbert. Saya menemukan sangat mudah untuk menulis validator anotasi Anda sendiri dengan cara JSR-303. Anda tidak dibatasi untuk memiliki validasi "satu bidang". Anda dapat membuat anotasi Anda sendiri pada level tipe dan memiliki validasi yang kompleks (lihat contoh di bawah). Saya lebih suka cara ini karena saya tidak perlu mencampur berbagai jenis validasi (Spring dan JSR-303) seperti yang dilakukan Jerome. Validator ini juga "Pegas sadar" sehingga Anda dapat menggunakan @ Suntikkan / @ Autowire di luar kotak.

Contoh validasi objek khusus:

@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 {
}

Contoh persamaan bidang generik:

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;

}

Jika Anda memiliki logika penanganan kesalahan yang sama untuk penangan metode yang berbeda, maka Anda akan berakhir dengan banyak penangan dengan pola kode berikut:

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

Misalkan Anda membuat layanan RESTful dan ingin kembali 400 Bad Requestbersama dengan pesan kesalahan untuk setiap kasus kesalahan validasi. Kemudian, bagian penanganan kesalahan akan sama untuk setiap titik akhir REST tunggal yang membutuhkan validasi. Mengulangi logika yang sama di setiap handler tidak terlalu kering !

Salah satu cara untuk mengatasi masalah ini adalah dengan menjatuhkan segera BindingResultsetelah setiap kacang To-Be-Validated . Sekarang, pawang Anda akan seperti ini:

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

Dengan cara ini, jika kacang yang diikat tidak valid, MethodArgumentNotValidExceptionakan dibuang oleh Spring. Anda bisa mendefinisikan ControllerAdviceyang menangani pengecualian ini dengan logika penanganan kesalahan yang sama:

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

Anda masih dapat memeriksa metode BindingResultmenggunakan yang mendasarinya .getBindingResultMethodArgumentNotValidException

Temukan contoh lengkap Spring Mvc Validation

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

Masukkan kacang ini di kelas konfigurasi Anda.

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

dan kemudian Anda dapat menggunakan

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

untuk memvalidasi kacang secara manual. Kemudian Anda akan mendapatkan semua hasil dalam BindingResult dan Anda dapat mengambilnya dari sana.