Spring RestController

Spring

De `Spring RestController`-annotatie is een gemakkelijke annotatie die zelf is geannoteerd met `@Controller` en `@ResponseBody`. Deze annotatie wordt toegepast op een klasse om deze te markeren als een verzoekverwerker. De `Spring RestController`-annotatie wordt gebruikt om RESTful webservices te maken met behulp van Spring MVC. `Spring RestController` zorgt voor het toewijzen van verzoekgegevens naar de gedefinieerde verzoekverwerkmethode. Zodra het responslichaam is gegenereerd vanuit de verwerkmethode, converteert het dit naar een JSON- of XML-respons.

Voorbeeld van Spring RestController

Laten we eens kijken hoe gemakkelijk we RestController kunnen gebruiken om een REST-webservice te maken in Spring. We zullen de implementatie van `Spring Repository` hergebruiken en een RESTful webservice maken. We zullen een op zichzelf staande webapplicatie maken en hier geen gebruik maken van Spring Boot. We zullen ook onze API’s blootstellen om zowel JSON als XML in verzoek en respons te ondersteunen. De onderstaande afbeelding toont onze uiteindelijke projectstructuur. Model- en Repository-klassen worden al geleverd in de `Spring Repository`-handleiding. We zullen ons hier meer richten op de implementatie van RestController.

Spring RestController Maven Afhankelijkheden

Laten we eens kijken naar de afhankelijkheden die nodig zijn om ons voorbeeldproject van Spring RestController te maken.

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

We hebben Spring MVC, Jackson en JAXB bibliotheken nodig om zowel XML- als JSON-verzoeken en -reacties van onze REST-webservice te ondersteunen. Ons web.xml-bestand wordt gebruikt om Spring MVC DispatcherServlet te configureren als de frontcontroller. Laten we nu het Spring Context-bestand bekijken.

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

Het belangrijkste deel is de jsonMessageConverter en xmlMessageConverter beans gedefinieerd en ingesteld in de RequestMappingHandlerAdapter messageConverters eigenschap. Dat is alles wat nodig is om Spring te vertellen dat we willen dat onze toepassing zowel JSON als XML ondersteunt, en dit zijn de beans die moeten worden gebruikt voor transformatie.

Spring RestController Klasse

Hier is onze implementatie van de 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")
	//Het retourneren van een lijst wordt alleen ondersteund met een JSON-reactie
	//Als je XML wilt, voeg dan een wrapperklasse toe als Root XML-element, bijvoorbeeld 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);
	}
}

Notice dat we hier alleen onze REST API’s hebben gedefinieerd, alle bedrijfslogica maakt deel uit van de Repository-klasse. Als onze methode een lijst of array retourneert, ondersteunt Spring alleen JSON-respons omdat het XML-rootelement niet anoniem kan zijn, maar JSON wel. Als je een lijst wilt retourneren als XML, moet je een wrapperklasse maken om deze lijst vast te houden en terug te geven. We verwachten dat de Employee-object als het verzoek in sommige van de methoden, Spring zal de zorg dragen voor het parsen van de request body en het omzetten naar het Employee-object voor deze methoden. Op dezelfde manier retourneren we Employee-object als het Response Body, opnieuw zal Spring ervoor zorgen dat het wordt omgezet naar JSON/XML-response.

Accept en Content-Type Request Headers

We hebben onze REST-toepassing geconfigureerd om te werken met zowel XML als JSON. Dus hoe weet het of het verzoek XML of JSON is? En als de respons in JSON- of XML-indeling moet worden verzonden. Hier komen de Accept en Content-Type Request Headers in beeld. Content-Type: Bepaalt het type inhoud in de request body, als de waarde “application/xml” is, zal Spring de request body behandelen als een XML-document. Als de waarde “application/json” is, wordt de request body behandeld als JSON. Accept: Bepaalt het type inhoud dat de client verwacht als respons. Als de waarde “application/xml” is, wordt een XML-respons verzonden. Als de waarde “application/json” is, wordt een JSON-respons verzonden.