Vårens webbnoteringar

Den här artikeln är en del av en serie: • Spring Core Annotations

• Webbnoteringar om våren (aktuell artikel) • Kommentarer om vårstarten

• Kommentarer om vårplanering

• Kommentarer om vårdata

• Kommentarer om vårbönor

1. Översikt

I den här självstudien kommer vi att utforska Spring Web-anteckningar från org.springframework.web.bind.annotation- paketet.

2. @RequestMapping

Enkelt uttryckt, @RequestMapping markerar begäran om hanteringsmetoder i @Controller- klasser; den kan konfigureras med:

  • sökväg, eller dess alias, namn och värde: vilken URL metoden är mappad till
  • metod: kompatibla HTTP-metoder
  • params: filtrerar förfrågningar baserat på närvaro, frånvaro eller värde på HTTP-parametrar
  • rubriker: filtrerar förfrågningar baserat på närvaro, frånvaro eller värde för HTTP-rubriker
  • förbrukar: vilka mediatyper metoden kan konsumera i HTTP-begäran
  • producerar: vilka mediatyper metoden kan producera i HTTP-svarskroppen

Här är ett snabbt exempel på hur det ser ut:

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

Vi kan tillhandahålla standardinställningar för alla hanteringsmetoder i en @Controller- klass om vi använder denna kommentar på klassnivå. Det enda undantaget är webbadressen som Spring inte kommer att åsidosätta med metodnivåinställningar men lägger till de två sökvägsdelarna.

Till exempel har följande konfiguration samma effekt som den ovan:

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

Dessutom är @GetMapping , @PostMapping , @PutMapping , @DeleteMapping och @PatchMapping olika varianter av @RequestMapping med HTTP-metoden som redan är inställd på GET, POST, PUT, DELETE respektive PATCH.

Dessa är tillgängliga sedan våren 4.3 släpptes.

3. @RequestBody

Låt oss gå vidare till @RequestBody - som kartlägger HTTP- begärans kropp till ett objekt :

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

Deserialiseringen är automatisk och beror på innehållstypen på begäran.

4. @PathVariable

Låt oss sedan prata om @PathVariable .

Denna kommentar indikerar att ett metodargument är bundet till en URI-mallvariabel . Vi kan specificera URI-mallen med @RequestMapping- anteckningen och binda ett metodargument till en av malldelarna med @PathVariable .

Vi kan uppnå detta med namn eller dess alias, det värde argument:

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

Om namnet på delen i mallen matchar namnet på metodargumentet behöver vi inte ange det i kommentaren:

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

Dessutom kan vi markera en sökvariabel som valfri genom att ställa in det argument som krävs för att vara falskt:

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

5. @RequestParam

Vi använder @RequestParam för att komma åt parametrar för HTTP-begäran :

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

Den har samma konfigurationsalternativ som @PathVariable- anteckningen.

Förutom dessa inställningar kan vi med @RequestParam ange ett injicerat värde när Spring inte hittar något eller tomt värde i begäran. För att uppnå detta måste vi ställa in defaultValue- argumentet.

Tillhandahåller ett standardvärde som implicit sätter krävs till falskt:

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

Förutom parametrar finns det andra HTTP-förfrågningsdelar vi kan komma åt: cookies och rubriker . Vi kan komma åt dem med anteckningarna @CookieValue respektive @RequestHeader .

Vi kan konfigurera dem på samma sätt som @RequestParam .

6. Kommentarer om svarshantering

I nästa avsnitt kommer vi att se de vanligaste anteckningarna för att manipulera HTTP-svar i Spring MVC.

6.1. @ResponseBody

Om vi ​​markerar en begäranhanteringsmetod med @ResponseBody, behandlar Spring resultatet av metoden som själva svaret :

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

Om vi ​​antecknar en klass @Controller med den här anteckningen kommer alla förfrågningshanteringsmetoder att använda den.

6.2. @ExceptionHandler

Med denna kommentar kan vi deklarera en anpassad felhanteringsmetod . Spring anropar den här metoden när en begäranhanteringsmetod ger något av de angivna undantagen.

Det fångade undantaget kan skickas till metoden som ett 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.

Mer information finns i den här artikeln.

8. Slutsats

I den här artikeln såg vi hur vi kan hantera HTTP-förfrågningar och svar med Spring MVC.

Som vanligt finns exemplen tillgängliga på GitHub.

Nästa » Spring Boot Annotations « Tidigare Spring Core-kommentarer