Spring RestTemplate Beispiel

Spring RestTemplate bietet eine bequeme Möglichkeit, RESTful Webdienste zu testen.

Spring RestTemplate

• Die Spring RestTemplate-Klasse ist Teil von spring-web, eingeführt in Spring 3.
• Wir können RestTemplate verwenden, um HTTP-basierte RESTful-Webdienste zu testen. Es unterstützt jedoch nicht das HTTPS-Protokoll.
• Die RestTemplate-Klasse bietet überladene Methoden für verschiedene HTTP-Methoden wie GET, POST, PUT, DELETE usw.

Beispiel für Spring RestTemplate

Lassen Sie uns ein Beispiel für Spring RestTemplate betrachten, in dem wir REST-Webdienste testen werden, die im Artikel zu Spring Data JPA erstellt wurden. Die folgende Tabelle veranschaulicht die von diesem REST-Webdienst unterstützten URIs. .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}

Lassen Sie uns damit beginnen, unser Rest-Client-Projekt zu erstellen, um diese Webdienste zu testen. Das folgende Bild zeigt unser endgültiges Beispielprojekt für Spring RestTemplate.

Spring RestTemplate Maven-Abhängigkeiten

Wir benötigen die Abhängigkeiten spring-core und spring-context für das Spring Framework. Dann benötigen wir das Artefakt spring-web, das die Klasse RestTemplate enthält. Außerdem benötigen wir jackson-mapper-asl für die Unterstützung von Spring JSON durch die Jackson API.

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

Spring Konfigurationsklasse

Wir müssen ein Spring Bean für die RestTemplate-Klasse definieren, das geschieht in der Klasse 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;
	}
}

Beachten Sie, dass RestTamplate einen MessageConverter verwendet und wir diese Eigenschaft im RestTemplate-Bean setzen müssen. In unserem Beispiel verwenden wir MappingJacksonHttpMessageConverter zum Abrufen von Daten im JSON-Format.

Modellklasse

Da wir versuchen, JSON, das von unserem Webdienst zurückgegeben wird, mithilfe des Jackson-Mappers in ein Java-Objekt umzuwandeln, müssen wir die Modellklasse dafür erstellen. Beachten Sie, dass diese Modellklasse der Modellklasse ähnlich sein wird, die im Webdienst verwendet wird, mit dem Unterschied, dass hier keine JPA-Annotationen benötigt werden.

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
				+ '\'' + '}';
	}
}

Klasse des Spring RestTemplate-Clients

Der letzte Schritt besteht darin, die Clientklassen zu erstellen, die den oben definierten RestTemplate-Bean verwenden werden.

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

	}
}

Der Code ist selbsterklärend, wir rufen RestTemplate-Methoden auf der Grundlage der URI und der HTTP-Methode auf und übergeben bei Bedarf das entsprechende Anforderungsobjekt.

Testklasse der Spring RestTemplate

Es ist Zeit, unser Beispielprojekt für Spring RestTemplate zu testen. Die folgende Klasse zeigt, wie RestTemplate-Methoden auf Spring-Weise verwendet werden.

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();
	}
}

Wenn ich das oben genannte Programm gegen meine lokale Einrichtung ausführe, erhalte ich folgende Ausgabe.

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

Das folgende Bild zeigt die Daten der Datenbanktabelle des Webdienstes vor und nach Ausführung des oben genannten Programms. Wie Sie sehen können, stimmt die Programmausgabe mit den Beispieldaten der Tabelle überein. Das ist alles für das Beispiel Spring RestTemplate, Sie können das Projekt über den untenstehenden Link herunterladen.

Laden Sie das Beispielprojekt Spring RestTemplate herunter

Referenz: API-Dokumentation