Spring Web Annotations

Dieser Artikel ist Teil einer Reihe: • Spring Core Annotations

• Spring Web Annotations (aktueller Artikel) • Spring Boot Annotations

• Anmerkungen zur Frühlingsplanung

• Frühlingsdatenanmerkungen

• Anmerkungen zu Spring Bean

1. Übersicht

In diesem Tutorial werden wir Spring Web-Annotationen aus dem org.springframework.web.bind.annotation- Paket untersuchen.

2. @RequestMapping

Einfach ausgedrückt markiert @RequestMapping Anforderungshandler-Methoden in @ Controller- Klassen. Es kann konfiguriert werden mit:

  • Pfad oder seine Aliase, Name und Wert: Welcher URL ist die Methode zugeordnet?
  • Methode: kompatible HTTP-Methoden
  • params: Filtert Anforderungen basierend auf Vorhandensein, Fehlen oder Wert von HTTP-Parametern
  • Header: Filtert Anforderungen basierend auf Vorhandensein, Fehlen oder Wert von HTTP-Headern
  • verbraucht: Welche Medientypen kann die Methode im HTTP-Anforderungshauptteil verwenden?
  • Erzeugt: Welche Medientypen kann die Methode im HTTP-Antworttext erzeugen?

Hier ist ein kurzes Beispiel dafür, wie das aussieht:

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

Wir können Standardeinstellungen für alle Handler-Methoden in einer @ Controller- Klasse bereitstellen , wenn wir diese Annotation auf Klassenebene anwenden. Die einzige Ausnahme ist die URL, die Spring nicht mit Einstellungen auf Methodenebene überschreibt, sondern die beiden Pfadteile anfügt.

Die folgende Konfiguration hat beispielsweise den gleichen Effekt wie die obige:

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

Darüber hinaus sind @GetMapping , @PostMapping , @PutMapping , @DeleteMapping und @PatchMapping verschiedene Varianten von @RequestMapping, wobei die HTTP-Methode bereits auf GET, POST, PUT, DELETE bzw. PATCH festgelegt ist.

Diese sind seit der Veröffentlichung von Spring 4.3 verfügbar.

3. @RequestBody

Fahren wir mit @RequestBody fort, der den Hauptteil der HTTP-Anforderung einem Objekt zuordnet :

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

Die Deserialisierung erfolgt automatisch und hängt vom Inhaltstyp der Anforderung ab.

4. @PathVariable

Lassen Sie uns als nächstes über @PathVariable sprechen .

Diese Anmerkung gibt an, dass ein Methodenargument an eine URI-Vorlagenvariable gebunden ist . Wir können die URI-Vorlage mit der Annotation @RequestMapping angeben und mit @PathVariable ein Methodenargument an einen der Vorlagenteile binden .

Dies erreichen wir mit dem Namen oder dem Alias, der Wert Argumente:

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

Wenn der Name des Teils in der Vorlage mit dem Namen des Methodenarguments übereinstimmt, müssen wir ihn nicht in der Anmerkung angeben:

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

Darüber hinaus können wir eine Pfadvariable optional markieren, indem wir das erforderliche Argument auf false setzen:

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

5. @RequestParam

Wir verwenden @RequestParam für den Zugriff auf HTTP-Anforderungsparameter :

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

Es verfügt über dieselben Konfigurationsoptionen wie die Annotation @PathVariable .

Zusätzlich zu diesen Einstellungen können wir mit @RequestParam einen injizierten Wert angeben, wenn Spring keinen oder einen leeren Wert in der Anforderung findet. Um dies zu erreichen, müssen wir das Argument defaultValue setzen .

Die Bereitstellung eines Standardwert implizit Sätze erforderlich , um false:

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

Neben den Parametern gibt es noch andere HTTP-Anforderungsteile, auf die wir zugreifen können: Cookies und Header . Wir können mit den Anmerkungen @CookieValue und @RequestHeader auf sie zugreifen .

Wir können sie genauso konfigurieren wie @RequestParam .

6. Anmerkungen zur Antwortbehandlung

In den nächsten Abschnitten werden die häufigsten Anmerkungen zum Bearbeiten von HTTP-Antworten in Spring MVC angezeigt.

6.1. @ResponseBody

Wenn wir eine Request-Handler-Methode mit @ResponseBody markieren, behandelt Spring das Ergebnis der Methode als Antwort selbst :

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

Wenn wir eine @ Controller- Klasse mit dieser Annotation versehen, wird sie von allen Request-Handler-Methoden verwendet.

6.2. @ExceptionHandler

Mit dieser Anmerkung können wir eine benutzerdefinierte Fehlerbehandlungsmethode deklarieren . Spring ruft diese Methode auf, wenn eine Request-Handler-Methode eine der angegebenen Ausnahmen auslöst.

Die abgefangene Ausnahme kann als Argument an die Methode übergeben werden:

@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.

Weitere Informationen finden Sie in diesem Artikel.

8. Fazit

In diesem Artikel haben wir gesehen, wie wir mit Spring MVC mit HTTP-Anforderungen und -Antworten umgehen können.

Wie üblich sind die Beispiele auf GitHub verfügbar.

Weiter » Spring Boot Annotations « Vorherige Spring Core Annotations