JAVA-HILFE

OkHttp Java (Wie es für Entwickler funktioniert)

Veröffentlicht 1. Juli 2024

Teilen Sie:

In der modernen Java-Entwicklung ist die effiziente Handhabung von HTTP-Anfragen entscheidend für die Erstellung robuster Anwendungen, insbesondere solcher, die auf Webdienste und APIs angewiesen sind. OkHttp, ein leistungsfähiger HTTP- und HTTP/2-Client für Java und Kotlin, hat sich aufgrund seiner Leistung, Benutzerfreundlichkeit und fortschrittlichen Funktionen zu einer beliebten Wahl entwickelt.

Dieser Artikel bietet einen umfassenden Leitfaden zu OkHttp, der die wichtigsten Funktionen, die Installation und gängige Anwendungsfälle behandelt.

Was ist OkHttp?

OkHttp ist eine vielseitige Open-Source-Java-Bibliothek für die Bearbeitung von HTTP-Anfragen und bietet eine umfassende Reihe von Funktionen für die nahtlose Integration in Ihre Anwendungen. Mit der intuitiven API ist das Erstellen einer neuen Anfrage oder das Ausführen einer einfachen POST-Anfrage so einfach wie das Konfigurieren eines neuen Request Builders mit Abfrageparametern und einer String-URL.

Darüber hinaus erleichtert OkHttp die effiziente Bearbeitung von Antworten, indem es den Zugriff auf den Antwortkörper und die Antwort-Header ermöglicht und sogar das Zwischenspeichern von Antworten unterstützt, um den Netzwerkverkehr zu optimieren und Probleme mit der Serververfügbarkeit zu verringern. Egal, ob Sie synchrone oder asynchrone Anrufe tätigen, das Verbindungspooling von OkHttp sorgt für optimale Leistung, selbst wenn Sie mit mehreren IP-Adressen arbeiten.

OkHttp Java (Wie es für Entwickler funktioniert): Abbildung 1

Für Entwickler, die an die Verwendung des Apache HTTP Client gewöhnt sind, bietet OkHttp eine modernere und effizientere Alternative mit verbesserter Leistung und Flexibilität. Seine Unterstützung für asynchrone Aufrufe und Rückrufe macht es zu einer bevorzugten Wahl für Anwendungen, die Reaktionsfähigkeit und Skalierbarkeit erfordern.

Mit OkHttp wird die Verwaltung vieler HTTP-Clients und -Anfragen zum Kinderspiel, so dass sich die Entwickler auf die Entwicklung robuster und zuverlässiger Anwendungen konzentrieren können, ohne Kompromisse bei der Leistung oder Funktionalität einzugehen.

Wesentliche Merkmale

Die wichtigsten Merkmale von OkHttp sind:

Synchrone und asynchrone Bearbeitung von Anfragen: OkHttp ermöglicht sowohl die synchrone (sperrung) und asynchrone (nicht-blockierend) operationen.
Verbindungspooling: Wiederverwendung von HTTP-Verbindungen zur Minimierung von Client-Verbindungsproblemen und Verbesserung der Leistung.
Transparente GZIP-Komprimierung: Verringert die Größe von HTTP-Antworten, spart Bandbreite und beschleunigt die Datenübertragung.
Zwischenspeicherung: Unterstützt die Zwischenspeicherung von Antworten, wodurch die Notwendigkeit wiederholter Netzwerkanfragen reduziert wird.
HTTP/2-Unterstützung: Erhöht die Leistung, indem mehrere Anfragen und Antworten über eine einzige Verbindung gemultiplext werden können.
Zeitüberschreitungen und Wiederholungen: Bietet fein abgestufte Kontrolle über Verbindungs- und Lesezeitüberschreitungen sowie Wiederholungsmechanismen für fehlgeschlagene Anfragen.

Installation von OkHttp

Um OkHttp in Ihrem Java-Projekt verwenden zu können, müssen Sie die Abhängigkeit von OkHttp in Ihre Build-Konfiguration aufnehmen. Wenn Sie Maven verwenden, fügen Sie die folgende Abhängigkeit zu Ihrer pom.xml Datei hinzu:

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>5.0.0-alpha.14</version>
</dependency>

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>5.0.0-alpha.14</version>
</dependency>

XML

Für Gradle fügen Sie diese Zeile zu Ihrer Datei "build.gradle" hinzu:

implementation 'com.squareup.okhttp3:okhttp:5.0.0-alpha.14'

Stellen Sie sicher, dass Sie die neueste Version auf Maven Central oder GitHub finden.

Grundlegende Verwendung

Erstellen eines OkHttpClient

Die Klasse OkHttpClient ist der Haupteinstiegspunkt für die Ausführung von HTTP-Anfragen. Es wird empfohlen, eine einzige OkHttpClient-Instanz zu erstellen und sie in der gesamten Anwendung wiederzuverwenden, um die Vorteile des Verbindungspoolings zu nutzen.

