#Démarrage Rapide

#Installer Rust

Si vous n'avez pas encore installé Rust, vous pouvez utiliser l'outil officiel (rustup)[https://doc.rust-lang.org/book/ch01-01-installation.html] pour l'installer.

#Écrire Votre Premier Programme Salvo

Créez un nouveau projet :

cargo new hello --bin

Ajoutez les dépendances dans Cargo.toml :

[package]
name = "example-hello"
version.workspace = true
edition.workspace = true
publish.workspace = true
rust-version.workspace = true

[dependencies]
salvo = { workspace = true }
tokio = { workspace = true, features = ["macros"] }
tracing.workspace = true
tracing-subscriber.workspace = true

Dans main.rs, créez un gestionnaire de fonction simple nommé hello, qui affiche simplement le texte "Hello world".

use salvo::prelude::*;

// Handler for English greeting
#[handler]
async fn hello() -> &'static str {
    "Hello World"
}

// Handler for Chinese greeting
#[handler]
async fn hello_zh() -> Result<&'static str, ()> {
    Ok("你好，世界！")
}

#[tokio::main]
async fn main() {
    // Initialize logging subsystem
    tracing_subscriber::fmt().init();

    // Bind server to port 8698
    let acceptor = TcpListener::new("0.0.0.0:8698").bind().await;

    // Create router with two endpoints:
    // - / (root path) returns English greeting
    // - /你好 returns Chinese greeting
    let router = Router::new()
        .get(hello)
        .push(Router::with_path("你好").get(hello_zh));

    // Print router structure for debugging
    println!("{router:?}");

    // Start serving requests
    Server::new(acceptor).serve(router).await;
}

Félicitations ! Votre premier programme Salvo est terminé. Exécutez simplement cargo run dans la ligne de commande, puis ouvrez http://127.0.0.1:8698 dans votre navigateur.

#Explication Détaillée

Ici, hello_world est un Handler utilisé pour traiter les requêtes utilisateur. L'attribut #[handler] permet à une fonction d'implémenter facilement le trait Handler. De plus, il nous permet d'écrire les paramètres de fonction de diverses manières simplifiées.

• Forme originale :

  #[handler]
  async fn hello(_req: &mut Request, _depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl) {
      res.render("Hello world");
  }

• Vous pouvez omettre les paramètres inutilisés dans la fonction. Par exemple, _req, _depot et _ctrl ne sont pas utilisés ici et peuvent être entièrement omis :

  #[handler]
  async fn hello(res: &mut Response) {
      res.render("Hello world");
  }

• N'importe quel type peut être utilisé comme type de retour de la fonction tant qu'il implémente le trait Writer. Par exemple, &str implémente Writer, et lorsqu'il est retourné, il imprime du texte brut :

  #[handler]
  async fn hello(res: &mut Response) -> &'static str {
      "Hello world"
  }

• Plus couramment, nous avons besoin d'utiliser Result<T, E> comme type de retour pour gérer les erreurs lors de l'exécution de la fonction. Si T et E implémentent tous deux Writer, alors Result<T, E> peut être utilisé comme valeur de retour :

  #[handler]
  async fn hello(res: &mut Response) -> Result<&'static str, ()> {
      Ok("Hello world")
  }

#HTTP3 Élégant

On dit qu'HTTP3 est aussi agile qu'une hirondelle, un rêve que de nombreux programmeurs ont longtemps caressé sans pouvoir l'atteindre. Cette fois, Salvo le rend possible, permettant à chacun de profiter sans effort des services merveilleux offerts par HTTP3 !

Tout d'abord, activez la fonctionnalité HTTP3 dans Cargo.toml, puis modifiez main.rs comme suit :

use salvo::conn::rustls::{Keycert, RustlsConfig};
use salvo::prelude::*;

// Handler function responding with "Hello World" for HTTP/3 requests
#[handler]
async fn hello() -> &'static str {
    "Hello World"
}

#[tokio::main]
async fn main() {
    // Initialize logging system
    tracing_subscriber::fmt().init();

    // Load TLS certificate and private key from embedded PEM files
    let cert = include_bytes!("../certs/cert.pem").to_vec();
    let key = include_bytes!("../certs/key.pem").to_vec();

    // Create router with single endpoint
    let router = Router::new().get(hello);

    // Configure TLS settings using Rustls
    let config = RustlsConfig::new(Keycert::new().cert(cert.as_slice()).key(key.as_slice()));

    // Create TCP listener with TLS encryption on port 8698
    let listener = TcpListener::new(("0.0.0.0", 8698)).rustls(config.clone());

    // Create QUIC listener and combine with TCP listener
    let acceptor = QuinnListener::new(config.build_quinn_config().unwrap(), ("0.0.0.0", 8698))
        .join(listener)
        .bind()
        .await;

    // Start server supporting both HTTP/3 (QUIC) and HTTPS (TCP)
    Server::new(acceptor).serve(router).await;
}

[package]
name = "example-hello-h3"
version.workspace = true
edition.workspace = true
publish.workspace = true
rust-version.workspace = true

[dependencies]
salvo = { workspace = true, features = ["quinn"] }
tokio = { workspace = true, features = ["macros"] }
tracing.workspace = true
tracing-subscriber.workspace = true

#Outil CLI Salvo 🛠️

Salvo CLI est un outil conçu pour le framework web Salvo. Il aide à créer un code propre et lisible, vous faisant gagner du temps pour des choses plus intéressantes dans la vie.

Si vous avez des idées pour améliorer le CLI ou si vous remarquez des problèmes à résoudre, n'hésitez pas ! Soumettez un problème — nous accueillons vos idées.

#Étape 1

Installez l'outil CLI :

cargo install salvo-cli

#Étape 2

Créez un nouveau projet Salvo en utilisant la commande new suivie du nom de votre projet :

salvo new nom_du_projet

Avec cet outil CLI simple, vous pouvez configurer rapidement un projet Salvo, vous permettant de vous concentrer sur l'implémentation de votre logique métier plutôt que sur la configuration de la structure du projet. ✨

#Plus d'Exemples

Il est recommandé de cloner directement le dépôt Salvo et d'exécuter les exemples dans le répertoire examples. Par exemple, la commande suivante exécute l'exemple hello :

git clone https://github.com/salvo-rs/salvo
cd salvo/examples
cargo run --bin example-hello

Il y a de nombreux exemples dans le répertoire examples. Vous pouvez les exécuter en utilisant des commandes comme cargo run --bin example-<nom>.