Exemple Spring RestTemplate

Spring RestTemplate offre un moyen pratique de tester les services web RESTful.

Spring RestTemplate

• La classe Spring RestTemplate fait partie de spring-web, introduit dans Spring 3.
• Nous pouvons utiliser RestTemplate pour tester des services web reposant sur HTTP, il ne supporte pas le protocole HTTPS.
• La classe RestTemplate offre des méthodes surchargées pour différentes méthodes HTTP, telles que GET, POST, PUT, DELETE etc.

Exemple de Spring RestTemplate

Examinons un exemple de Spring RestTemplate où nous testerons les services web REST créés dans l’article Spring Data JPA. Le tableau ci-dessous illustre les URI pris en charge par ce service web REST. .tg {border-collapse:collapse;border-spacing:0;border-color:#999;} .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#999;color:#444;background-color:#F7FDFA;} .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#999;color:#fff;background-color:#26ADE4;} .tg .tg-baqh{text-align:center;vertical-align:top} .tg .tg-yw4l{vertical-align:top}

Commençons par créer notre projet de client Rest pour tester ces services web. L’image ci-dessous montre notre projet final d’exemple de Spring RestTemplate.

Spring RestTemplate Dépendances Maven

Nous avons besoin des dépendances spring-core et spring-context pour le framework Spring. Ensuite, nous avons besoin de l’artefact spring-web qui contient la classe RestTemplate. Nous avons également besoin de jackson-mapper-asl pour le support JSON Spring via l’API Jackson.

<?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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.journaldev.spring</groupId>
	<artifactId>SpringRestTemplate</artifactId>
	<version>1.0-SNAPSHOT</version>
	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
		<spring.web>3.0.2.RELEASE</spring.web>
		<serializer.version>2.8.1</serializer.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.codehaus.jackson</groupId>
			<artifactId>jackson-mapper-asl</artifactId>
			<version>1.9.4</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.web}</version>
		</dependency>
	</dependencies>
</project>

Classe de Configuration Spring

Nous devons définir un bean Spring pour la classe RestTemplate, cela se fait dans la classe AppConfig.

package com.journaldev.spring.config;

import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.MappingJacksonHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

@Configuration
@ComponentScan("com.journaldev.spring")
public class AppConfig {

	@Bean
	RestTemplate restTemplate() {
		RestTemplate restTemplate = new RestTemplate();
		MappingJacksonHttpMessageConverter converter = new MappingJacksonHttpMessageConverter();
		converter.setObjectMapper(new ObjectMapper());
		restTemplate.getMessageConverters().add(converter);
		return restTemplate;
	}
}

Notez que RestTemplate utilise MessageConverter et nous devons définir cette propriété dans le bean RestTemplate. Dans notre exemple, nous utilisons MappingJacksonHttpMessageConverter pour récupérer des données au format JSON.

Classe de Modèle

Depuis que nous essayons de convertir JSON retourné par notre service web en un objet java en utilisant jackson mapper, nous devons créer la classe de modèle pour cela. Notez que cette classe de modèle sera très similaire à la classe de modèle utilisée dans le service web, à l’exception que nous n’avons pas besoin d’annotations JPA ici.

package com.journaldev.spring.model;

public class Person {

	private Long id;

	private Integer age;

	private String firstName;

	private String lastName;

	public Person() {
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	@Override
	public String toString() {
		return "Person{" + "id=" + id + ", age=" + age + ", firstName='" + firstName + '\'' + ", lastName='" + lastName
				+ '\'' + '}';
	}
}

Classe Client Spring RestTemplate

La dernière étape consiste à créer les classes cliente qui utiliseront le bean RestTemplate défini ci-dessus.

package com.journaldev.spring.config;

import java.util.List;

import org.springframework.http.HttpStatus;

import com.journaldev.spring.model.Person;

public interface PersonClient {
	List<Person> getAllPerson();

	Person getById(Long id);

	HttpStatus addPerson(Person person);

	void updatePerson(Person person);

	void deletePerson(Long id);
}

package com.journaldev.spring.config;

import java.util.Arrays;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import com.journaldev.spring.model.Person;

@Service
public class PersonClientImpl implements PersonClient {

	@Autowired
	RestTemplate restTemplate;

	final String ROOT_URI = "https://localhost:8080/springData/person";

	public List<Person> getAllPerson() {
		ResponseEntity<Person[]> response = restTemplate.getForEntity(ROOT_URI, Person[].class);
		return Arrays.asList(response.getBody());

	}

	public Person getById(Long id) {
		ResponseEntity<Person> response = restTemplate.getForEntity(ROOT_URI + "/"+id, Person.class);
		return response.getBody();
	}

	public HttpStatus addPerson(Person person) {
		ResponseEntity<HttpStatus> response = restTemplate.postForEntity(ROOT_URI, person, HttpStatus.class);
		return response.getBody();
	}

	public void updatePerson(Person person) {
		restTemplate.put(ROOT_URI, person);
	}

	public void deletePerson(Long id) {
		restTemplate.delete(ROOT_URI + id);

	}
}

Le code est auto-explicatif, nous appelons les méthodes RestTemplate en fonction de l’URI et de la méthode HTTP et en passant l’objet de requête approprié si nécessaire.

Classe de test Spring RestTemplate

Il est temps de tester notre exemple de projet Spring RestTemplate, la classe ci-dessous montre comment utiliser les méthodes RestTemplate à la manière de Spring.

package com.journaldev.spring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.http.HttpStatus;

import com.journaldev.spring.config.AppConfig;
import com.journaldev.spring.config.PersonClient;
import com.journaldev.spring.model.Person;

public class Main {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

		PersonClient client = applicationContext.getBean(PersonClient.class);

		System.out.println("Getting list of all people:");

		for (Person p : client.getAllPerson()) {
			System.out.println(p);
		}

		System.out.println("\nGetting person with ID 2");

		Person personById = client.getById(2L);

		System.out.println(personById);

		System.out.println("Adding a Person");
		Person p = new Person();
		p.setAge(50);
		p.setFirstName("David");
		p.setLastName("Blain");
		HttpStatus status = client.addPerson(p);
		System.out.println("Add Person Response = " + status);

		applicationContext.close();
	}
}

Lorsque j’exécute le programme ci-dessus contre ma configuration locale, j’obtiens la sortie suivante.

Getting list of all people:
Person{id=2, age=30, firstName='Oksi', lastName=' Bahatskaya'}
Person{id=1, age=30, firstName='Vlad', lastName='Mateo'}

Getting person with ID 2
Person{id=2, age=30, firstName='Oksi', lastName=' Bahatskaya'}
Adding a Person
Add Person Response = 201

L’image ci-dessous montre les données de la table de la base de données du service web avant et après l’exécution du programme ci-dessus. Comme vous pouvez le voir, la sortie du programme correspond aux données d’échantillon de la table. C’est tout pour l’exemple Spring RestTemplate, vous pouvez télécharger le projet à partir du lien ci-dessous.

Téléchargez le projet exemple Spring RestTemplate

Référence: Documentation de l’API