Erstellen Sie einen REST-Client in Java

  2. How-To's
  3. Java-Howtos
  4. Erstellen Sie einen REST-Client in Java
Jay Shaw 15 Februar 2024
Java Java REST
  1. Schritte zum Erstellen eines Java-Rest-Clients mit Spring Boot
  2. Erstellen Sie einen Java-REST-Client mit OkHttp
  3. Abschluss
Erstellen Sie einen REST-Client in Java

REST ist eine Reihe von Regeln und Bestimmungen, die erstellt wurden, damit Webprogramme problemlos miteinander interagieren können, ohne dass viel Verarbeitung erforderlich ist.

Für den Zugriff auf die REST-Dienste, die diese Webprogramme verwenden, ist eine clientseitige Anwendung erforderlich, die als REST-Client bezeichnet wird.

Dieser Artikel befasst sich mit verschiedenen Tools zum Erstellen eines REST-Clients. Das erste Beispiel zeigt die Schritte zum Erstellen eines einfachen REST-Clients mit Spring Boot und OkHttp.

Schritte zum Erstellen eines Java-Rest-Clients mit Spring Boot

Um einen REST-Client zu erstellen, benötigt die IDE ein Framework, um zu funktionieren. Ein Framework ist eine Umgebung, die alle wesentlichen Bibliothekspakete und laufzeitbezogenen Komponenten enthält.

Spring Boot ist ein Open-Source-Java-Framework zum Erstellen von Microservices. Wir benötigen die folgenden Ressourcen, um einen REST-Client mit Java und Spring Boot zu erstellen.

  • Eclipse IDE oder Spring Tool Suite
  • JDK 1.8 oder höher
  • Maven 3.2+

In den folgenden Unterabschnitten erstellen wir Schritt für Schritt einen REST-Client mit allen oben genannten Tools.

Erstellen Sie ein leeres Projekt

Der erste Schritt besteht darin, ein leeres Projekt zu erstellen. Dies kann auf zwei Arten erfolgen.

  1. Erstellen Sie ein leeres Projekt und fügen Sie alle Abhängigkeiten manuell hinzu.

    • Öffnen Sie die Spring Tool Suite, gehen Sie zu Datei>Neu>Andere>Web>Dynamisches Webprojekt und klicken Sie auf Weiter.
    • Geben Sie einen Projektnamen ein, wählen Sie einen Laufzeitserver aus, wählen Sie die Modulversion für Dynamic Web und klicken Sie auf Weiter.
    • Der letzte Abschnitt zeigt den Bibliotheksbaum. Alle Änderungen am gesamten Dateipfadbaum können hier vorgenommen werden.

  2. Verwenden Sie Spring Initializr, um ein vorinitialisiertes Projekt abzurufen.

Spring Initializr lädt ein vorinitialisiertes Projekt herunter, das gemäß den Anforderungen des Programmierers an die Abhängigkeiten konfiguriert ist und von https://start.spring.io/ erstellt werden kann.

Java-Rest-Client

Dieser Webdienst erstellt ein Maven- oder Gradle-Projekt mit allen ausgewählten Abhängigkeiten. Sobald Generieren angeklickt wird, lädt der Browser eine .zip-Datei herunter, die alle notwendigen Dateien und Bibliotheken enthält, die für das Webprojekt erforderlich sind.

Das hier verwendete Beispielprojekt verwendet einen REST-API-Dienst, um Zitate aus einer URL zu extrahieren, und gibt das Ergebnis zurück, wenn der Client eine GET-Anforderung sendet.

Das Projekt erhält einen Namen - org.clientforquotes, und hier ist nur eine Abhängigkeit erforderlich, daher wird nur spring web ausgewählt.

Erstellen Sie einen REST-Dienst

Ein REST-Dienst nimmt Befehle wie GET und POST entgegen und gibt eine Antwort zurück.

Um eine Anwendung zu erstellen, die einen REST-Dienst ausführt, erstellen Sie eine Java-Klasse und geben ihr einen Namen. In diesem Beispiel erhält die Klasse einen Namen – mainapplication.java, der im Ordner src/main/java erstellt wird.

Diese Klasse enthält die Methode main. Wenn diese Klasse durch den Initialisierer erstellt wird, ist sie dort bereits vorhanden.

Es gibt drei Hauptkomponenten in dieser Klasse:

  1. Um die Ausgabe anzuzeigen, wird eine logger-Methode hinzugefügt.
  2. Die von der Domain empfangenen Daten werden über die JSON-Bibliothek verarbeitet. Dies geschieht mit der Methode RestTemplate.
  3. Die Anwendung extrahiert beim Start ein Angebot. Dieser Vorgang findet statt, wenn das Rest-Template mit CommandLineRunner ausgeführt wird.

