Anotasi Web Spring

Pengaturcaraan
Artikel ini adalah sebahagian daripada siri: • Anotasi Inti Musim Semi

• Anotasi Web Spring (artikel semasa) • Anotasi Boot Musim Semi

• Anotasi Penjadualan Musim Bunga

• Anotasi Data Musim Semi

• Anotasi Kacang Musim Bunga

1. Gambaran keseluruhan

Dalam tutorial ini, kita akan meneroka anotasi Spring Web dari pakej pemberitahuan org.springframework.web.bind.annotation .

2. @ Pemetaan Permintaan

Ringkasnya, tanda @RequestMapping meminta kaedah pengendali di dalam kelas @Controller ; ia boleh dikonfigurasi menggunakan:

  • jalan, atau nama samaran, nama, dan nilainya: URL mana kaedahnya dipetakan
  • kaedah: kaedah HTTP yang serasi
  • parameter : menapis permintaan berdasarkan kehadiran, ketiadaan, atau nilai parameter HTTP
  • tajuk: menapis permintaan berdasarkan kehadiran, ketiadaan, atau nilai tajuk HTTP
  • menggunakan: media mana yang menaip kaedah yang boleh digunakan dalam badan permintaan HTTP
  • menghasilkan: jenis media mana kaedah yang boleh dihasilkan dalam badan respons HTTP

Berikut adalah contoh ringkas seperti apa:

@Controller class VehicleController { @RequestMapping(value = "/vehicles/home", method = RequestMethod.GET) String home() { return "home"; } }

Kami boleh menyediakan tetapan lalai untuk semua kaedah pengendali dalam kelas @Controller jika kami menerapkan anotasi ini di peringkat kelas. Satu-satunya pengecualian adalah URL yang tidak akan diganti oleh Spring dengan tetapan tahap kaedah tetapi menambahkan dua bahagian jalan.

Sebagai contoh, konfigurasi berikut mempunyai kesan yang sama seperti yang di atas:

@Controller @RequestMapping(value = "/vehicles", method = RequestMethod.GET) class VehicleController { @RequestMapping("/home") String home() { return "home"; } }

Lebih-lebih lagi, @GetMapping , @PostMapping , @PutMapping , @DeleteMapping , dan @PatchMapping adalah varian berbeza @RequestMapping dengan kaedah HTTP yang telah ditetapkan masing-masing ke GET, POST, PUT, DELETE, dan PATCH.

Ini tersedia sejak keluaran Spring 4.3.

3. @RequestBody

Mari beralih ke @RequestBody - yang memetakan badan permintaan HTTP ke objek :

