Panduan Lengkap Spring Boot 4 · Pelajaran

Kekangan Pengesahan Bean dan Kumpulan Kekangan

Gunakan anotasi Pengesahan Bean Jakarta dengan pengumpulan untuk menguatkuasakan peraturan khusus konteks.

Pelajaran 1 daripada 413 langkah

Kekangan Pengesahan Bean dan Kumpulan Kekangan ialah pelajaran Panduan Lengkap Spring Boot 4 percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Panduan Lengkap Spring Boot 4, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Panduan Lengkap Spring Boot 4 merangkumi sejumlah 4 pelajaran.

Mengapa Bean Validation?

Dalam aplikasi Spring Boot 4, anda sentiasa menerima data yang tidak dipercayai: badan permintaan, parameter pertanyaan dan penghantaran borang. Jakarta Bean Validation (API jakarta.validation) membolehkan anda mengisytiharkan peraturan sebagai anotasi terus pada medan model, berbanding menulis semakan if secara manual di merata tempat.

Pengisytiharan — peraturan diletakkan bersebelahan dengan medan yang dilindunginya.
Berpusat — Spring mencetuskan pengesahan secara automatik pada sempadan pengawal.
Konsisten — kelas beranotasi yang sama boleh disahkan dalam lapisan web, lapisan perkhidmatan atau lapisan ketekalan.

Pelaksanaan rujukan di sebalik API ini ialah Hibernate Validator, yang dimasukkan melalui kebergantungan spring-boot-starter-validation.

Menambah Starter

Pengesahan tidak lagi disertakan bersama starter web, jadi anda mesti menambahkannya secara jelas. Setelah tersedia, Hibernate Validator dikonfigurasi secara automatik dan Spring menyediakan bean Validator untuk anda.

Tambahkan kebergantungan itu pada pom.xml anda:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Menganotasi DTO

Anda melampirkan kekangan pada medan Data Transfer Object. Setiap anotasi mempunyai message pilihan dan parameter pengesahan.

@NotBlank — rentetan mesti mengandungi sekurang-kurangnya satu aksara bukan ruang kosong.
@Email — mesti kelihatan seperti alamat e-mel yang sah.
@Size(min, max) — panjang mesti berada dalam julat yang ditetapkan.
@Min / @Max — had berangka.

public class UserRegistrationRequest {

    @NotBlank(message = "Username is required")
    @Size(min = 3, max = 20)
    private String username;

    @NotBlank
    @Email(message = "Provide a valid email")
    private String email;

    @Min(value = 18, message = "Must be at least 18")
    private int age;

    // getters and setters
}

Mencetuskan Pengesahan dengan @Valid

Menganotasi DTO sahaja tidak melakukan apa-apa. Anda mesti memberitahu Spring untuk mengesahkan argumen dengan meletakkan @Valid pada parameter kaedah pengawal. Jika pengesahan gagal, Spring melontarkan MethodArgumentNotValidException sebelum badan kaedah anda dijalankan dan mengembalikan 400 Bad Request.

@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping
    public ResponseEntity<String> register(
            @Valid @RequestBody UserRegistrationRequest request) {
        // reaches here only if all constraints pass
        return ResponseEntity.ok("Registered " + request.getUsername());
    }
}

Masalahnya: Satu DTO, Banyak Konteks

Bayangkan UserRegistrationRequest yang sama digunakan semula untuk dua operasi:

Penciptaan — klien MESTI TIDAK menghantar id (pelayan menjana nilai tersebut).
Kemas kini — klien MESTI menghantar id sedia ada untuk menentukan perkara yang hendak diubah.

Medan yang sepatutnya @Null semasa penciptaan tetapi @NotNull semasa kemas kini tidak boleh dinyatakan dengan anotasi biasa kerana anotasi tersebut sentiasa dijalankan. Inilah masalah yang diselesaikan oleh kumpulan kekangan.

Mentakrifkan Kumpulan Kekangan

Kumpulan kekangan hanyalah antara muka penanda — antara muka kosong yang digunakan semata-mata sebagai tanda. Anda mencipta satu kumpulan untuk setiap konteks pengesahan.

Setiap anotasi kekangan menerima atribut groups. Apabila anda menetapkan kekangan kepada suatu kumpulan, kekangan itu hanya dijalankan apabila pengesahan diminta untuk kumpulan tersebut.

public interface OnCreate {}

public interface OnUpdate {}

Menetapkan Kekangan kepada Kumpulan

Kini tandakan setiap kekangan dengan kumpulan yang dianggotainya. Kekangan yang tidak mempunyai atribut groups secara tersirat tergolong dalam kumpulan terbina dalam Default dan dijalankan melainkan anda menukar kumpulan.

Di sini medan id mematuhi peraturan yang bertentangan bergantung pada konteks:

public class ProductRequest {

    @Null(groups = OnCreate.class,
          message = "id must be empty when creating")
    @NotNull(groups = OnUpdate.class,
             message = "id is required when updating")
    private Long id;

    @NotBlank(groups = {OnCreate.class, OnUpdate.class})
    private String name;

    @Positive(groups = {OnCreate.class, OnUpdate.class})
    private BigDecimal price;

    // getters and setters
}

Memilih Kumpulan dengan @Validated

