Rust
Iron Web Framework

Invoering

Eenvoudige 'Hallo' server

In dit voorbeeld wordt een gecodeerde reactie naar de gebruiker verzonden wanneer deze een serververzoek verzendt.

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

Wanneer u in dit voorbeeld een nieuwe Iron , expect dat u fouten oploopt met een meer beschrijvende foutmelding. In productietoepassingen moet u de geproduceerde fout verwerken (zie de documentatie voor http() ).

IJzer installeren

Voeg deze afhankelijkheid toe aan het bestand Cargo.toml :

[dependencies]
iron = "0.4.0"

Voer cargo build en Cargo zal de gespecificeerde versie van Iron downloaden en installeren.

Eenvoudige routing met ijzer

Dit voorbeeld biedt eenvoudige webroutering met behulp van Iron.

Om te beginnen moet u de Iron-afhankelijkheid toevoegen aan uw Cargo.toml bestand.

[dependencies]
iron = "0.4.*"

We zullen de eigen routerbibliotheek van Iron gebruiken. Omwille van de eenvoud biedt het Iron-project deze bibliotheek als onderdeel van de Iron-kernbibliotheek, waardoor het niet meer nodig is deze toe te voegen als een afzonderlijke afhankelijkheid. Vervolgens verwijzen we naar zowel de Iron-bibliotheek als de Router-bibliotheek.

extern crate iron;
extern crate router;

Vervolgens importeren we de vereiste objecten om ons in staat te stellen de routering te beheren en een antwoord terug te sturen naar de gebruiker.

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

In dit voorbeeld houden we het eenvoudig door de routelogica in onze main() -functie te schrijven. Naarmate uw applicatie groeit, wilt u natuurlijk routing, logboekregistratie, beveiligingsproblemen en andere gebieden van uw webapplicatie scheiden. Voor nu is dit een goed uitgangspunt.

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

Laten we eens kijken wat we tot nu toe hebben bereikt. Ons programma start momenteel een nieuw Iron Router object en koppelt twee "handlers" aan twee soorten URL-aanvragen: de eerste ( "/" ) is de root van ons domein en de tweede ( "/:query" ) is een willekeurig pad onder de wortel.

Door een puntkomma voor het woord "query" te gebruiken, vertellen we Iron om dit deel van het URL-pad als variabele te nemen en aan onze handler door te geven.

De volgende coderegel is hoe we Iron instantiëren, door ons eigen router aan te wijzen om onze URL-aanvragen te beheren. Het domein en de poort zijn in dit voorbeeld voor de eenvoud hard gecodeerd.

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

Vervolgens verklaren we twee inline functies die onze handlers zijn, handler en query_handler . Deze worden beide gebruikt om vaste URL's en variabele URL's aan te tonen.

In de tweede functie nemen we de "query" -variabele uit de URL van het verzoekobject en sturen we deze als antwoord terug naar de gebruiker.

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

Als we dit voorbeeld uitvoeren, kunnen we het resultaat bekijken in de webbrowser op localhost:3000 . De root van het domein zou moeten antwoorden met "OK" , en alles onder de root zou het pad terug moeten herhalen.

De volgende stap uit dit voorbeeld zou de scheiding van routing en het aanbieden van statische pagina's kunnen zijn.