Im Folgenden finden Sie den Quellcode zum Erstellen des REST-Dienstes. Die Datei heißt MainApplication.java.

package com.example.clientforquotes;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class MainApplication {
  private static final Logger log = LoggerFactory.getLogger(MainApplication.class);

  public static void main(String[] args) {
    SpringApplication.run(MainApplication.class, args);
  }

  @Bean
  public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder.build();
  }

  @Bean
  public CommandLineRunner run(RestTemplate restTemplate) throws Exception {
    return args -> {
      Quote qt =
          restTemplate.getForObject("https://quoters.apps.pcfone.io/api/random", Quote.class);
      log.info(qt.toString());
    };
  }
}

Erstellen Sie eine Klasse, die die Daten aus der Domäne speichert

Erstellen Sie zwei weitere .java-Dateien – pullquote.java und basevalues.java, um die Getter-Setter-Methode, Konstruktoren und To_String-Funktionen hinzuzufügen.

Die Klasse pullquote speichert den zitierten Wert, der von der URL-Domäne abgerufen wird, und zeigt ihn an, wenn die Klasse aufgerufen wird. Nachfolgend der Quellcode der Datei pullquote.java.

package com.example.clientforquotes;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class Pullquote {
  private String object_type;
  private Basevalue qt_value;

  public Pullquote() {}

  public String getType() {
    return object_type;
  }

  public void setType(String type) {
    this.object_type = type;
  }

  public Basevalue getValue() {
    return qt_value;
  }

  public void setValue(Basevalue value) {
    this.qt_value = value;
  }

  @Override
  public String toString() {
    return "The quote for you = {"
        + "type='" + object_type + '\'' + ", value=" + qt_value + '}';
  }
}

Wir werden auch eine Klasse Basevalue in der Datei basevalue.java erstellen, um das innere Zitat zu speichern.

package com.example.clientforquotes;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class Basevalue {
  private Long sr_no;
  private String qt;

  public Basevalue() {}

  public Long getId() {
    return this.sr_no;
  }

  public String getQuote() {
    return this.qt;
  }

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

  public void setQuote(String quote) {
    this.qt = quote;
  }

  @Override
  public String toString() {
    return "Value{"
        + "id=" + sr_no + ", quote='" + qt + '\'' + '}';
  }
}

Fügen Sie alle neuen Abhängigkeiten zu pom.xml hinzu

Jedes Webprojekt hat eine Datei pom.xml, die die Abhängigkeiten speichert, die das Projekt benötigt. Wenn eine neue Bibliothek in das Projekt importiert wird, muss ihre Abhängigkeit zu ihrer pom.xml hinzugefügt werden.

Das Folgende ist die Datei pom.xml für unser Projekt.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>client-for-quotes</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>client-for-quotes</name>
    <description>Project for fetching quotes</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Führen Sie die Anwendung aus

Es gibt viele Möglichkeiten, die Anwendung auszuführen.

  • Führen Sie es direkt in der Spring Boot-App aus.
  • Erstellen Sie eine ausführbare .jar-Datei des Projekts.
  • Führen Sie es über die Befehlszeile aus.

Sie können den von uns erstellten REST-Client mit einer der oben genannten Methoden ausführen. Lassen Sie uns nun die Erstellung eines Java-REST-Clients mit anderen Frameworks besprechen.

Erstellen Sie einen Java-REST-Client mit OkHttp

Es ist ein leichter und effizienter Client für Java-Anwendungen. Webprogramme, die es verwenden, können angeblich schneller geladen werden.

Das Programm sendet einen JSON-Aufruf an einen Dienst, wenn eine Anfrage gestellt wird. Die URL wird in den Parameter .url geschrieben, während der Anfragetyp in den Parameter .post geschrieben wird.

Die Funktion .build() erstellt eine OkHttp-Anfrage. Das Folgende ist der Quellcode zum Erstellen eines Java-REST-Clients mit dem OkHttp-Framework.

public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

OkHttpClient obj = new OkHttpClient();

String post(String domain, String call) throws IOException {
  RequestBody req_body = RequestBody.create(JSON, call);
  Request quest = new Requests.Builder().url(domain).post(req_body).build();
  Response resp = obj.newCall(quest).execute();
  return resp.req_body().string();
}

Abschluss

Wir haben das Erstellen eines Java-REST-Clients ausführlich und dennoch unkompliziert erklärt. Nachdem der Leser diesen Artikel gelesen hat, kann er einen Java-REST-Client mit einigen gängigen Frameworks wie Spring Boot und OkHttp erstellen.