#Schnellstart

#Rust installieren

Falls Sie Rust noch nicht installiert haben, können Sie es mit dem offiziellen rustup-Tool installieren.

#Ihr erstes Salvo-Programm

Erstellen Sie ein neues Projekt:

cargo new hello --bin

Fügen Sie Abhängigkeiten in der Cargo.toml hinzu:

[package]
name = "example-hello"
version = "0.1.0"
edition = "2024"

[dependencies]
salvo = { version = "0.77.1" }
tokio = { version = "1", features = ["macros"] }
tracing = "0.1"
tracing-subscriber = "0.3"

Erstellen Sie in main.rs einen einfachen Funktions-Handler namens hello, der einfach den Text "Hello world" ausgibt.

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 5800
    let acceptor = TcpListener::new("0.0.0.0:5800").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;
}

Glückwunsch! Ihr erstes Salvo-Programm ist fertig. Führen Sie einfach cargo run aus und öffnen Sie http://127.0.0.1:5800 in Ihrem Browser.

#Detaillierte Erklärung

Hier ist hello_world ein Handler, der Benutzeranfragen verarbeitet. #[handler] ermöglicht es einer Funktion, einfach das Handler-Trait zu implementieren. Außerdem erlaubt es uns, Funktionsparameter auf verschiedene Weise zu vereinfachen.

• Ursprüngliche Form:

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

• Sie können ungenutzte Parameter weglassen, wie z.B. _req, _depot, _ctrl:

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

• Jeder Typ kann als Rückgabetyp verwendet werden, solange er das Writer-Trait implementiert. Zum Beispiel implementiert &str Writer und gibt bei Rückgabe einfachen Text aus:

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

• Häufiger ist die Verwendung von Result<T, E> als Rückgabetyp, um Fehler während der Ausführung zu behandeln. Wenn sowohl T als auch E Writer implementieren, kann Result<T, E> als Rückgabewert dienen:

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

#Verspieltes HTTP3

Man sagt, HTTP3 sei federleicht – viele Entwickler träumen davon, aber Salvo macht es Ihnen leicht, die Vorzüge von HTTP3 zu genießen!

Aktivieren Sie zunächst die HTTP3-Funktion in der Cargo.toml und ändern Sie main.rs wie folgt:

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 5800
  let listener = TcpListener::new(("0.0.0.0", 5800)).rustls(config.clone());

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

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

#Salvo CLI-Werkzeug 🛠️

Salvo CLI ist ein Werkzeug für das Salvo-Webframework, das sauberen, lesbaren Code erzeugt und Ihnen Zeit für die schöneren Dinge des Lebens spart.

Wenn Sie Ideen zur Verbesserung der CLI haben oder Probleme entdecken, zögern Sie nicht! Eröffnen Sie ein Issue – wir freuen uns auf Ihre Beiträge.

cargo install salvo-cli

Mit diesem einfachen CLI-Werkzeug können Sie schnell Salvo-Projekte starten und sich auf Ihre Geschäftslogik konzentrieren, anstatt auf den Projektaufbau. ✨

#Weitere Beispiele

Es wird empfohlen, das Salvo-Repository direkt zu klonen und die Beispiele im examples-Verzeichnis auszuführen. Der folgende Befehl führt beispielsweise das hello-Beispiel aus:

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

Im examples-Verzeichnis finden Sie viele Beispiele. Alle können mit Befehlen wie cargo run --bin example-<name> ausgeführt werden.