#Schnellstart

#Rust installieren

Falls Sie Rust noch nicht installiert haben, können Sie das offizielle Tool (rustup)[https://doc.rust-lang.org/book/ch01-01-installation.html] verwenden, um Rust zu installieren.

#Ihr erstes Salvo-Programm schreiben

Erstellen Sie ein neues Projekt:

cargo new hello --bin

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

[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

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

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

#Detaillierte Erklärung

Hier ist hello_world ein Handler, der zur Verarbeitung von Benutzeranfragen dient. Das #[handler]-Attribut ermöglicht es einer Funktion, auf bequeme Weise das Handler-Trait zu implementieren. Darüber hinaus erlaubt es uns, Funktionsparameter auf verschiedene vereinfachte Arten zu schreiben.

• 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 in der Funktion weglassen. Zum Beispiel werden _req, _depot und _ctrl hier nicht verwendet und können vollständig entfallen:

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

• Jeder Typ kann als Rückgabetyp der Funktion verwendet werden, solange er das Writer-Trait implementiert. Beispielsweise implementiert &str das Writer-Trait, und bei Rückgabe wird Klartext ausgegeben:

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

• Häufiger müssen wir Result<T, E> als Rückgabetyp verwenden, um Fehler während der Funktionsausführung zu behandeln. Wenn sowohl T als auch E das Writer-Trait implementieren, kann Result<T, E> als Rückgabewert verwendet werden:

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

#Elegantes HTTP3

Man sagt, HTTP3 sei so flink wie eine Schwalbe, ein Traum, den viele Programmierer ersehnt, aber nie erreicht haben. Diesmal macht Salvo es möglich und erlaubt jedem, mühelos die wunderbaren Dienste von HTTP3 zu genießen!

Aktivieren Sie zunächst das HTTP3-Feature in Cargo.toml und ändern Sie dann 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 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

#Salvo CLI-Werkzeug 🛠️

Salvo CLI ist ein Werkzeug, das für das Salvo-Webframework entwickelt wurde. Es hilft dabei, sauberen, lesbaren Code zu erstellen und spart Ihnen Zeit für interessantere Dinge im Leben.

Wenn Sie Ideen zur Verbesserung der CLI haben oder Probleme bemerken, die behoben werden müssen, zögern Sie nicht! Reichen Sie ein Issue ein – wir freuen uns über Ihre Beiträge.

#Schritt 1

Installieren Sie das CLI-Werkzeug:

cargo install salvo-cli

#Schritt 2

Erstellen Sie ein neues Salvo-Projekt mit dem Befehl new, gefolgt von Ihrem Projektnamen:

salvo new projektname

Mit diesem einfachen CLI-Werkzeug können Sie schnell ein Salvo-Projekt einrichten, sodass Sie sich auf die Implementierung Ihrer Geschäftslogik konzentrieren können, anstatt auf den Projektstrukturaufbau. ✨

#Weitere Beispiele

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

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

Es gibt viele Beispiele im Verzeichnis examples. Sie können sie mit Befehlen wie cargo run --bin example-<name> ausführen.