Rust
Iron Web Framework

Einführung

Einfacher Hallo-Server

In diesem Beispiel wird eine hart codierte Antwort an den Benutzer gesendet, wenn er eine Serveranfrage sendet.

extern crate iron;

use iron::prelude::*;
use iron::status;

// You can pass the handler as a function or a closure. In this
// case, we've chosen a function for clarity.
// Since we don't care about the request, we bind it to _.
fn handler(_: &mut Request) -> IronResult<Response> {
    Ok(Response::with((status::Ok, "Hello, Stack Overflow")))
}

fn main() {
    Iron::new(handler).http("localhost:1337").expect("Server failed!")
}

Wenn Sie in diesem Beispiel einen neuen Iron Server erstellen, expect Fehler mit einer aussagekräftigeren Fehlermeldung. Behandeln Sie in Produktionsanwendungen den erzeugten Fehler (siehe Dokumentation zu http() ).

Eisen installieren

Fügen Sie diese Abhängigkeit der Cargo.toml Datei hinzu:

[dependencies]
iron = "0.4.0"

Führen Sie cargo build und Cargo lädt die angegebene Version von Iron herunter und installiert sie.

Einfaches Routing mit Eisen

In diesem Beispiel wird ein grundlegendes Web-Routing mit Iron bereitgestellt.

Zunächst müssen Sie die Iron-Abhängigkeit zu Ihrer Cargo.toml Datei Cargo.toml .

[dependencies]
iron = "0.4.*"

Wir werden die eigene Router-Bibliothek von Iron verwenden. Der Einfachheit halber stellt das Iron-Projekt diese Bibliothek als Teil der Iron-Kernbibliothek bereit, so dass sie nicht mehr als separate Abhängigkeit hinzugefügt werden muss. Als Nächstes beziehen wir uns sowohl auf die Iron-Bibliothek als auch auf die Router-Bibliothek.

extern crate iron;
extern crate router;

Anschließend importieren wir die erforderlichen Objekte, um das Routing zu verwalten und dem Benutzer eine Antwort zu senden.

use iron::{Iron, Request, Response, IronResult};
use iron::status;
use router::{Router};

In diesem Beispiel halten wir es einfach, indem wir die Routing-Logik in unsere main() Funktion schreiben. Wenn Ihre Anwendung wächst, sollten Sie natürlich Routing, Protokollierung, Sicherheitsbedenken und andere Bereiche Ihrer Webanwendung trennen. Dies ist vorerst ein guter Ausgangspunkt.

fn main() {
    let mut router = Router::new();
    router.get("/", handler, "handler");
    router.get("/:query", query_handler, "query_handler");

Gehen wir noch einmal durch, was wir bisher erreicht haben. Unser Programm instanziiert derzeit ein neues Iron Router Objekt und fügt zwei "Handler" zwei Arten von URL-Anforderungen hinzu: Der erste ( "/" ) ist der Stamm unserer Domäne und der zweite ( "/:query" ) ist ein beliebiger Pfad unter der Wurzel.

Durch die Verwendung eines Semikolons vor dem Wort "Abfrage" weisen wir Iron an, diesen Teil des URL-Pfads als Variable zu verwenden und an unseren Handler zu übergeben.

Die nächste Codezeile ist, wie wir Iron instanziieren, indem wir unser eigenes router zum Verwalten unserer URL-Anforderungen festlegen. Die Domäne und der Port sind in diesem Beispiel der Einfachheit halber hart codiert.

    Iron::new(router).http("localhost:3000").unwrap();

Als Nächstes deklarieren wir zwei Inline-Funktionen, unsere Handler, handler und query_handler . Beide werden verwendet, um feste URLs und variable URLs zu veranschaulichen.

In der zweiten Funktion nehmen wir die Variable "query" aus der URL des Anforderungsobjekts und senden sie als Antwort an den Benutzer zurück.

    fn handler(_: &mut Request) -> IronResult<Response> {
        Ok(Response::with((status::Ok, "OK")))
    }

    fn query_handler(req: &mut Request) -> IronResult<Response> {
        let ref query = req.extensions.get::<Router>()
            .unwrap().find("query").unwrap_or("/");
        Ok(Response::with((status::Ok, *query)))
    }
}

Wenn wir dieses Beispiel ausführen, können wir das Ergebnis im Webbrowser unter localhost:3000 anzeigen. Der Stamm der Domäne sollte mit "OK" antworten, und alles unter dem Stamm sollte den Pfad zurück wiederholen.

Der nächste Schritt aus diesem Beispiel könnte die Trennung von Routing und das Bereitstellen statischer Seiten sein.