dlang-Anfragen - wie Python-Anfragen, nur für D

    Guten tag

    Ich möchte Ihnen die dlang-request Bibliothek vorstellen. Wofür ist sie? Für D möchte es das sein, was Python-Requests für Python sind, also ein praktischer http- (und ftp-) Client. Der Autor schwor, dass seine Ziele beim Schreiben der Bibliothek waren:

    1. bequeme, einfache Schnittstelle
    2. Leistung vergleichbar mit libcurl
    3. Kompatibilität mit Standardbibliothek D

    Der erste Teil des Artikels enthält Beispiele für die Verwendung von dlang-Anforderungen für die häufigsten Aufgaben.

    Beginnen wir mit GET-Anfragen


    Lassen Sie uns die einfachste Anwendung mit dlang-Anfragen erstellen (kopieren Sie sie direkt in die Shell, wenn Sie sich unter einer Unix-ähnlichen Achse befinden):

    Erstellen Sie eine minimale Anwendung mit Dub
    mkdir testanfragen && cd testanfragen && dub init. Anfragen
    cat> source / app.d <
    Als Ergebnis des Befehls dub run sollte HTML in der Konsole aus dem Stammverzeichnis der Website httpbin.org gezeichnet werden .

    Bisher ist alles ganz einfach: Wenn Sie nur den Inhalt des Dokuments benötigen, können Sie getContent (url) verwenden. Dieser Aufruf gibt einfach einen Puffer mit dem Dokument zurück.

    Warum ist der Puffer und nicht nur ein Array von Bytes? Denn in den meisten Fällen enthält der Puffer Daten, die direkt vom Netzwerk empfangen werden, ohne unnötiges Kopieren und Zusammenfügen von Linien aus Teilen. Bei Bedarf kann der Puffer mit der data () -Methode einfach in ein Array von Bytes umgewandelt werden:
    Konvertieren Sie die Antwort in ein Array von Bytes
    Import std.stdio;
    Importanfragen;
    void main ()
    {
        auto content = getContent ("http://httpbin.org");
        writeln (typeid (content.data ()));
    }
    


    Aber brauchst du es? Schließlich unterstützt der Puffer viele Range-Primitive, und Sie können ihn direkt zur Übergabe an die entsprechenden Algorithmen verwenden. Zum Beispiel müssen wir den Inhalt nicht in einen String konvertieren, um die Anzahl der Zeilen in der Antwort zu zählen, da
    Die Antwort kann mit den Standard-Bibliotheksalgorithmen verarbeitet werden, die mit range arbeiten. Gleichzeitig wird untersucht, welche Eigenschaften die Antwort hat.
    Import std.stdio;
    Importieren von Standardbereichsprimitiven;
    Standardalgorithmus importieren;
    Importanfragen;
    void main ()
    {
        auto content = getContent ("http://httpbin.org");
        writeln (content.splitter ('\ n'). count);
        alias type = typeof (Inhalt);
        statische Zusicherung (Typ isInputRange!);
        statische Zusicherung (Typ isForwardRange!);
        statische Zusicherung (Typ hasLength!);
        statische Zusicherung (Typ hasSlicing!);
        statische Zusicherung (Typ isBidirectionalRange!);
        statische Zusicherung (Typ isRandomAccessRange!);
    }

    Ein weiteres Beispiel: Wir können den resultierenden json ohne zusätzlichen Aufwand analysieren:
    Analysieren von Json von Antwort
    Import std.stdio;
    Import std.json;
    Importanfragen;
    void main ()
    {
        auto content = getContent ("http://httpbin.org/get");
        auto json = parseJSON (Inhalt);
        writeln (json);
    }

    Bevor wir uns mit Post beschäftigen, wollen wir sehen, was zu tun ist, wenn wir Parameter benötigen.
    Anfrage mit Parametern holen
    Import std.stdio;
    Import std.json;
    Importanfragen;
    void main ()
    {
        auto content = getContent ("http://httpbin.org/get",
                                 queryParams ("name", "bob", "age", 101));
        auto json = parseJSON (Inhalt);
        writeln (json);
    }
    



    Wir übergeben an POST-Anfragen.


    Der erste und einfachste Post ist das Posten in einem Webformular mit formular-urlencoded. Ein solcher Post wird normalerweise für die Übertragung kleiner Datenmengen verwendet und ähnelt in der Art des Aufrufs einem get-Aufruf mit folgenden Parametern:
    POST in formular-urlencodierter Form
    Import std.stdio;
    Import std.json;
    Importanfragen;
    void main ()
    {
        auto content = postContent ("http://httpbin.org/post", queryParams ("name", "bob", "age", 101));
        auto json = parseJSON (Inhalt);
        writeln (json);
    }

    Bitte beachten Sie: Der getContent-Aufruf wurde zu postContent, ansonsten hat sich nichts geändert.

    Multipart Form POST - Dient zum Übertragen großer Datenmengen auf den Server, einschließlich zum Hochladen von Dateien über ein Webformular.
    Ein Beispiel für das Senden einer Datei und von Parametern über MultipartForm
    Import std.stdio;
    Importanfragen;
    void main ()
    {
        MultipartForm form;
        form.add (formData ("content", "example for MultipartForm"));
        form.add (formData ("Datei", Datei ("source / app.d", "rb"), ["Dateiname": "app.d", "Inhaltstyp": "text / plain"]) ;
        auto content = postContent ("http://httpbin.org/post", Formular);
        writeln (Inhalt);
    }


    Wir sammeln die Felder, die an das Formular gesendet werden sollen, indem wir form.add (formData (Feldbeschreibung)) aufrufen, wobei der erste Parameter für formData der Name des Feldes ist und der zweite ein Array mit den zu sendenden Daten oder eine zum Lesen geöffnete Datei. Der dritte Parameter kann ein assoziatives Array mit zusätzlichen Daten sein (einschließlich des Inhaltstyps für den zu sendenden Teil).

    Die letzte Möglichkeit, postContent aufzurufen, besteht darin, Daten ohne Formular zu senden. Hier sind zwei Möglichkeiten möglich. Das erste ist das Senden eines Peer-to-Peer-Datenarrays (z. B. ubyte []). In diesem Fall müssen wir die Länge des Arrays zum Zeitpunkt des Aufrufs kennen, da der Content-Length-Header während der Übertragung verwendet wird. Ich werde hier nur die Rufzeile geben:

    auto content = postContent ("http://httpbin.org/post", 
                            "ABCDEFGH", 
                            "application / binary");
    


    Wenn wir aus irgendeinem Grund die Länge des Arrays zum Zeitpunkt des Aufrufs nicht kennen (aber wir wissen, dass sie endlich ist), können Sie die Übertragung eines Arrays der Dimension 2 verwenden. In diesem Fall wird jedes aufeinanderfolgende Stück des Arrays als ein anderes Stück an Transfer-Encoding übertragen: chunked:
    Senden einer Datei mit Transfer-Encoding: Chunked
    Import std.stdio;
    Importanfragen;
    void main ()
    {
         auto f = Datei ("source / app.d", "rb");
         auto content = postContent ("http://httpbin.org/post", f.byChunk (5), "application / binary");
         writeln (Inhalt);
    }


    Damit ist die Übersicht über die einfachste Verwendung von dlang-Anforderungen abgeschlossen. Wenn Sie kein Debugging benötigen, müssen Sie die empfangene Antwort nicht streamen. Sie benötigen keine anderen Methoden als GET und POST. Alles, was in Teil 1 nicht berücksichtigt wurde, werden wir in Teil 2 betrachten.

    Link zum Projekt-Repository auf Github .

    Viel glück

    Jetzt auch beliebt: