Rust
Iron Web Framework

Introduktion

Enkel "Hej" -server

Detta exempel skickar ett hårkodat svar till användaren när de skickar en serverbegäran.

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

När du skapar en ny Iron server i det här exemplet, expect att fånga eventuella fel med ett mer beskrivande felmeddelande. I produktionsapplikationer, hantera det producerade felet (se dokumentationen för http() ).

Installera järn

Lägg till detta beroende till Cargo.toml filen:

[dependencies]
iron = "0.4.0"

Kör cargo build och Cargo kommer att ladda ner och installera den angivna versionen av Iron.

Enkel dirigering med järn

Detta exempel kommer att tillhandahålla grundläggande webbrutning med Iron.

Till att börja med måste du lägga till Iron-beroende i din Cargo.toml fil.

[dependencies]
iron = "0.4.*"

Vi kommer att använda Iron's eget Router-bibliotek. För enkelhets skull tillhandahåller Iron-projektet detta bibliotek som en del av Iron Core-biblioteket, vilket tar bort alla behov att lägga till det som ett separat beroende. Nästa hänvisar vi till både Iron-biblioteket och Router-biblioteket.

extern crate iron;
extern crate router;

Sedan importerar vi de objekt som krävs för att vi ska kunna hantera routing och returnera ett svar till användaren.

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

I det här exemplet håller vi det enkelt genom att skriva routinglogiken i vår huvudfunktion main() . När din ansökan växer vill du naturligtvis separera routing, loggning, säkerhetsproblem och andra områden i din webbapplikation. För tillfället är detta en bra utgångspunkt.

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

Låt oss gå igenom vad vi hittills har uppnått. Vårt program instanserar för närvarande ett nytt Iron Router objekt och kopplar två "hanterare" till två typer av URL-begäran: den första ( "/" ) är roten till vår domän, och den andra ( "/:query" ) är vilken väg som helst under rot.

Genom att använda en semi-colon innan ordet "fråga", berättar vi Iron att ta denna del av URL-banan som en variabel och skicka den till vår hanterare.

Nästa kodrad är hur vi initierar Iron, som utser vårt eget router att hantera våra URL-förfrågningar. Domänen och porten är hårdkodade i detta exempel för enkelhetens skull.

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

Därefter förklarar vi två inlinefunktioner som är våra hanterare, handler och query_handler . Dessa används båda för att demonstrera fasta URL: er och variabla URL: er.

I den andra funktionen tar vi variabeln "query" från den URL som innehas av förfrågningsobjektet och vi skickar tillbaka den till användaren som svar.

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

Om vi kör detta exempel kommer vi att kunna se resultatet i webbläsaren på localhost:3000 . Domänens rot bör svara med "OK" , och allt under roten ska upprepa vägen tillbaka.

Nästa steg från detta exempel kan vara separering av routing och visning av statiska sidor.