Spring RestController: Wie verwendet man es?

Die Spring RestController Annotation ist eine bequeme Annotation, die selbst mit @Controller und @ResponseBody annotiert ist. Diese Annotation wird auf eine Klasse angewendet, um sie als Anfragehandler zu markieren. Die Spring RestController Annotation wird verwendet, um RESTful Web Services mit Spring MVC zu erstellen. Spring RestController kümmert sich um die Zuordnung von Anfragedaten zur definierten Anfragehandler-Methode. Sobald der Antworttext von der Handlermethode generiert wird, konvertiert er ihn in eine JSON- oder XML-Antwort.

Spring RestController Beispiel

Lassen Sie uns sehen, wie einfach wir RestController verwenden können, um einen REST-Webdienst in Spring zu erstellen. Wir werden die Spring Repository-Implementierung wiederverwenden und einen RESTful-Webservice erstellen. Wir werden eine eigenständige Webanwendung erstellen und hier nicht Spring Boot verwenden. Wir werden auch unsere APIs so aussetzen, dass sie sowohl JSON als auch XML in Anfrage und Antwort unterstützen. Das folgende Bild zeigt unsere endgültige Projektstruktur.

Modell- und Repository-Klassen werden bereits im Spring Repository Tutorial bereitgestellt. Wir werden uns hier mehr auf die Implementierung von RestController konzentrieren.

Spring RestController Maven-Abhängigkeiten

Lassen Sie uns einen Blick auf die Abhängigkeiten werfen, die benötigt werden, um unser Spring RestController-Beispielprojekt zu erstellen.

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.0.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.0.7.RELEASE</version>
</dependency>

<!-- Jackson für REST JSON-Unterstützung -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.6</version>
</dependency>
<!-- JAXB für XML-Antwort, ab Java 9 explizit zu definieren -->
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.0</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.0</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>javax.activation</groupId>
    <artifactId>javax.activation-api</artifactId>
    <version>1.2.0</version>
</dependency>

Wir benötigen Spring MVC, Jackson und JAXB Bibliotheken, um sowohl XML- als auch JSON-Anfragen und -Antworten von unserem REST-Webdienst zu unterstützen. Unsere web.xml Datei wird verwendet, um Spring MVC DispatcherServlet als Front-Controller zu konfigurieren. Lassen Sie uns jetzt die Spring Context-Datei ansehen.

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans
    xmlns="https://www.springframework.org/schema/mvc"
    xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="https://www.springframework.org/schema/beans"
    xmlns:context="https://www.springframework.org/schema/context"
    xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- Aktiviert das Spring MVC @Controller Programmiermodell -->
    <annotation-driven />

    <context:component-scan
        base-package="com.journaldev.spring" />

    <beans:bean id="jsonMessageConverter"
        class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
    <beans:bean id="xmlMessageConverter"
        class="org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter" />

    <beans:bean
        class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <beans:property name="messageConverters">
            <beans:list>
                <beans:ref bean="jsonMessageConverter" />
                <beans:ref bean="xmlMessageConverter" />
            </beans:list>
        </beans:property>
    </beans:bean>

</beans:beans>

Der wichtigste Teil sind die jsonMessageConverter und xmlMessageConverter Beans, die in der messageConverters-Eigenschaft des RequestMappingHandlerAdapter definiert und gesetzt sind. Das ist alles, was nötig ist, um Spring zu sagen, dass wir wollen, dass unsere Anwendung sowohl JSON als auch XML unterstützt und dass diese Beans für die Umwandlung verwendet werden sollen.

Spring RestController Klasse

Hier ist unsere Implementierung der Spring RestController-Klasse.

package com.journaldev.spring.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.journaldev.spring.model.Employee;
import com.journaldev.spring.repository.EmployeeRepository;

@RestController
public class EmployeeRestController {

    @Autowired
    private EmployeeRepository repository;
    
    @GetMapping("/rest/employee/get/{id}")
    public Employee getEmployeeByID(@PathVariable("id") int id) {
        return repository.retrieve(id);
    }
    
    @GetMapping("/rest/employee/getAll")
    public List<Employee> getAllEmployees() {
        return repository.getAll();
    }

    @PostMapping("/rest/employee/create")
    public Employee createEmployee(@RequestBody Employee emp) {
        repository.store(emp);
        return emp;
    }
    
    @GetMapping("/rest/employee/search/{name}")
    public Employee getEmployeeByName(@PathVariable("name") String name) {
        return repository.search(name);
    }
    
    @DeleteMapping("/rest/employee/delete/{id}")
    public Employee deleteEmployeeByID(@PathVariable("id") int id) {
        return repository.delete(id);
    }
}

Beachten Sie, dass wir hier nur unsere REST-APIs definiert haben, die gesamte Geschäftslogik ist Teil der Repository-Klasse…

Accept und Content-Type Anfrage-Header

Wir haben unsere REST-Anwendung so konfiguriert, dass sie sowohl mit XML als auch JSON funktioniert. Also wie wird sie wissen, ob die Anfrage XML oder JSON ist, und ob die Antwort im JSON- oder XML-Format gesendet werden soll. Hier kommen die Accept- und Content-Type Anfrage-Header ins Spiel. Content-Type: Definiert den Typ des Inhalts im Anfragekörper, wenn sein Wert “application/xml” ist, dann wird Spring den Anfragekörper als XML-Dokument behandeln. Wenn sein Wert “application/json” ist, wird der Anfragekörper als JSON behandelt. Accept: Definiert den Typ des Inhalts, den der Client als Antwort erwartet. Wenn sein Wert “application/xml” ist, wird eine XML-Antwort gesendet. Wenn sein Wert “application/json” ist, wird eine JSON-Antwort gesendet.

Spring RestController Test

Unsere Anwendung ist bereit für einen Test, ich habe sie auf Tomcat-9 bereitgestellt und teste mit Postman. Unten sind die Testergebnisse mit Erklärung.

Spring RestController GET JSON-Antwort

Es ist eine einfache GET-Anfrage, der wichtige Punkt ist der Wert des “Accept”-Headers.

Spring RestController GET XML-Antwort

Wenn wir den Wert des “Accept”-Headers auf “application/xml” ändern, erhalten wir eine XML-Antwort.

Spring RestController GET Liste

Lassen Sie uns versuchen, die API aufzurufen, um eine Liste von Mitarbeitern zu erhalten. Wir erhalten eine Liste von Elementen in JSON mit einem anonymen Wurzelelement. Da XML keine anonymen Wurzelelemente unterstützt, erhalten wir eine Ausnahmemeldung.

Spring RestController POST

Spring RestController POST mit JSON-Anfrage und -Antwort

Spring RestController POST mit JSON-Anfragekörper

Spring RestController POST mit JSON-Anfrage und XML-Antwort

Spring RestController DELETE

Zusammenfassung

Spring RestController hilft uns, uns auf die Geschäftslogik zu konzentrieren, indem er sich um alle Boilerplate-Arbeiten für die Erstellung von REST-Webdienst-APIs kümmert.