Rust 的 salvo 框架是一個現代的、基于 Tokio 異步運行時的 Web 框架，它提供了構建高性能、可擴展的 Web 應用程序的能力。而 WebSocket 是一種網絡通信協議，它允許在單個 TCP 連接上進行全雙工通信。

要將 salvo 與 WebSocket 集成，你需要使用一個支持 WebSocket 的庫。在 Rust 中，有幾個流行的庫可以用來實現 WebSocket 服務器，例如 tokio-tungstenite 和 warp。

以下是一個使用 tokio-tungstenite 和 salvo 集成 WebSocket 的簡單示例：

1. 首先，添加依賴項到你的 Cargo.toml 文件：

[dependencies]
salvo = "0.6"
tokio = { version = "1", features = ["full"] }
tokio-tungstenite = "0.15"

2. 然后，創建一個簡單的 salvo 應用程序，并集成 WebSocket：

use salvo::{prelude::*, web::get, web::service, App, HttpResponse, HttpServer};
use tokio_tungstenite::accept_async;
use futures_util::{SinkExt, StreamExt};

#[derive(Clone)]
struct MyWebSocket;

impl Service for MyWebSocket {
    type Error = std::convert::Infallible;
    type Future = futures_util::stream::StreamExt<Result<tokio_tungstenite::tungstenite::Message, Self::Error>>;

    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: HttpRequest) -> Self::Future {
        let (ws_stream, _) = accept_async(req).await.expect("Failed to accept");
        println!("WebSocket connection established");

        let (_, mut read_stream) = ws_stream.split();
        let (_, mut write_stream) = ws_stream.split();

        let (mut user_tx, mut user_rx) = tokio::sync::mpsc::channel(32);

        tokio::spawn(async move {
            while let Some(message) = user_rx.recv().await {
                if let Err(e) = write_stream.send(tokio_tungstenite::tungstenite::Message::Text(message)).await {
                    eprintln!("Failed to send message: {}", e);
                }
            }
        });

        read_stream.for_each(|message| {
            match message {
                Ok(msg) => {
                    if msg.is_text() || msg.is_binary() {
                        user_tx.send(msg).unwrap();
                    } else {
                        eprintln!("Unsupported message type");
                    }
                }
                Err(e) => eprintln!("Error reading message: {}", e),
            }
        }).await;

        println!("WebSocket connection closed");
        futures_util::future::ok::<_, Self::Error>(()).boxed()
    }
}

#[get("/ws")]
async fn ws() -> HttpResponse {
    HttpResponse::Ok().content_type("text/html").body("Hello, WebSocket!")
}

#[tokio::main]
async fn main() {
    HttpServer::new(|| {
        App::new()
            .service(ws)
            .service(MyWebSocket)
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

這個示例中，我們創建了一個名為 MyWebSocket 的服務，它實現了 Service trait。當 WebSocket 連接建立時，我們將連接分成讀取和寫入部分，并使用一個通道來處理客戶端發送的消息。我們還定義了一個名為 ws 的路由，用于處理 WebSocket 連接。

請注意，這個示例僅用于演示目的，實際應用中可能需要更多的錯誤處理和功能。