Rust
Iron Web Framework

introduzione

Semplice server "Hello"

Questo esempio invia una risposta codificata all'utente quando invia una richiesta al server.

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

Quando crei un nuovo server Iron in questo esempio, expect di rilevare eventuali errori con un messaggio di errore più descrittivo. Nelle applicazioni di produzione, gestire l'errore prodotto (consultare la documentazione per http() ).

Installazione di ferro

Aggiungi questa dipendenza al file Cargo.toml :

[dependencies]
iron = "0.4.0"

Esegui la cargo build e Cargo scaricherà e installerà la versione specificata di Iron.

Semplice routing con ferro

Questo esempio fornirà il web routing di base usando Iron.

Per cominciare, dovrai aggiungere la dipendenza Iron al tuo file Cargo.toml .

[dependencies]
iron = "0.4.*"

Useremo la libreria del router di Iron. Per semplicità, il progetto Iron fornisce questa libreria come parte della libreria Iron core, eliminando ogni necessità di aggiungerla come dipendenza separata. Successivamente facciamo riferimento sia alla libreria Iron che alla libreria Router.

extern crate iron;
extern crate router;

Quindi importiamo gli oggetti richiesti per consentirci di gestire il routing e restituire una risposta all'utente.

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

In questo esempio, manterremo la cosa semplice scrivendo la logica di routing all'interno della nostra funzione main() . Naturalmente, man mano che l'applicazione cresce, è necessario separare routing, registrazione, problemi di sicurezza e altre aree dell'applicazione Web. Per ora, questo è un buon punto di partenza.

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

Andiamo oltre ciò che abbiamo ottenuto finora. Il nostro programma crea istantaneamente un nuovo oggetto Iron Router e allega due "handler" a due tipi di richieste URL: il primo ( "/" ) è la radice del nostro dominio e il secondo ( "/:query" ) è qualsiasi percorso sotto la radice.

Usando un punto e virgola prima della parola "query", stiamo dicendo a Iron di prendere questa parte del percorso dell'URL come variabile e trasmetterla al nostro gestore.

La prossima riga di codice è il modo in cui istanziamo Iron, designando il nostro oggetto router per gestire le nostre richieste URL. Il dominio e la porta sono hard-coded in questo esempio per semplicità.

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

Successivamente, dichiariamo due funzioni inline che sono i nostri gestori, handler e query_handler . Questi sono entrambi utilizzati per dimostrare URL fissi e URL variabili.

Nella seconda funzione prendiamo la variabile "query" dall'URL detenuto dall'oggetto request e la rimandiamo all'utente come risposta.

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

Se eseguiamo questo esempio, saremo in grado di visualizzare il risultato nel browser Web su localhost:3000 . La radice del dominio dovrebbe rispondere con "OK" e qualsiasi cosa sotto la radice dovrebbe ripetere il percorso.

Il prossimo passo di questo esempio potrebbe essere la separazione del routing e la pubblicazione di pagine statiche.