Spring RestTemplate Beispiel
Spring RestTemplate bietet eine praktische Möglichkeit, RESTful-Webdienste zu testen.
Einführung in Spring RestTemplate
- Die Spring RestTemplate class 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 class bietet überladene Methoden für verschiedene HTTP-Methoden wie GET, POST, PUT, DELETE usw.
Spring RestTemplate Beispiel
Die untenstehende Tabelle veranschaulicht die von diesem REST-Webdienst unterstützten URIs.
| URI | HTTP-Methode | Beschreibung |
|---|---|---|
| /springData/person | GET | Alle Personen aus der Datenbank abrufen |
| /springData/person/{id} | GET | Person anhand der ID abrufen |
| /springData/person | POST | Person zur Datenbank hinzufügen |
| /springData/person | PUT | Person aktualisieren |
| /springData/person/{id} | DELETE | Person anhand der ID löschen |
Lassen Sie uns unser REST-Client-Projekt erstellen, um diese Webdienste zu testen. Das untenstehende Bild zeigt unser finales Spring RestTemplate Beispielprojekt.
Spring RestTemplate Maven-Abhängigkeiten
Wir benötigen spring-core, spring-context Abhängigkeiten für das Spring Framework. Dann benötigen wir das spring-web Artefakt, das die RestTemplate class enthält. Wir benötigen auch jackson-mapper-asl für Spring JSON-Unterstützung 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 Configuration Class
Wir müssen einen Spring Bean für die RestTemplate class definieren, das wird in der AppConfig class gemacht.
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 RestTemplate einen MessageConverter verwendet und wir diese Eigenschaft im RestTemplate Bean setzen müssen. In unserem Beispiel verwenden wir MappingJacksonHttpMessageConverter, um Daten im JSON-Format abzurufen.
Model Class
Da wir versuchen, JSON, das von unserem Webdienst zurückgegeben wird, mit dem Jackson Mapper in ein Java-Objekt umzuwandeln, müssen wir die Model Class dafür erstellen. Beachten Sie, dass diese Model Class der im Webdienst verwendeten Model Class sehr ähnlich sein wird, außer dass wir hier keine JPA-Annotationen benötigen.
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 + '\'' + '}';
}
}
Spring RestTemplate Client Class
Der letzte Schritt besteht darin, die Client-Klassen 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 erklärt sich von selbst, wir rufen RestTemplate-Methoden basierend auf der URI und der HTTP-Methode auf und übergeben bei Bedarf das entsprechende Anfrageobjekt.
Spring RestTemplate Testklasse
Es ist Zeit, unser Spring RestTemplate Beispielprojekt zu testen, die untenstehende Klasse zeigt, wie man RestTemplate-Methoden auf Spring-Art verwendet.
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("Liste aller Personen abrufen:");
for (Person p : client.getAllPerson()) {
System.out.println(p);
}
System.out.println("\nPerson mit der ID 2 abrufen");
Person personById = client.getById(2L);
System.out.println(personById);
System.out.println("Eine Person hinzufügen");
Person p = new Person();
p.setAge(50);
p.setFirstName("David");
p.setLastName("Blain");
HttpStatus status = client.addPerson(p);
System.out.println("Antwort zum Hinzufügen einer Person = " + status);
applicationContext.close();
}
}
Wenn ich das oben genannte Programm mit meiner lokalen Einrichtung ausführe, erhalte ich folgende Ausgabe:
Liste aller Personen abrufen:
Person{id=2, age=30, firstName='Oksi', lastName=' Bahatskaya'}
Person{id=1, age=30, firstName='Vlad', lastName='Mateo'}
Person mit der ID 2 abrufen
Person{id=2, age=30, firstName='Oksi', lastName=' Bahatskaya'}
Eine Person hinzufügen
Antwort zum Hinzufügen einer Person = 201
Das untenstehende Bild zeigt die Daten der Webservice-Datenbanktabelle vor und nach der Ausführung des oben genannten Programms.
Wie man sehen kann, entspricht die Programmausgabe den Beispieldaten der Tabelle. Das war alles zum Spring RestTemplate Beispiel.