import okhttp3.OkHttpClient;
OkHttpClient client = new OkHttpClient();

import okhttp3.OkHttpClient;
OkHttpClient client = new OkHttpClient();

JAVA

GET-Anfragen stellen

Um eine einfache GET-Anfrage zu stellen, müssen Sie ein Request-Objekt erstellen und es mit dem OkHttpClient ausführen.

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

OkHttp Java (Wie es für Entwickler funktioniert): Abbildung 2

POST-Anfragen stellen

Bei einer POST-Anfrage müssen Sie einen Anfragetrumpf und eine Rückantwort angeben. OkHttp bietet die Klasse RequestBody, um dies zu handhaben.

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";
        RequestBody body = RequestBody.create(json, JSON);
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts")
                .post(body)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";
        RequestBody body = RequestBody.create(json, JSON);
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts")
                .post(body)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

OkHttp Java (Wie es für Entwickler funktioniert): Abbildung 3

Asynchrone Anforderungen

Asynchrone Anfragen werden über Rückrufe abgewickelt, so dass Ihre Anwendung während des Wartens auf die Antwort reaktionsfähig bleibt.

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    System.out.println(response.body().string());
                } else {
                    System.err.println("Request failed: " + response.code());
                }
            }
        });
    }
}

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    System.out.println(response.body().string());
                } else {
                    System.err.println("Request failed: " + response.code());
                }
            }
        });
    }
}

JAVA

Erweiterte Funktionen

Abfangjäger

Abfangjäger sind eine leistungsstarke Funktion, die es Ihnen ermöglicht, Anfragen und Antworten zu prüfen, zu ändern oder zu wiederholen. Sie können für die Protokollierung, das Hinzufügen von Kopfzeilen oder die Authentifizierung verwendet werden.

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(new Interceptor() {
                    @Override
                    public Response intercept(Chain chain) throws IOException {
                        Request request = chain.request().newBuilder()
                                .addHeader("Authorization", "Bearer your_token_here")
                                .build();
                        return chain.proceed(request);
                    }
                })
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(new Interceptor() {
                    @Override
                    public Response intercept(Chain chain) throws IOException {
                        Request request = chain.request().newBuilder()
                                .addHeader("Authorization", "Bearer your_token_here")
                                .build();
                        return chain.proceed(request);
                    }
                })
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

Umgang mit Zeitüberschreitungen

OkHttp bietet Methoden, um Timeouts für verschiedene Phasen der HTTP-Anfrage selbst zu setzen.

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

Zwischenspeichern von Antworten

OkHttp kann Antworten zwischenspeichern, um die Latenzzeit von Anfragen zu verringern und die Leistung zu verbessern. Dazu muss ein Cache-Verzeichnis und eine Cache-Größe eingerichtet werden.

import okhttp3.Cache;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.File;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        File cacheDirectory = new File("cacheDirectory");
        Cache cache = new Cache(cacheDirectory, 10 * 1024 * 1024); // 10 MB cache
        OkHttpClient client = new OkHttpClient.Builder()
                .cache(cache)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.Cache;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.File;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        File cacheDirectory = new File("cacheDirectory");
        Cache cache = new Cache(cacheDirectory, 10 * 1024 * 1024); // 10 MB cache
        OkHttpClient client = new OkHttpClient.Builder()
                .cache(cache)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

Integration von OkHttp mit IronPDF in Java

Die Kombination der Fähigkeiten von OkHttp und IronPDF ermöglicht es Java-Entwicklern, Daten aus dem Web zu holen und in PDFs zu konvertieren. OkHttp ist ein robuster HTTP-Client für die Bearbeitung von Netzwerkanfragen, während IronPDF eine leistungsfähige Bibliothek zur Erzeugung von PDFs aus verschiedenen Quellen ist.

IronPDF - Überblick

IronPDF for Java ist eine umfassende Bibliothek, die die PDF-Erzeugung in Java-Anwendungen vereinfacht. Mithilfe der intuitiven API können Entwickler mühelos PDF-Dokumente aus verschiedenen Datenquellen, darunter HTML, Bilder und Text, erstellen, bearbeiten und rendern.

IronPDF unterstützt erweiterte Funktionen wie PDF-Verschlüsselung, digitale Signaturen und interaktives Ausfüllen von Formularen und ermöglicht es Entwicklern, professionelle PDF-Dateien zu erstellen, die auf ihre spezifischen Anforderungen zugeschnitten sind. Die nahtlose Integration und die ausführliche Dokumentation machen die Lösung zur ersten Wahl für Java-Entwickler, die ihre Anwendungen um robuste PDF-Generierungsfunktionen erweitern möchten.

OkHttp Java (Wie es für Entwickler funktioniert): Abbildung 4