Inilah perbezaan penting: @Valid sentiasa mengesahkan kumpulan Default sahaja dan tidak boleh memilih kumpulan. Untuk mengaktifkan kumpulan tertentu, anda mesti menggunakan anotasi Spring @Validated, yang menerima kelas kumpulan sasaran.

Setiap titik akhir memilih kumpulan yang sepadan dengan operasinya:

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @PostMapping
    public ResponseEntity<Void> create(
            @Validated(OnCreate.class) @RequestBody ProductRequest req) {
        // @Null id, @NotBlank name, @Positive price enforced
        return ResponseEntity.status(HttpStatus.CREATED).build();
    }

    @PutMapping
    public ResponseEntity<Void> update(
            @Validated(OnUpdate.class) @RequestBody ProductRequest req) {
        // @NotNull id enforced instead
        return ResponseEntity.ok().build();
    }
}

@Valid berbanding @Validated

Pasangan ini sering mengelirukan ramai pembangun, jadi ingatlah dengan baik:

@Valid — berasal daripada jakarta.validation. Berfungsi pada medan untuk pengesahan bersarang/berantai, tetapi tidak boleh menentukan kumpulan (menggunakan Default).
@Validated — berasal daripada org.springframework.validation.annotation. Menerima kelas kumpulan dan turut mengaktifkan pengesahan pada peringkat kaedah untuk bean Spring. Tidak boleh diletakkan pada medan untuk pengesahan berantai.

Peraturan umum: gunakan @Validated(Group.class) pada parameter pengawal untuk memilih kumpulan; gunakan @Valid pada medan objek dalaman untuk mengesahkan objek tersebut secara berantai.

Pengesahan Berantai dan Urutan Kumpulan

Dua keperluan lanjutan sering muncul:

Pengesahan berantai — untuk mengesahkan objek bersarang, tandakan medannya dengan @Valid. Tanpanya, kekangan objek bersarang akan dilangkau.
Penyusunan — @GroupSequence menjalankan kumpulan mengikut urutan dan berhenti pada kumpulan pertama yang gagal, supaya anda boleh melaksanakan semakan murah sebelum semakan mahal.

@GroupSequence({First.class, Second.class})
public interface OrderedChecks {}

public class OrderRequest {

    @NotEmpty(groups = First.class)
    private List<@Valid LineItem> items; // @Valid cascades into each item

    @AssertTrue(groups = Second.class,
                message = "Total must match line items")
    public boolean isTotalConsistent() {
        return /* expensive cross-field check */ true;
    }
}

Membaca Ralat

Apabila pengesahan berkumpulan gagal, MethodArgumentNotValidException yang terhasil masih membawa BindingResult standard. Anda boleh menukarkannya kepada respons JSON yang kemas dengan pengendali @RestControllerAdvice, yang memetakan setiap medan kepada mesejnya.

@RestControllerAdvice
public class ValidationExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public Map<String, String> handle(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(err ->
                errors.put(err.getField(), err.getDefaultMessage()));
        return errors;
    }
}

Semakan Pantas

Uji pemahaman anda tentang cara Spring memilih kumpulan kekangan.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari cara menguatkuasakan peraturan pengesahan khusus konteks dengan Jakarta Bean Validation dalam Spring Boot 4:

Tambahkan spring-boot-starter-validation, kemudian anotasi medan DTO dengan kekangan seperti @NotBlank, @Email, @Size dan @Min.
Cetuskan pengesahan pada sempadan pengawal; kegagalan menghasilkan 400 melalui MethodArgumentNotValidException.
Kumpulan kekangan ialah antara muka penanda yang ditetapkan melalui atribut groups setiap anotasi, yang membolehkan satu DTO membawa peraturan berbeza bagi setiap operasi (contohnya @Null semasa penciptaan berbanding @NotNull semasa kemas kini).
Gunakan @Validated(Group.class) untuk memilih kumpulan — @Valid hanya menjalankan kumpulan Default dan digunakan untuk pengesahan berantai terhadap objek bersarang.
@GroupSequence menyusun kumpulan dan berhenti apabila kegagalan pertama berlaku; @Valid pada koleksi mengesahkan setiap elemen secara berantai.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 21
Pelajaran: 84

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Kekangan Pengesahan Bean dan Kumpulan Kekangan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Panduan Lengkap Spring Boot 4, termasuk “Kekangan Pengesahan Bean dan Kumpulan Kekangan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Panduan Lengkap Spring Boot 4 merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Kekangan Pengesahan Bean dan Kumpulan Kekangan”?

Gunakan anotasi Pengesahan Bean Jakarta dengan pengumpulan untuk menguatkuasakan peraturan khusus konteks. Anda berlatih Panduan Lengkap Spring Boot 4 menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Panduan Lengkap Spring Boot 4?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Panduan Lengkap Spring Boot 4 di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Kekangan Pengesahan Bean dan Kumpulan Kekangan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Panduan Lengkap Spring Boot 4 ini?

Ya. Setiap pelajaran Panduan Lengkap Spring Boot 4 menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Kekangan Pengesahan Bean dan Kumpulan Kekangan
Membina Anotasi Kekangan Tersuai
Pengendalian Pengecualian Global dengan @ControllerAdvice
Tindak Balas Butiran Masalah RFC 7807

← Kembali ke Panduan Lengkap Spring Boot 4