Cloud-Lösungen der Zukunft - Testen!

Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!

Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden
Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden

Kategorien

Apache

Databases

Docker

JavaScript

Kubernetes

Linux Basis

MySQL

Python

React

Security

Ubuntu

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.

Copy Code 


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

Copy Code 


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.

Copy Code 


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.

Copy Code 


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);
}
Copy Code 


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.

Copy Code 


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:

Copy Code 


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.

Entdecken Sie die Cloud der Zukunft mit Unserer Kostenlosen Testversion

Entfesseln Sie das volle Potenzial Ihres Unternehmens mit unseren innovativen Cloud-Lösungen. Tauchen Sie ein in eine Welt der Effizienz, Skalierbarkeit und umfassenden Sicherheit mit unserer risikofreien kostenlosen Testversion.

Try for free!

You might be interested in:

https://www.centron.de/tutorial/verwendung-der-funktion-puts-in-c-c/

https://www.centron.de/en/tutorial/container-an-introduction/