Einrichten von Abhängigkeiten

Fügen Sie zunächst die erforderlichen Abhängigkeiten zu Ihrer pom.xml hinzu (für Maven) xml-Datei oder build.gradle (für Gradle) datei.

Maven

<dependency>
    <groupId>com.ironsoftware</groupId>
    <artifactId>ironpdf</artifactId>
    <version>2024.3.1</version>
</dependency>

<dependency>
    <groupId>com.ironsoftware</groupId>
    <artifactId>ironpdf</artifactId>
    <version>2024.3.1</version>
</dependency>

XML

Gradle

implementation 'com.ironsoftware:ironpdf:2024.3.1'

Integration von OkHttp und IronPDF

Kombinieren wir nun die beiden Funktionen: Abrufen von HTML-Inhalten mit OkHttp und Erzeugen einer PDF-Datei mit IronPDF.

import com.ironsoftware.ironpdf.PdfDocument;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.nio.file.Paths;

public class OkHttpToPdf {
    private final OkHttpClient client = new OkHttpClient();

    public String fetchHtml(String url) throws IOException {
        Request request = new Request.Builder()
                .url(url)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
            return response.body().string();
        }
    }

    public void generatePdfFromUrl(String url, String outputFilePath) {
        try {
            String htmlContent = fetchHtml(url);
            PdfDocument pdf = PdfDocument.renderHtmlAsPdf(htmlContent);
            pdf.saveAs(Paths.get(outputFilePath));
            System.out.println("PDF generated successfully at " + outputFilePath);
        } catch (IOException e) {
            System.err.println("Failed to fetch HTML content: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Failed to generate PDF: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        OkHttpToPdf converter = new OkHttpToPdf();
        converter.generatePdfFromUrl("https://ironpdf.com/java", "website.pdf");
    }
}

import com.ironsoftware.ironpdf.PdfDocument;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.nio.file.Paths;

public class OkHttpToPdf {
    private final OkHttpClient client = new OkHttpClient();

    public String fetchHtml(String url) throws IOException {
        Request request = new Request.Builder()
                .url(url)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
            return response.body().string();
        }
    }

    public void generatePdfFromUrl(String url, String outputFilePath) {
        try {
            String htmlContent = fetchHtml(url);
            PdfDocument pdf = PdfDocument.renderHtmlAsPdf(htmlContent);
            pdf.saveAs(Paths.get(outputFilePath));
            System.out.println("PDF generated successfully at " + outputFilePath);
        } catch (IOException e) {
            System.err.println("Failed to fetch HTML content: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Failed to generate PDF: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        OkHttpToPdf converter = new OkHttpToPdf();
        converter.generatePdfFromUrl("https://ironpdf.com/java", "website.pdf");
    }
}

JAVA

Code Erläuterung

Der obige Code zeigt, wie HTML-Inhalte von einer URL abgerufen und mit Hilfe der OkHttp- und IronPDF-Bibliotheken in Java in eine PDF-Datei umgewandelt werden können:

Import-Anweisungen: Die erforderlichen Bibliotheken werden importiert, einschließlich IronPDF für die PDF-Erzeugung und OkHttp für HTTP-Anfragen.
OkHttpClient Initialisierung: Eine Instanz von OkHttpClient wird erstellt.
fetchHtml Methode: Diese Methode holt den HTML-Inhalt von einer angegebenen URL.
- Es wird eine Anfrage mit der angegebenen URL erstellt.
- Die Anfrage wird ausgeführt und die Antwort wird erhalten.
- Wenn die Antwort nicht erfolgreich ist, wird eine IOException ausgelöst.
- Der Antwortkörper wird als Zeichenkette zurückgegeben.
generatePdfFromUrl Methode: Diese Methode erzeugt ein PDF aus dem HTML-Inhalt einer angegebenen URL und speichert es in einem angegebenen Dateipfad.
- Der HTML-Inhalt wird mit der Methode "fetchHtml" abgerufen.
- Der HTML-Inhalt wird mit "IronPDF" als PDF-Datei gerendert.
- Die PDF-Datei wird unter dem angegebenen Dateipfad gespeichert.
- Sowohl für den HTML-Abruf als auch für die PDF-Erzeugung ist eine angemessene Fehlerbehandlung vorgesehen.
methode main**: Dies ist der Einstiegspunkt des Programms.
- Eine Instanz von OkHttpToPdf wird erstellt.
- Die Methode generatePdfFromUrl wird mit einer bestimmten URL und einem Pfad zur Ausgabedatei aufgerufen.

Ausgabe

Die URL-Daten werden mit dem OkHttp-Client abgerufen und dann mit IronPDF effizient in PDF umgewandelt, wie unten dargestellt:

OkHttp Java (Wie es für Entwickler funktioniert): Abbildung 5

Ausführlichere Informationen über IronPDF finden Sie hier dokumentation seite. Bitte prüfen Sie auch dies code-Beispiele und API-Referenz seite für die weitere Nutzung von IronPDF.

Schlussfolgerung

OkHttp ist ein vielseitiger und leistungsstarker HTTP-Client für Java und Android, der den Prozess der Netzwerkanfragen vereinfacht. Mit seiner Unterstützung für synchrone und asynchrone Operationen, Verbindungspooling, transparente GZIP-Kompression, Caching und HTTP/2 ist der OkHttp-Client für eine Vielzahl von Anwendungsfällen geeignet. Durch die Integration von OkHttp in Ihre Java-Anwendungen können Sie deren Leistung, Zuverlässigkeit und Effizienz steigern.

Durch die Integration von OkHttp mit IronPDF können Sie effizient HTML-Inhalte aus Webquellen abrufen und in PDF-Dokumente umwandeln. Dieser Ansatz ist besonders nützlich für Anwendungen, die Berichte erstellen, Webseiten speichern oder Webinhalte in Offline-Dokumente umwandeln müssen.

Erschließen Sie das Potenzial der PDF-Erzeugung in Ihren Java-Anwendungen mit IronPDFs kostenloser Testund ermöglicht die nahtlose Integration professioneller PDF-Erstellung in Ihre Projekte. Jetzt herunterladen und die PDF-Erstellung optimieren!

< PREVIOUS
Apache Commons IO (Wie es für Entwickler funktioniert)

NÄCHSTES >
Gson Java (Wie es für Entwickler funktioniert)

Auf dieser Seite

Was ist OkHttp?
- Wesentliche Merkmale
Installation von OkHttp
Grundlegende Verwendung
Erweiterte Funktionen
Integration von OkHttp mit IronPDF in Java
- IronPDF - Überblick
- Einrichten von Abhängigkeiten
Integration von OkHttp und IronPDF
Schlussfolgerung

Installation mit Maven

Version:2024.9.1

<dependency>
  <groupId>com.ironsoftware</groupId>
  <artifactId>ironpdf</artifactId>
  <version>2024.9.1</version>
</dependency>

Ein Problem melden

Nehmen Sie an unserer Bug Bounty für Iron Swag teil

Sind Sie bereit, loszulegen? Version: 2024.9 gerade veröffentlicht

Lizenzen anzeigen >

OkHttp Java (Wie es für Entwickler funktioniert)

Was ist OkHttp?

Wesentliche Merkmale

Installation von OkHttp

Grundlegende Verwendung

Erstellen eines OkHttpClient

GET-Anfragen stellen

POST-Anfragen stellen

Asynchrone Anforderungen

Erweiterte Funktionen

Abfangjäger

Umgang mit Zeitüberschreitungen

Zwischenspeichern von Antworten

Integration von OkHttp mit IronPDF in Java

IronPDF - Überblick

Einrichten von Abhängigkeiten

Maven

Gradle

Integration von OkHttp und IronPDF

Code Erläuterung

Ausgabe

Schlussfolgerung

Auf dieser Seite

Ein Problem melden

Sind Sie bereit, loszulegen? Version: 2024.9 gerade veröffentlicht

Holen Sie sich Ihr FREE

Das Versuchsformular wurde eingereichterfolgreich.

Das Versuchsformular wurde eingereichterfolgreich.

Das Versuchsformular wurde eingereichterfolgreich.

Das Versuchsformular wurde eingereichterfolgreich.

Test in einer Live-Umgebung

Vollständig funktionsfähiges Produkt

24/5 technische Unterstützung

Holen Sie sich Ihr kostenloses 30-Tage-Testschlüssel sofort.

Das Versuchsformular wurde eingereichterfolgreich.

Millionen von Ingenieuren weltweit vertrauen darauf

Test in einer Live-Umgebung

Vollständig funktionsfähiges Produkt

24/5 technische Unterstützung

Holen Sie sich Ihr kostenloses 30-Tage-Testschlüssel sofort.

Das Versuchsformular wurde eingereichterfolgreich.

Millionen von Ingenieuren weltweit vertrauen darauf

Test in einer Live-Umgebung

Vollständig funktionsfähiges Produkt

24/5 technische Unterstützung

Holen Sie sich Ihr kostenloses 30-Tage-Testschlüssel sofort.

Millionen von Ingenieuren weltweit vertrauen darauf

IronPDF ist ein Teil von IRONSUITE

Das Versuchsformular wurde eingereicht
erfolgreich.

Das Versuchsformular wurde eingereicht
erfolgreich.

Das Versuchsformular wurde eingereicht
erfolgreich.

Das Versuchsformular wurde eingereicht
erfolgreich.

Das Versuchsformular wurde eingereicht
erfolgreich.

Das Versuchsformular wurde eingereicht
erfolgreich.