Spring RestController

Tutorials

Spring

Spring RestController-Annotation ist eine Komfortannotation, die selbst mit @Controller und @ResponseBody annotiert ist. Diese Annotation wird auf eine Klasse angewendet, um sie als Anforderungsverarbeiter zu kennzeichnen. Die Spring RestController-Annotation wird verwendet, um RESTful Webdienste mit Spring MVC zu erstellen. Der Spring RestController kümmert sich um die Zuordnung von Anforderungsdaten zur definierten Methode des Anforderungsverarbeiters. Sobald der Antwortkörper aus der Handlermethode generiert wurde, wandelt er ihn in eine JSON- oder XML-Antwort um.

Beispiel für Spring RestController

Lassen Sie uns sehen, wie einfach wir RestController verwenden können, um einen REST-Webdienst in Spring zu erstellen. Wir werden die Implementierung des Spring Repository wiederverwenden und einen RESTful-Webservice erstellen. Wir werden eine eigenständige Webanwendung erstellen und hier kein Spring Boot verwenden. Wir werden auch unsere APIs freigeben, um sowohl JSON als auch XML in Anforderung und Antwort zu unterstützen. Das unten stehende Bild zeigt unsere endgültige Projektstruktur. Modell- und Repository-Klassen sind bereits im Spring Repository-Tutorial bereitgestellt. Hier werden wir uns mehr auf die Implementierung des RestControllers konzentrieren.

Frühling RestController Maven Abhängigkeiten

Lassen Sie uns einen Blick auf die Abhängigkeiten werfen, die erforderlich sind, um unser Beispielprojekt für den Spring RestController 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 for REST JSON Support -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.9.6</version>
</dependency>
<!-- JAXB for XML Response, needed to explicitly define from Java 9 onwards -->
<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 die 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 den Spring MVC DispatcherServlet als Front-Controller zu konfigurieren. Schauen wir uns jetzt die Spring-Kontextdatei an.

<?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">

	<!-- Enables the Spring MVC @Controller programming model -->
	<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 im RequestMappingHandlerAdapter messageConverters Eigenschaft definiert und festgelegt sind. Das ist alles, was benötigt wird, um Spring mitzuteilen, dass wir möchten, dass unsere Anwendung sowohl JSON als auch XML unterstützt, und dass dies die Beans sind, die für die Transformation 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")
	//Das Zurückgeben einer Liste wird nur mit JSON-Antwort unterstützt
	//Wenn Sie XML möchten, fügen Sie eine Wrapper-Klasse als Root-XML-Element hinzu, zum Beispiel EmployeeList
	public List 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. Wenn unsere Methode eine Liste oder ein Array zurückgibt, unterstützt Spring nur JSON als Antwort, da das XML-Stammelement nicht anonym sein kann, JSON jedoch kann. Wenn Sie eine Rückgabe von Listen als XML unterstützen möchten, müssen Sie eine Wrapper-Klasse erstellen, um diese Liste zu halten und zurückzugeben. In einigen der Methoden erwarten wir ein Employee-Objekt als Anfrage. Spring kümmert sich um das Parsen des Anfragekörpers und die Konvertierung in das Employee-Objekt für diese Methoden. Ebenso geben wir ein Employee-Objekt als Antwortkörper zurück, auch hier kümmert sich Spring um die Konvertierung in JSON/XML-Antworten.

Accept- und Content-Type-Anforderungsheader

Wir haben unsere REST-Anwendung so konfiguriert, dass sie sowohl mit XML als auch mit JSON funktioniert. Wie soll sie jedoch 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-Anforderungsheader ins Spiel. Content-Type: Definiert den Typ des Inhalts im Anfragekörper. Wenn sein Wert „application/xml“ ist, behandelt Spring den Anfragekörper als XML-Dokument. 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 zum Testen. Ich habe sie auf Tomcat-9 bereitgestellt und teste sie mit Postman. Nachfolgend finden Sie die Testergebnisse mit Erklärungen.

Spring RestController GET JSON Response

Es handelt sich um eine einfache GET-Anfrage. Der wichtige Punkt ist der Wert des „Accept“-Headers.

Spring RestController GET XML Response

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

Spring RestController GET List

Lassen Sie uns versuchen, die API aufzurufen, um die Liste der Mitarbeiter zu erhalten. Wir erhalten eine Liste von Elementen im JSON-Format mit einem anonymen Wurzelelement. Da XML kein anonymes Wurzelelement unterstützt, erhalten wir eine Ausnahmemeldung.