Lente is een van de meest gebruikte Java EE-frameworks. We hebben eerder gezien hoe we Spring MVC kunnen gebruiken om op Java gebaseerde webapplicaties te maken. Vandaag zullen we leren hoe we Spring Restful Web Services kunnen maken met behulp van Spring MVC en deze vervolgens testen met de Rest-client. Tot slot zullen we ook kijken hoe we de Spring Restful webservice kunnen aanroepen met behulp van de Spring RestTemplate API. 
Spring REST
We zullen de nieuwste versie van Spring gebruiken, 4.0.0.RELEASE, en de Spring Jackson JSON-integratie gebruiken om JSON-responsen in de REST-oproeprespons te verzenden. De tutorial is ontwikkeld in Spring STS IDE om gemakkelijk skeletcode voor Spring MVC te maken en vervolgens uit te breiden om een Restful-architectuur te implementeren. Maak een nieuw Spring MVC-project in de STS, ons uiteindelijke project zal eruitzien zoals op onderstaande afbeelding. We zullen elk van de onderdelen één voor één bekijken. 
Spring REST Configuratie XML-bestanden
Ons pom.xml-bestand ziet er als volgt uit.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev</groupId>
<artifactId>SpringRestExample</artifactId>
<name>SpringRestExample</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.6</java-version>
<org.springframework-version>4.0.0.RELEASE</org.springframework-version>
<org.aspectj-version>1.7.4</org.aspectj-version>
<org.slf4j-version>1.7.5</org.slf4j-version>
<jackson.databind-version>2.2.3</jackson.databind-version>
</properties>
<dependencies>
<!-- Jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.databind-version}</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
De STS-tool genereert het pom.xml-bestand voor ons. Ik heb echter de Spring Framework-, AspectJ-, SLF4J- en Jackson-versie bijgewerkt naar de nieuwste versie van vandaag. Het grootste deel is gemeenschappelijk en wordt automatisch gegenereerd, het belangrijkste punt om op te merken is dat ik de Jackson JSON-bibliotheken aan de afhankelijkheid heb toegevoegd omdat we die zullen gebruiken om objecten naar JSON te converteren en vice versa.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
Dit bestand is automatisch gegenereerd en ik heb er niets aan gewijzigd. Als je echter de contextconfiguratiebestanden en hun locatie wilt wijzigen, kun je dit doen in het web.xml-bestand.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Root Context: defines shared resources visible to all other web components -->
</beans>
Dit bestand bevat de gedeelde bronnen die zichtbaar zullen zijn voor alle webonderdelen. We zullen een eenvoudige REST-service ontwikkelen en daarom heb ik hier niets gewijzigd.
<?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">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<resources mapping="/resources/**" location="/resources/" />
<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
<!-- Configure to plugin JSON as request and response in method handler -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<beans:property name="messageConverters">
<beans:list>
<beans:ref bean="jsonMessageConverter"/>
</beans:list>
</beans:property>
</beans:bean>
<!-- Configure bean to convert JSON to POJO and vice versa -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>
<context:component-scan base-package="com.journaldev.spring.controller" />
</beans:beans>
Het grootste deel is automatisch gegenereerd en bevat standaardconfiguraties. Belangrijk om op te merken is echter het annotation-driven-element om annotatiegebaseerde configuratie te ondersteunen, en het invoegen van MappingJackson2HttpMessageConverter naar de RequestMappingHandlerAdapter messageConverters, zodat de Jackson API wordt geactiveerd en JSON naar Java Beans en vice versa converteert. Met deze configuratie gebruiken we JSON in het verzoek en ontvangen we JSON-gegevens in de respons.
Spring REST Modelklassen
Laten we een eenvoudige POJO-klasse schrijven die zal dienen als invoer en uitvoer voor onze RESTful webservice-methoden.
package com.journaldev.spring.model;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.DateSerializer;
public class Employee implements Serializable{
private static final long serialVersionUID = -7788619177798333712L;
private int id;
private String name;
private Date createdDate;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@JsonSerialize(using=DateSerializer.class)
public Date getCreatedDate() {
return createdDate;
}
public void setCreatedDate(Date createdDate) {
this.createdDate = createdDate;
}
}
Het enige belangrijke punt om op te merken is het gebruik van de @JsonSerialize-annotatie om de klasse DateSerializer te gebruiken voor de conversie van datum van Java-type naar JSON-formaat en vice versa.
Spring Restful web service Eindpunten
We zullen de volgende REST-webdiensteindpunten hebben.
| Sl. No | URI | HTTP Method | Details |
|---|---|---|---|
| 1 | /rest/emp/dummy | GET | Health Check service, to insert a dummy data in the Employees data storage |
| 2 | /rest/emp/{id} | GET | To get the Employee object based on the id |
| 3 | /rest/emps | GET | To get the list of all the Employees in the data store |
| 4 | /rest/emp/create | POST | To create the Employee object and store it |
| 5 | /rest/emp/delete/{id} | PUT | To delete the Employee object from the data storage based on the id |
We hebben een klasse die al deze URI’s definieert als String-constanten.
package com.journaldev.spring.controller;
public class EmpRestURIConstants {
public static final String DUMMY_EMP = "/rest/emp/dummy";
public static final String GET_EMP = "/rest/emp/{id}";
public static final String GET_ALL_EMP = "/rest/emps";
public static final String CREATE_EMP = "/rest/emp/create";
public static final String DELETE_EMP = "/rest/emp/delete/{id}";
}
Spring Restful web service Controllerklasse
Onze EmployeeControllerklasse zal alle bovengenoemde webdiensteindpunten publiceren. Laten we naar de code van de klasse kijken en dan zullen we elk van de methoden in detail bespreken.
package com.journaldev.spring.controller;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.journaldev.spring.model.Employee;
/**
* Handles requests for the Employee service.
*/
@Controller
public class EmployeeController {
private static final Logger logger = LoggerFactory.getLogger(EmployeeController.class);
//Kaart om werknemers op te slaan, idealiter zouden we een database moeten gebruiken
Map empData = new HashMap();
@RequestMapping(value = EmpRestURIConstants.DUMMY_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getDummyEmployee() {
logger.info("Start getDummyEmployee");
Employee emp = new Employee();
emp.setId(9999);
emp.setName("Dummy");
emp.setCreatedDate(new Date());
empData.put(9999, emp);
return emp;
}
@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
logger.info("Start getEmployee. ID="+empId);
return empData.get(empId);
}
@RequestMapping(value = EmpRestURIConstants.GET_ALL_EMP, method = RequestMethod.GET)
public @ResponseBody List getAllEmployees() {
logger.info("Start getAllEmployees.");
List emps = new ArrayList();
Set empIdKeys = empData.keySet();
for(Integer i : empIdKeys){
emps.add(empData.get(i));
}
return emps;
}
@RequestMapping(value = EmpRestURIConstants.CREATE_EMP, method = RequestMethod.POST)
public @ResponseBody Employee createEmployee(@RequestBody Employee emp) {
logger.info("Start createEmployee.");
emp.setCreatedDate(new Date());
empData.put(emp.getId(), emp);
return emp;
}
@RequestMapping(value = EmpRestURIConstants.DELETE_EMP, method = RequestMethod.PUT)
public @ResponseBody Employee deleteEmployee(@PathVariable("id") int empId) {
logger.info("Start deleteEmployee.");
Employee emp = empData.get(empId);
empData.remove(empId);
return emp;
}
}
Voor eenvoudigheid sla ik alle gegevens van de werknemers op in de HashMap empData. De @RequestMapping-annotatie wordt gebruikt om de aanvraag-URI aan de handlermethode te koppelen. We kunnen ook specificeren welke HTTP-methode door de clienttoepassing moet worden gebruikt om de REST-methode aan te roepen. De @ResponseBody-annotatie wordt gebruikt om het responsobject in het responslichaam in kaart te brengen. Zodra het responsobject door de handlermethode wordt geretourneerd, wordt MappingJackson2HttpMessageConverter geactiveerd en wordt het omgezet naar JSON-respons. De @PathVariable-annotatie is de eenvoudige manier om de gegevens uit de REST-URI te extraheren en deze aan het methodeargument te koppelen. De @RequestBody-annotatie wordt gebruikt om de aanvraagbody JSON-gegevens in het werknemersobject in kaart te brengen, dit gebeurt opnieuw door de MappingJackson2HttpMessageConverter-mapping. De rest van de code is eenvoudig en zelfverklarend, onze applicatie is klaar voor implementatie en testen. Exporteer het gewoon als WAR-bestand en kopieer het naar de webapp-map van de servletcontainer. Als je de server geconfigureerd hebt in de STS, kun je deze eenvoudig op de server uitvoeren om deze te implementeren. Ik gebruik WizTools RestClient om de REST-oproepen aan te roepen, maar je kunt ook de Chrome-extensie Postman gebruiken. Onderstaande schermafbeeldingen tonen de verschillende oproepen van de REST-API’s die door onze applicatie worden blootgesteld en de uitvoer ervan. Health Check – Dummy-werknemer REST-oproep 
Maak werknemer POST REST-oproep: Zorg ervoor dat het verzoek Content-Type is ingesteld op “application/json”, anders krijg je HTTP-foutcode 415. 
Werknemer oproepen ophalen 
Werknemer verwijderen REST-oproep 
Haal alle werknemers REST-oproep op 
Spring Rest Client Program
Rest Clients zijn goed om onze REST-webdienst te testen, maar meestal moeten we REST-diensten aanroepen via ons programma. We kunnen Spring RestTemplate gebruiken om deze methoden eenvoudig aan te roepen. Hieronder staat een eenvoudig programma dat onze toepassingsrestmethoden aanroept met behulp van de RestTemplate API.
package com.journaldev.spring;
import java.util.LinkedHashMap;
import java.util.List;
import org.springframework.web.client.RestTemplate;
import com.journaldev.spring.controller.EmpRestURIConstants;
import com.journaldev.spring.model.Employee;
public class TestSpringRestExample {
public static final String SERVER_URI = "https://localhost:9090/SpringRestExample";
public static void main(String args[]){
testGetDummyEmployee();
System.out.println("*****");
testCreateEmployee();
System.out.println("*****");
testGetEmployee();
System.out.println("*****");
testGetAllEmployee();
}
private static void testGetAllEmployee() {
RestTemplate restTemplate = new RestTemplate();
// we kunnen geen List krijgen omdat de JSON-converter het type van
// object in de lijst niet kent en het daarom omzet naar het standaard JSON-objecttype LinkedHashMap
List emps = restTemplate.getForObject(SERVER_URI+EmpRestURIConstants.GET_ALL_EMP, List.class);
System.out.println(emps.size());
for(LinkedHashMap map : emps){
System.out.println("ID="+map.get("id")+",Name="+map.get("name")+",CreatedDate="+map.get("createdDate"));;
}
}
private static void testCreateEmployee() {
RestTemplate restTemplate = new RestTemplate();
Employee emp = new Employee();
emp.setId(1);emp.setName("Pankaj Kumar");
Employee response = restTemplate.postForObject(SERVER_URI+EmpRestURIConstants.CREATE_EMP, emp, Employee.class);
printEmpData(response);
}
private static void testGetEmployee() {
RestTemplate restTemplate = new RestTemplate();
Employee emp = restTemplate.getForObject(SERVER_URI+"/rest/emp/1", Employee.class);
printEmpData(emp);
}
private static void testGetDummyEmployee() {
RestTemplate restTemplate = new RestTemplate();
Employee emp = restTemplate.getForObject(SERVER_URI+EmpRestURIConstants.DUMMY_EMP, Employee.class);
printEmpData(emp);
}
public static void printEmpData(Employee emp){
System.out.println("ID="+emp.getId()+",Name="+emp.getName()+",CreatedDate="+emp.getCreatedDate());
}
}
Het grootste deel van het programma is eenvoudig te begrijpen, maar bij het aanroepen van een REST-methode die een verzameling retourneert, moeten we LinkedHashMap gebruiken omdat de conversie van JSON naar object niet op de hoogte is van het Employee-object en het omzet naar de verzameling van LinkedHashMap. We kunnen een hulpprogramma schrijven om van LinkedHashMap naar ons Java Bean-object te converteren. Wanneer we het bovenstaande programma uitvoeren, krijgen we de volgende uitvoer in de console.
ID=9999,Name=Dummy,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
ID=1,Name=Pankaj Kumar,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
ID=1,Name=Pankaj Kumar,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
2
ID=1,Name=Pankaj Kumar,CreatedDate=1393995761654
ID=9999,Name=Dummy,CreatedDate=1393995761381
Nog een punt is dat RestTemplate put-methoden geen optie hebben om een responsobject in te stellen omdat de PUT-methode moet worden gebruikt om iets op de server op te slaan en een eenvoudige HTTP 200-statuscode voldoende zou moeten zijn.
Spring Restful Webservice Project downloaden
Dat is alles voor de Spring Restful webapplicatie tutorial. Download het voorbeeldproject vanaf de bovenstaande link en speel ermee om meer te leren. UPDATE: Vanwege zoveel verzoeken om een vergelijkbaar voorbeeld te bieden met XML, evenals ondersteuning voor zowel XML als JSON, heb ik deze applicatie uitgebreid in Spring REST XML JSON Voorbeeld om zowel XML- als JSON-verzoeken en -reacties te ondersteunen. Ik raad je ten zeerste aan om daar doorheen te gaan om de schoonheid van het Spring-framework te zien en hoe gemakkelijk het is om dit te bereiken.
Je kunt het volledige project downloaden van onze GitHub Repository.