Rust
Iron Web Framework

Wprowadzenie

Prosty serwer „cześć”

Ten przykład wysyła zakodowaną odpowiedź do użytkownika, gdy wyśle żądanie serwera.

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!")
}

Tworząc nowy serwer Iron w tym przykładzie, expect się wychwycenia błędów za pomocą bardziej opisowego komunikatu o błędzie. W aplikacjach produkcyjnych obsłuż wygenerowany błąd (zobacz dokumentację dla http() ).

Instalowanie żelaza

Dodaj tę zależność do pliku Cargo.toml :

[dependencies]
iron = "0.4.0"

Uruchom cargo build a Cargo pobierze i zainstaluje określoną wersję Iron.

Proste trasowanie za pomocą żelazka

Ten przykład zapewni podstawowe routing internetowy za pomocą Iron.

Na początek musisz dodać zależność Iron do pliku Cargo.toml .

[dependencies]
iron = "0.4.*"

Użyjemy własnej biblioteki routera Iron. Dla uproszczenia projekt Iron udostępnia tę bibliotekę jako część biblioteki rdzenia Iron, eliminując potrzebę dodawania jej jako oddzielnej zależności. Następnie odwołujemy się zarówno do biblioteki Iron, jak i biblioteki Router.

extern crate iron;
extern crate router;

Następnie importujemy wymagane obiekty, aby umożliwić nam zarządzanie routingiem i zwrócić odpowiedź użytkownikowi.

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

W tym przykładzie uprościmy to, pisząc logikę routingu w naszej funkcji main() . Oczywiście, w miarę rozwoju aplikacji, będziesz chciał oddzielić routing, logowanie, kwestie bezpieczeństwa i inne obszary swojej aplikacji internetowej. Na razie jest to dobry punkt wyjścia.

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

Omówmy to, co dotychczas osiągnęliśmy. Nasz program obecnie tworzy instancję nowego obiektu Iron Router i dołącza dwa „moduły obsługi” do dwóch typów żądań adresu URL: pierwszy ( "/" ) jest katalogiem głównym naszej domeny, a drugi ( "/:query" ) to dowolna ścieżka pod rootem.

Używając średnika przed słowem „zapytanie”, mówimy Ironowi, aby wziął tę część ścieżki URL jako zmienną i przekazał ją do naszego modułu obsługi.

Kolejny wiersz kodu to sposób tworzenia instancji Iron, wyznaczając własny obiekt router do zarządzania naszymi żądaniami adresów URL. Domena i port są w tym przykładzie zakodowane na stałe dla uproszczenia.

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

Następnie deklarujemy dwie funkcje wbudowane, które są naszymi query_handler handler query_handler handler i query_handler handler query_handler . Oba są używane do wykazania stałych adresów URL i zmiennych adresów URL.

W drugiej funkcji pobieramy zmienną "query" z adresu URL przechowywanego przez obiekt żądania i w odpowiedzi wysyłamy ją do użytkownika.

    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)))
    }
}

Jeśli uruchomimy ten przykład, będziemy mogli zobaczyć wynik w przeglądarce internetowej na localhost:3000 . Katalog główny domeny powinien odpowiedzieć "OK" , a wszystko poniżej katalogu głównego powinno powtórzyć ścieżkę wstecz.

Następnym krokiem w tym przykładzie może być rozdzielenie routingu i wyświetlania statycznych stron.