@PostMapping("/save") void saveVehicle(@RequestBody Vehicle vehicle) { // ... }

Deserialisasi adalah automatik dan bergantung pada jenis kandungan permintaan.

4. @PathVariable

Seterusnya, mari kita bincangkan mengenai @PathVariable .

Anotasi ini menunjukkan bahawa argumen kaedah terikat dengan pemboleh ubah templat URI . Kita dapat menentukan templat URI dengan anotasi @RequestMapping dan mengikat argumen kaedah ke salah satu bahagian templat dengan @PathVariable .

Kita dapat mencapainya dengan nama atau aliasnya, argumen nilai :

@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable("id") long id) { // ... }

Sekiranya nama bahagian dalam templat sepadan dengan nama argumen kaedah, kita tidak perlu menentukannya dalam anotasi:

@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable long id) { // ... }

Lebih-lebih lagi, kita dapat menandakan pemboleh ubah jalur sebagai pilihan dengan menetapkan argumen yang diperlukan menjadi salah:

@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable(required = false) long id) { // ... }

5. @RequestParam

Kami menggunakan @RequestParam untuk mengakses parameter permintaan HTTP :

@RequestMapping Vehicle getVehicleByParam(@RequestParam("id") long id) { // ... }

Ia mempunyai pilihan konfigurasi yang sama dengan anotasi @PathVariable .

Sebagai tambahan kepada tetapan tersebut, dengan @RequestParam kita dapat menentukan nilai yang disuntikkan ketika Spring tidak menemui nilai kosong atau tidak dalam permintaan. Untuk mencapainya, kita harus menetapkan argumen defaultValue .

Memberikan nilai lalai secara tersirat disyaratkan kepada false:

@RequestMapping("/buy") Car buyCar(@RequestParam(defaultValue = "5") int seatCount) { // ... }

Selain parameter, ada bahagian permintaan HTTP lain yang dapat kita akses: kuki dan tajuk . Kami boleh mengaksesnya dengan anotasi @CookieValue dan @RequestHeader masing-masing.

Kami boleh mengkonfigurasinya dengan cara yang sama seperti @RequestParam .

6. Anotasi Pengendalian Respons

Pada bahagian seterusnya, kita akan melihat anotasi yang paling biasa untuk memanipulasi respons HTTP di Spring MVC.

6.1. @ResponseBody

Sekiranya kita menandakan kaedah pengendali permintaan dengan @ResponseBody, Spring menganggap hasil kaedah itu sebagai tindak balas itu sendiri :

@ResponseBody @RequestMapping("/hello") String hello() { return "Hello World!"; }

Sekiranya kita memberi anotasi kelas @Controller dengan anotasi ini, semua kaedah pengendali permintaan akan menggunakannya.

6.2. @ExceptionHandler

Dengan penjelasan ini, kami dapat menyatakan kaedah pengendali ralat tersuai . Spring memanggil kaedah ini apabila kaedah pengendali permintaan membuang pengecualian yang ditentukan.

Pengecualian yang ditangkap dapat diteruskan ke metode sebagai argumen:

@ExceptionHandler(IllegalArgumentException.class) void onIllegalArgumentException(IllegalArgumentException exception) { // ... }

6.3. @ResponseStatus

We can specify the desired HTTP status of the response if we annotate a request handler method with this annotation. We can declare the status code with the code argument, or its alias, the value argument.

Also, we can provide a reason using the reason argument.

We also can use it along with @ExceptionHandler:

@ExceptionHandler(IllegalArgumentException.class) @ResponseStatus(HttpStatus.BAD_REQUEST) void onIllegalArgumentException(IllegalArgumentException exception) { // ... }

For more information about HTTP response status, please visit this article.

7. Other Web Annotations

Some annotations don't manage HTTP requests or responses directly. In the next sections, we'll introduce the most common ones.

7.1. @Controller

We can define a Spring MVC controller with @Controller. For more information, please visit our article about Spring Bean Annotations.

7.2. @RestController

The @RestControllercombines @Controller and @ResponseBody.

Therefore, the following declarations are equivalent:

@Controller @ResponseBody class VehicleRestController { // ... }
@RestController class VehicleRestController { // ... }

7.3. @ModelAttribute

With this annotation we can access elements that are already in the model of an MVC @Controller, by providing the model key:

@PostMapping("/assemble") void assembleVehicle(@ModelAttribute("vehicle") Vehicle vehicleInModel) { // ... }

Like with @PathVariable and @RequestParam, we don't have to specify the model key if the argument has the same name:

@PostMapping("/assemble") void assembleVehicle(@ModelAttribute Vehicle vehicle) { // ... }

Besides, @ModelAttribute has another use: if we annotate a method with it, Spring will automatically add the method's return value to the model:

@ModelAttribute("vehicle") Vehicle getVehicle() { // ... }

Like before, we don't have to specify the model key, Spring uses the method's name by default:

@ModelAttribute Vehicle vehicle() { // ... }

Before Spring calls a request handler method, it invokes all @ModelAttribute annotated methods in the class.

More information about @ModelAttribute can be found in this article.

7.4. @CrossOrigin

@CrossOriginenables cross-domain communication for the annotated request handler methods:

@CrossOrigin @RequestMapping("/hello") String hello() { return "Hello World!"; }

If we mark a class with it, it applies to all request handler methods in it.

We can fine-tune CORS behavior with this annotation's arguments.

Untuk maklumat lebih lanjut, sila lawati artikel ini.

8. Kesimpulannya

Dalam artikel ini, kami melihat bagaimana kami dapat menangani permintaan dan respons HTTP dengan Spring MVC.

Seperti biasa, contohnya terdapat di GitHub.

Seterusnya » Anotasi Musim Semi Musim Semi « Anotasi Teras Musim Semi Sebelumnya