Anotasi Web Musim Semi

Artikel ini bagian dari serial: • Spring Core Annotations

• Anotasi Spring Web (artikel saat ini) • Anotasi Spring Boot

• Penjadwalan Penjadwalan Musim Semi

• Anotasi Data Musim Semi

• Anotasi Spring Bean

1. Ikhtisar

Dalam tutorial ini, kita akan menjelajahi anotasi Spring Web dari paket org.springframework.web.bind.annotation .

2. @Meminta Pemetaan

Sederhananya, @RequestMapping menandai metode penangan permintaan di dalam kelas @Controller ; itu dapat dikonfigurasi menggunakan:

  • path, atau alias, nama, dan nilainya: ke URL mana metode dipetakan
  • metode: metode HTTP yang kompatibel
  • params: memfilter permintaan berdasarkan ada, tidak ada, atau nilai parameter HTTP
  • headers: memfilter permintaan berdasarkan keberadaan, ketidakhadiran, atau nilai header HTTP
  • konsumsi: jenis media mana yang dapat digunakan metode dalam isi permintaan HTTP
  • menghasilkan: jenis media mana yang dapat dihasilkan metode dalam isi respons HTTP

Berikut contoh singkat tampilannya:

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

Kita dapat menyediakan pengaturan default untuk semua metode penangan dalam kelas @Controller jika kita menerapkan anotasi ini pada tingkat kelas. Satu-satunya pengecualian adalah URL yang tidak akan diganti oleh Spring dengan setelan tingkat metode tetapi menambahkan dua bagian jalur.

Misalnya, konfigurasi berikut memiliki efek yang sama seperti di atas:

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

Selain itu, @GetMapping , @PostMapping , @PutMapping , @DeleteMapping , dan @PatchMapping adalah varian berbeda dari @RequestMapping dengan metode HTTP yang masing-masing telah disetel ke GET, POST, PUT, DELETE, dan PATCH.

Ini tersedia sejak rilis Spring 4.3.

3. @Requody

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

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

Deserialisasi dilakukan secara otomatis dan bergantung pada jenis konten permintaan.

4. @PathVable

Selanjutnya, mari kita bahas tentang @PathVariable .

Anotasi ini menunjukkan bahwa argumen metode terikat ke variabel template URI . Kita bisa menentukan template URI dengan anotasi @RequestMapping dan mengikat argumen metode ke salah satu bagian template dengan @PathVariable .

Kita bisa mencapai ini dengan nama atau aliasnya, argumen nilai :

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

Jika nama bagian dalam template cocok dengan nama argumen metode, kita tidak perlu menentukannya di anotasi:

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

Selain itu, kami dapat menandai variabel jalur opsional dengan menyetel 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) { // ... }

It has the same configuration options as the @PathVariable annotation.

In addition to those settings, with @RequestParam we can specify an injected value when Spring finds no or empty value in the request. To achieve this, we have to set the defaultValue argument.

Providing a default value implicitly sets required to false:

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

Besides parameters, there are other HTTP request parts we can access: cookies and headers. We can access them with the annotations @CookieValue and @RequestHeader respectively.

We can configure them the same way as @RequestParam.

6. Response Handling Annotations

In the next sections, we will see the most common annotations to manipulate HTTP responses in Spring MVC.

6.1. @ResponseBody

If we mark a request handler method with @ResponseBody,Spring treats the result of the method as the response itself:

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

If we annotate a @Controller class with this annotation, all request handler methods will use it.

6.2. @ExceptionHandler

With this annotation, we can declare a custom error handler method. Spring calls this method when a request handler method throws any of the specified exceptions.

The caught exception can be passed to the method as an argument:

@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 lebih jelasnya, silakan kunjungi artikel ini.

8. Kesimpulan

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

Seperti biasa, contoh tersedia di GitHub.

Berikutnya » Anotasi Spring Boot « Anotasi Spring Core Sebelumnya