Rust
Cadre Web Iron

Introduction

Simple 'Hello' Server

Cet exemple envoie une réponse codée en dur à l'utilisateur lorsqu'il envoie une demande de serveur.

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

Lors de la création d'un nouveau serveur Iron dans cet exemple, expect - expect à détecter les erreurs avec un message d'erreur plus descriptif. Dans les applications de production, gérez l'erreur générée (voir la documentation de http() ).

Installation du fer

Ajoutez cette dépendance au fichier Cargo.toml :

[dependencies]
iron = "0.4.0"

Exécuter la cargo build et Cargo téléchargera et installera la version spécifiée d'Iron.

Routage simple avec fer

Cet exemple fournira un routage Web de base avec Iron.

Pour commencer, vous devrez ajouter la dépendance Iron à votre fichier Cargo.toml .

[dependencies]
iron = "0.4.*"

Nous utiliserons la bibliothèque du routeur d'Iron. Pour plus de simplicité, le projet Iron fournit cette bibliothèque dans la bibliothèque principale d’Iron, éliminant ainsi le besoin de l’ajouter en tant que dépendance distincte. Ensuite, nous référençons à la fois la bibliothèque Iron et la bibliothèque Router.

extern crate iron;
extern crate router;

Nous importons ensuite les objets requis pour nous permettre de gérer le routage et retourner une réponse à l'utilisateur.

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

Dans cet exemple, nous allons rester simple en écrivant la logique de routage dans notre fonction main() . Bien entendu, à mesure que votre application se développe, vous souhaiterez séparer le routage, la journalisation, les problèmes de sécurité et d’autres domaines de votre application Web. Pour l'instant, c'est un bon point de départ.

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

Passons en revue ce que nous avons accompli jusqu'à présent. Notre programme instancie actuellement un nouvel objet Iron Router , et attache deux "gestionnaires" à deux types de requête d'URL: le premier ( "/" ) est la racine de notre domaine, et le second ( "/:query" ) sous root.

En utilisant un point-virgule avant le mot "query", nous disons à Iron de prendre cette partie du chemin de l’URL en tant que variable et de la transmettre à notre gestionnaire.

La prochaine ligne de code est la façon dont nous instancions Iron, en désignant notre propre objet router pour gérer nos requêtes URL. Le domaine et le port sont codés en dur dans cet exemple pour plus de simplicité.

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

Ensuite, nous déclarons deux fonctions en ligne qui sont nos gestionnaires, handler et query_handler . Celles-ci sont toutes deux utilisées pour démontrer les URL fixes et les URL variables.

Dans la deuxième fonction, nous prenons la variable "query" de l'URL détenue par l'objet de requête, et nous la renvoyons à l'utilisateur en réponse.

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

Si nous exécutons cet exemple, nous pourrons afficher le résultat dans le navigateur Web à l’ localhost:3000 . La racine du domaine devrait répondre par "OK" , et tout ce qui se trouve sous la racine devrait répéter le chemin.

L'étape suivante de cet exemple pourrait être la séparation du routage et de la diffusion des pages statiques.