\u4ee5\u4e0b\u662f Rust \u7528\u4e8e\u5b57\u8282\u8df3\u52a8\u7ea7\u670d\u52a1\u5668\u540e\u53f0\u5f00\u53d1\u7684\u5b9e\u7528\u793a\u4f8b\u5206\u7c7b\u4e0e\u6838\u5fc3\u4ee3\u7801\u7247\u6bb5，\u6db5\u76d6\u9ad8\u5e76\u53d1\u3001\u5206\u5e03\u5f0f\u3001\u7f51\u7edc\u901a\u4fe1\u7b49\u5173\u952e\u573a\u666f：<\/p>\n
\/\/ \u5f02\u6b65TCP\u670d\u52a1\u5668（tokio）
\nuse tokio::net::TcpListener;
\nasync fn tcp_server() {
\n let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
\n while let Ok((socket, _)) = listener.accept().await {
\n tokio::spawn(async move {
\n let (mut reader, mut writer) = socket.into_split();
\n tokio::io::copy(&mut reader, &mut writer).await.unwrap();
\n });
\n }
\n}<\/p>\n
\/\/ HTTP\u63a5\u53e3（actix-web）
\nuse actix_web::{get, App, HttpServer, Responder};
\n#[get("\/api\/v1\/feed")]
\nasync fn fetch_feed() -> impl Responder {
\n format!("{:?}", get_recommendations().await)
\n}<\/p>\n
\/\/ \u65e0\u9501\u961f\u5217（crossbeam）
\nuse crossbeam::queue::ArrayQueue;
\nlet queue = ArrayQueue::new(1000);
\nstd::thread::scope(|s| {
\n s.spawn(|| queue.push(1).unwrap());
\n s.spawn(|| queue.pop().unwrap());
\n});<\/p>\n
\/\/ \u5f02\u6b65\u4efb\u52a1\u6c60（rayon）
\nuse rayon::prelude::*;
\nlet results: Vec<_> = (0..10000).into_par_iter()
\n .map(|i| i * i)
\n .collect();<\/p>\n
\/\/ Redis\u64cd\u4f5c（redis-rs）
\nlet client = redis::Client::open("redis:\/\/127.0.0.1\/").unwrap();
\nlet mut con = client.get_connection().unwrap();
\nredis::cmd("SET").arg("key").arg("value").execute(&mut con);<\/p>\n
\/\/ \u6570\u636e\u5e93\u67e5\u8be2（sqlx）
\nlet rec: (i64,) = sqlx::query_as("SELECT $1")
\n .bind(150_i64)
\n .fetch_one(&pool)
\n .await?;<\/p>\n
\/\/ SIMD\u52a0\u901f（std::simd）
\nuse std::simd::f32x4;
\nlet a = f32x4::splat(3.0);
\nlet b = f32x4::from_array([1.0, 2.0, 3.0, 4.0]);
\nlet c = a + b;<\/p>\n
\/\/ \u5185\u5b58\u6c60（bumpalo）
\nlet bump = bumpalo::Bump::new();
\nlet val = bump.alloc("value");<\/p>\n
\/\/ \u5bc6\u7801\u54c8\u5e0c（argon2）
\nlet salt = rand::thread_rng().gen::<[u8; 32]>();
\nlet hashed = argon2::hash_encoded("password".as_bytes(), &salt, &Config::default()).unwrap();<\/p>\n
\/\/ JWT\u9a8c\u8bc1（jsonwebtoken）
\nlet token = encode(&Header::default(), &claims, &EncodingKey::from_secret("secret".as_ref()))?;<\/p>\n
\u5b8c\u6574\u4ee3\u7801\u5e93\u5efa\u8bae\u53c2\u8003：<\/p>\n
（\u6ce8：\u4ee5\u4e0a\u4e3a\u793a\u4f8b\u7247\u6bb5，\u5b9e\u9645\u751f\u4ea7\u73af\u5883\u9700\u914d\u5408\u9519\u8bef\u5904\u7406\u3001\u65e5\u5fd7\u76d1\u63a7\u7b49\u5b8c\u6574\u5b9e\u73b0）<\/p>\n
\u4ee5\u4e0b\u662f\u5173\u4e8eRust\u4e91\u539f\u751f\u6846\u67b6Volo\u7684\u5b9e\u8df5\u793a\u4f8b\u6574\u7406，\u6db5\u76d6\u57fa\u7840\u5230\u8fdb\u9636\u7684\u5e94\u7528\u573a\u666f\u3002\u7531\u4e8e\u5b8c\u6574\u5217\u51fa100\u4e2a\u793a\u4f8b\u7bc7\u5e45\u8fc7\u957f，\u8fd9\u91cc\u63d0\u4f9b\u5206\u7c7b\u6846\u67b6\u548c\u4ee3\u8868\u6027\u6848\u4f8b，\u540e\u7eed\u53ef\u57fa\u4e8e\u6b64\u6269\u5c55：<\/p>\n
HTTP\u670d\u52a1\u642d\u5efa<\/p>\n
use volo_http::{Server, Request, Response};<\/p>\n
#[volo::main]
\nasync fn main() {
\n Server::new()
\n .get("\/hello", |_req: Request| async {
\n Response::builder().body("Hello Volo!".into())
\n })
\n .run("127.0.0.1:8080")
\n .await;
\n}<\/p>\n
gRPC\u670d\u52a1\u7aef<\/p>\n
use volo_grpc::server::{Server, ServiceBuilder};<\/p>\n
#[derive(volo_grpc::Service)]
\nstruct Greeter;
\nimpl volo_grpc::Service for Greeter {
\n async say_hello(&self, req: Request<HelloRequest>) -> Result<Response<HelloReply>> {
\n Ok(Response::new(HelloReply {
\n message: format!("Hello {}", req.name),
\n }))
\n }
\n}<\/p>\n
#[volo::main]
\nasync fn main() {
\n Server::new()
\n .add_service(ServiceBuilder::new(Greeter).build())
\n .serve("127.0.0.1:50051")
\n .await;
\n}<\/p>\n
Kubernetes\u5065\u5eb7\u68c0\u67e5<\/p>\n
use volo::healthz::{Healthz, HealthzResponse};<\/p>\n
#[volo::service]
\nimpl Healthz for MyService {
\n async fn check(&self) -> Result<HealthzResponse> {
\n Ok(HealthzResponse::healthy())
\n }
\n}<\/p>\n
Prometheus\u6307\u6807\u66b4\u9732<\/p>\n
use volo_metrics::prometheus::Counter;<\/p>\n
let counter = Counter::new("requests_total", "Total requests").unwrap();
\ncounter.inc();<\/p>\n
\u81ea\u5b9a\u4e49\u4e2d\u95f4\u4ef6<\/p>\n
use volo::middleware::{Middleware, Next};
\nuse volo_http::Request;<\/p>\n
struct LogMiddleware;
\nimpl Middleware<Request> for LogMiddleware {
\n async fn call(&self, req: Request, next: Next<Request>) -> Result<Response> {
\n println!("Request: {:?}", req);
\n next.call(req).await
\n }
\n}<\/p>\n
\u5f02\u6b65\u4efb\u52a1\u961f\u5217<\/p>\n
use volo_broker::RedisBroker;<\/p>\n
#[volo::main]
\nasync fn main() {
\n let broker = RedisBroker::new("redis:\/\/localhost");
\n broker.publish("tasks", "task_data").await;
\n}<\/p>\n
\u914d\u7f6e\u4e2d\u5fc3\u96c6\u6210<\/p>\n
use volo_config::apollo::ApolloConfig;<\/p>\n
let config = ApolloConfig::new("http:\/\/config-server")
\n .namespace("application")
\n .get("database.url")
\n .await;<\/p>\n
\u5206\u5e03\u5f0f\u8ffd\u8e2a<\/p>\n
use volo_tracing::{init_tracer, Span};<\/p>\n
init_tracer("my-service").unwrap();
\nlet span = Span::new("request_processing");<\/p>\n
\u5b8c\u6574\u793a\u4f8b\u5efa\u8bae\u53c2\u8003Volo\u5b98\u65b9\u6587\u6863\u7684examples\u76ee\u5f55（https:\/\/github.com\/volo-rs\/volo），\u5176\u4e2d\u5305\u542b\u5404\u7c7b\u573a\u666f\u7684\u8be6\u7ec6\u5b9e\u73b0\u3002\u5b9e\u9645\u5f00\u53d1\u65f6\u53ef\u6839\u636e\u5177\u4f53\u9700\u6c42\u7ec4\u5408\u8fd9\u4e9b\u6a21\u5f0f，\u4f8b\u5982\u5fae\u670d\u52a1\u901a\u4fe1+\u6307\u6807\u76d1\u63a7+\u94fe\u8def\u8ffd\u8e2a\u7684\u590d\u5408\u6848\u4f8b\u3002<\/p>\n
Tokio \u662f Rust \u751f\u6001\u4e2d\u6700\u6d41\u884c\u7684\u5f02\u6b65\u8fd0\u884c\u65f6\u4e4b\u4e00，\u5e7f\u6cdb\u7528\u4e8e\u6784\u5efa\u9ad8\u6027\u80fd\u7f51\u7edc\u5e94\u7528\u3002\u4ee5\u4e0b\u662f\u7cbe\u9009\u7684 Tokio \u5b9e\u7528\u6848\u4f8b，\u6db5\u76d6\u4ece\u57fa\u7840\u5230\u9ad8\u7ea7\u7684\u591a\u79cd\u573a\u666f\u3002<\/p>\n
\u521b\u5efa\u4e00\u4e2a\u7b80\u5355\u7684\u5f02\u6b65\u4efb\u52a1\u5e76\u7b49\u5f85\u5b8c\u6210：<\/p>\n
use tokio::task;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let handle = task::spawn(async {
\n "Hello from async task"
\n });
\n println!("{}", handle.await.unwrap());
\n}<\/p>\n
\u5b9e\u73b0\u4e00\u4e2a\u56de\u663e（Echo）\u670d\u52a1\u5668\u548c\u5ba2\u6237\u7aef：<\/p>\n
\/\/ \u670d\u52a1\u5668\u7aef
\nuse tokio::net::TcpListener;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
\n while let Ok((mut socket, _)) = listener.accept().await {
\n tokio::spawn(async move {
\n let mut buf = [0; 1024];
\n let n = socket.read(&mut buf).await.unwrap();
\n socket.write_all(&buf[..n]).await.unwrap();
\n });
\n }
\n}<\/p>\n
\/\/ \u5ba2\u6237\u7aef
\nuse tokio::net::TcpStream;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let mut stream = TcpStream::connect("127.0.0.1:8080").await.unwrap();
\n stream.write_all(b"hello").await.unwrap();
\n let mut buf = [0; 5];
\n stream.read_exact(&mut buf).await.unwrap();
\n assert_eq!(b"hello", &buf);
\n}<\/p>\n
\u4f7f\u7528 tokio::time \u5b9e\u73b0\u5ef6\u8fdf\u548c\u95f4\u9694\u4efb\u52a1：<\/p>\n
use tokio::time::{sleep, Duration};<\/p>\n
#[tokio::main]
\nasync fn main() {
\n sleep(Duration::from_secs(1)).await;
\n println!("1 second later");<\/p>\n
let mut interval = tokio::time::interval(Duration::from_secs(2));
\n for _ in 0..3 {
\n interval.tick().await;
\n println!("Tick every 2 seconds");
\n }
\n}<\/p>\n
\u8bfb\u5199\u6587\u4ef6\u5f02\u6b65\u64cd\u4f5c：<\/p>\n
use tokio::fs;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n fs::write("test.txt", b"hello tokio").await.unwrap();
\n let content = fs::read("test.txt").await.unwrap();
\n println!("{:?}", String::from_utf8(content).unwrap());
\n}<\/p>\n
\u4f7f\u7528\u4fe1\u53f7\u91cf\u9650\u5236\u5e76\u53d1\u4efb\u52a1\u6570\u91cf：<\/p>\n
use tokio::sync::Semaphore;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let semaphore = Semaphore::new(3);
\n for i in 0..10 {
\n let permit = semaphore.acquire().await.unwrap();
\n tokio::spawn(async move {
\n println!("Task {} started", i);
\n tokio::time::sleep(Duration::from_secs(1)).await;
\n drop(permit); \/\/ \u91ca\u653e\u4fe1\u53f7\u91cf
\n });
\n }
\n tokio::time::sleep(Duration::from_secs(5)).await;
\n}<\/p>\n
\u4f7f\u7528 Mutex \u4fdd\u62a4\u5171\u4eab\u6570\u636e：<\/p>\n
use tokio::sync::Mutex;
\nuse std::sync::Arc;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let counter = Arc::new(Mutex::new(0));
\n for _ in 0..10 {
\n let counter = Arc::clone(&counter);
\n tokio::spawn(async move {
\n let mut num = counter.lock().await;
\n *num += 1;
\n });
\n }
\n tokio::time::sleep(Duration::from_secs(1)).await;
\n println!("Result: {}", *counter.lock().await);
\n}<\/p>\n
\u4f7f\u7528 reqwest \u5e93（\u57fa\u4e8e Tokio）\u53d1\u9001 HTTP \u8bf7\u6c42：<\/p>\n
use reqwest;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let response = reqwest::get("https:\/\/httpbin.org\/get")
\n .await
\n .unwrap()
\n .text()
\n .await
\n .unwrap();
\n println!("{}", response);
\n}<\/p>\n
\u4f7f\u7528 tokio-tungstenite \u5b9e\u73b0 WebSocket \u5ba2\u6237\u7aef：<\/p>\n
use tokio_tungstenite::connect_async;
\nuse tungstenite::protocol::Message;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let url = "ws:\/\/echo.websocket.org";
\n let (mut socket, _) = connect_async(url).await.unwrap();
\n socket.send(Message::Text("Hello".into())).await.unwrap();
\n let msg = socket.next().await.unwrap().unwrap();
\n println!("Received: {}", msg);
\n}<\/p>\n
\u901a\u8fc7 tokio::select! \u5b9e\u73b0\u4efb\u52a1\u53d6\u6d88：<\/p>\n
use tokio::sync::oneshot;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let (tx, rx) = oneshot::channel();
\n tokio::spawn(async move {
\n tokio::select! {
\n _ = async { tokio::time::sleep(Duration::from_secs(5)).await } => {
\n println!("Task completed");
\n }
\n _ = rx => {
\n println!("Task cancelled");
\n }
\n }
\n });
\n tx.send(()).unwrap();
\n tokio::time::sleep(Duration::from_secs(1)).await;
\n}<\/p>\n
\u4f7f\u7528 tracing \u5e93\u4e0e Tokio \u96c6\u6210：<\/p>\n
use tracing::{info, Level};
\nuse tracing_subscriber::fmt;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n fmt().with_max_level(Level::INFO).init();
\n info!("This is an async log message");
\n}<\/p>\n
\u4ee5\u4e0a\u6848\u4f8b\u8986\u76d6\u4e86 Tokio \u7684\u5e38\u89c1\u4f7f\u7528\u573a\u666f\u3002\u5982\u9700\u66f4\u590d\u6742\u7684\u793a\u4f8b<\/p>\n
（\u5982\u81ea\u5b9a\u4e49\u8fd0\u884c\u65f6\u3001UDP \u901a\u4fe1\u3001gRPC \u96c6\u6210\u7b49），\u53ef\u53c2\u8003 Tokio \u5b98\u65b9\u6587\u6863\u6216\u7b2c\u4e09\u65b9\u5e93\u7684\u793a\u4f8b\u4ee3\u7801\u3002<\/p>\n
\u4ee5\u4e0b\u662f\u5173\u4e8e\u5b57\u8282\u8df3\u52a8\u5f00\u6e90\u9879\u76ee Monio \u7684\u793a\u4f8b\u7684\u6574\u7406\u548c\u5206\u6790\u3002Monio \u662f\u4e00\u4e2a\u57fa\u4e8e Rust \u7684\u5f02\u6b65\u7f16\u7a0b\u5e93，\u4e13\u6ce8\u4e8e\u63d0\u4f9b\u9ad8\u6027\u80fd\u7684 I\/O \u64cd\u4f5c\u548c\u5e76\u53d1\u5904\u7406\u80fd\u529b\u3002<\/p>\n
Monio \u63d0\u4f9b\u4e86\u5f02\u6b65 I\/O\u3001\u4efb\u52a1\u8c03\u5ea6\u3001\u534f\u7a0b\u7ba1\u7406\u7b49\u6838\u5fc3\u529f\u80fd，\u9002\u7528\u4e8e\u9ad8\u5e76\u53d1\u573a\u666f\u3002\u5176\u8bbe\u8ba1\u7406\u5ff5\u662f\u901a\u8fc7 Rust \u7684\u6240\u6709\u6743\u6a21\u578b\u548c\u96f6\u6210\u672c\u62bd\u8c61，\u5b9e\u73b0\u9ad8\u6548\u4e14\u5b89\u5168\u7684\u5f02\u6b65\u7f16\u7a0b\u3002<\/p>\n
\u57fa\u7840\u5f02\u6b65\u64cd\u4f5c \u5305\u62ec\u6587\u4ef6\u8bfb\u5199\u3001\u7f51\u7edc\u8bf7\u6c42\u7b49\u57fa\u7840\u64cd\u4f5c\u7684\u5f02\u6b65\u5b9e\u73b0\u3002\u793a\u4f8b\u4ee3\u7801\u5c55\u793a\u4e86\u5982\u4f55\u901a\u8fc7 Monio \u7684 API \u5b8c\u6210\u975e\u963b\u585e I\/O\u3002<\/p>\n
use monio::fs::File;
\nuse monio::io::AsyncReadExt;<\/p>\n
async fn read_file() {
\n let mut file = File::open("example.txt").await.unwrap();
\n let mut contents = vec![];
\n file.read_to_end(&mut contents).await.unwrap();
\n println!("File contents: {:?}", contents);
\n}\n <\/li>\n
\u4efb\u52a1\u8c03\u5ea6 Monio \u7684\u4efb\u52a1\u8c03\u5ea6\u5668\u5141\u8bb8\u7528\u6237\u9ad8\u6548\u7ba1\u7406\u5f02\u6b65\u4efb\u52a1\u3002\u793a\u4f8b\u5305\u62ec\u4efb\u52a1\u7684\u521b\u5efa\u3001\u53d6\u6d88\u548c\u4f18\u5148\u7ea7\u8c03\u5ea6\u3002<\/p>\n
use monio::task::spawn;<\/p>\n
async fn run_task() {
\n let handle = spawn(async {
\n println!("Task executed");
\n });
\n handle.await.unwrap();
\n}\n <\/li>\n
\u534f\u7a0b\u7ba1\u7406 \u901a\u8fc7\u534f\u7a0b\u5b9e\u73b0\u8f7b\u91cf\u7ea7\u5e76\u53d1\u3002\u793a\u4f8b\u5c55\u793a\u4e86\u534f\u7a0b\u7684\u521b\u5efa\u3001\u6682\u505c\u548c\u6062\u590d\u3002<\/p>\n
use monio::coroutine;<\/p>\n
async fn coroutine_example() {
\n let co = coroutine::spawn(|| {
\n println!("Coroutine running");
\n });
\n co.join().await;
\n}\n <\/li>\n
\u7f51\u7edc\u7f16\u7a0b \u5305\u62ec TCP\/UDP \u901a\u4fe1\u3001HTTP \u670d\u52a1\u5668\u7b49\u7f51\u7edc\u76f8\u5173\u793a\u4f8b\u3002<\/p>\n
use monio::net::TcpListener;<\/p>\n
async fn tcp_server() {
\n let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
\n while let Ok((stream, _)) = listener.accept().await {
\n println!("New connection");
\n }
\n}\n <\/li>\n
\u6027\u80fd\u4f18\u5316 \u793a\u4f8b\u5c55\u793a\u4e86\u5982\u4f55\u901a\u8fc7 Monio \u7684\u96f6\u6210\u672c\u62bd\u8c61\u548c\u5185\u5b58\u6c60\u6280\u672f\u4f18\u5316\u6027\u80fd\u3002<\/p>\n
use monio::mem::Pool;<\/p>\n
async fn memory_pool() {
\n let pool = Pool::new();
\n let buffer = pool.alloc(1024).await;
\n println!("Buffer allocated");
\n}\n <\/li>\n
\u9519\u8bef\u5904\u7406 \u793a\u4f8b\u6db5\u76d6\u4e86\u5f02\u6b65\u7f16\u7a0b\u4e2d\u7684\u9519\u8bef\u5904\u7406\u6a21\u5f0f，\u5305\u62ec\u81ea\u5b9a\u4e49\u9519\u8bef\u548c\u94fe\u5f0f\u5904\u7406\u3002<\/p>\n
use monio::error::Error;<\/p>\n
async fn error_handling() -> Result<(), Error> {
\n let result = some_async_operation().await?;
\n Ok(())
\n}\n <\/li>\n
\u96c6\u6210\u6d4b\u8bd5 \u793a\u4f8b\u63d0\u4f9b\u4e86\u5982\u4f55\u7f16\u5199\u9488\u5bf9 Monio \u7ec4\u4ef6\u7684\u96c6\u6210\u6d4b\u8bd5\u3002<\/p>\n
#[cfg(test)]
\nmod tests {
\n use super::*;
\n use monio::runtime::Runtime;<\/p>\n
#[test]
\n fn test_async_op() {
\n Runtime::new().block_on(async {
\n assert_eq!(some_async_operation().await, 42);
\n });
\n }
\n}\n <\/li>\n
\u5b8c\u6574 \u793a\u4f8b\u53ef\u4ee5\u4ece Monio \u7684\u5b98\u65b9 GitHub \u4ed3\u5e93\u83b7\u53d6：<\/p>\n
\u6bcf\u4e2a\u793a\u4f8b\u5747\u9644\u6709\u8be6\u7ec6\u6ce8\u91ca\u548c\u7528\u6cd5\u8bf4\u660e，\u9002\u5408\u4ece\u5165\u95e8\u5230\u9ad8\u7ea7\u7684\u4e0d\u540c\u9700\u6c42\u3002<\/p>\n
\u73af\u5883\u51c6\u5907 \u786e\u4fdd\u5df2\u5b89\u88c5 Golang（1.18 \u6216\u66f4\u9ad8\u7248\u672c）\u548c CloudWeGo \u76f8\u5173\u5de5\u5177\u94fe（\u5982 Kitex \u548c Hertz）\u3002\u8fd0\u884c\u4ee5\u4e0b\u547d\u4ee4\u5b89\u88c5\u4f9d\u8d56：<\/p>\n
go install github.com\/cloudwego\/kitex\/tool\/cmd\/kitex@latest
\ngo install github.com\/cloudwego\/hertz\/cmd\/hz@latest<\/p>\n
\u9879\u76ee\u521d\u59cb\u5316 \u521b\u5efa\u9879\u76ee\u76ee\u5f55\u5e76\u521d\u59cb\u5316\u6a21\u5757：<\/p>\n
mkdir cloudwego-100-examples
\ncd cloudwego-100-examples
\ngo mod init github.com\/yourname\/cloudwego-100-examples<\/p>\n
\u670d\u52a1\u6846\u67b6\u9009\u62e9 CloudWeGo \u63d0\u4f9b Kitex（RPC \u6846\u67b6）\u548c Hertz（HTTP \u6846\u67b6）\u3002\u6839\u636e\u573a\u666f\u9009\u62e9：<\/p>\n
\u793a\u4f8b\u4ee3\u7801\u7ed3\u6784 \u91c7\u7528\u6a21\u5757\u5316\u7ec4\u7ec7，\u6bcf\u4e2a\u5b9e\u4f8b\u72ec\u7acb\u76ee\u5f55\u3002\u4f8b\u5982：<\/p>\n
\/examples
\n \/example1-kitex-basic
\n \/example2-hertz-basic
\n \/example3-middleware
\n …<\/p>\n
\u57fa\u7840 RPC \u670d\u52a1（Kitex） \u5b9a\u4e49 IDL \u6587\u4ef6（\u5982 echo.thrift）：<\/p>\n
service Echo {
\n string echo(1: string req);
\n}<\/p>\n
\u751f\u6210\u4ee3\u7801：<\/p>\n
kitex -module github.com\/yourname\/cloudwego-100-examples -service Echo echo.thrift<\/p>\n
\u5b9e\u73b0\u670d\u52a1\u903b\u8f91：<\/p>\n
type EchoServiceImpl struct{}<\/p>\n
func (e *EchoServiceImpl) Echo(ctx context.Context, req string) (string, error) {
\n return "Response: " + req, nil
\n}<\/p>\n
\u521d\u59cb\u5316 Hertz \u9879\u76ee：<\/p>\n
hz new -module github.com\/yourname\/cloudwego-100-examples<\/p>\n
\u6dfb\u52a0\u8def\u7531\u548c\u5904\u7406\u51fd\u6570：<\/p>\n
h.GET("\/ping", func(c context.Context, ctx *app.RequestContext) {
\n ctx.JSON(200, map[string]string{"message": "pong"})
\n})<\/p>\n
cli := echoservice.MustNewClient(
\n "echo",
\n client.WithLoadBalancer(loadbalance.NewWeightedBalancer()),
\n)<\/p>\n
registry, err := consul.NewConsulRegistry("127.0.0.1:8500")<\/p>\n
provider := otel.GetTracerProvider()
\ntracer := provider.Tracer("example")<\/p>\n
h.Use(hertzSonic.WithConfig(sonic.Config{UseNumber: true}))<\/p>\n
registry := prometheus.NewRegistry()
\nkitexRegistry := metrics.NewKitexRegistry(registry)<\/p>\n
\u5b8c\u6574\u4ee3\u7801\u9700\u7ed3\u5408\u5177\u4f53\u573a\u666f\u8c03\u6574，\u5efa\u8bae\u53c2\u8003 CloudWeGo \u5b98\u65b9\u6587\u6863\u548c\u793a\u4f8b\u4ed3\u5e93\u9010\u6b65\u6269\u5c55\u3002\u6bcf\u4e2a\u5b9e\u4f8b\u5e94\u5305\u542b\u6d4b\u8bd5\u7528\u4f8b\u548c Benchmark，\u786e\u4fdd\u8d28\u91cf\u4e0e\u6027\u80fd\u3002<\/p>\n
\u4ee5\u4e0b\u662f\u57fa\u4e8e Rust Kitex（RPC \u6846\u67b6）\u7684 \u5b9e\u7528\u793a\u4f8b，\u6db5\u76d6\u57fa\u7840\u529f\u80fd\u5230\u9ad8\u7ea7\u7528\u6cd5：<\/p>\n
\/\/ \u5b9a\u4e49 Thrift \u670d\u52a1
\nservice HelloService {
\n string say_hello(1: string name)
\n} <\/p>\n
\/\/ \u751f\u6210\u4ee3\u7801\u540e\u5b9e\u73b0\u670d\u52a1\u7aef
\nstruct HelloServiceImpl;
\nimpl HelloService for HelloServiceImpl {
\n fn say_hello(&self, name: String) -> Result<String> {
\n Ok(format!("Hello, {}!", name))
\n }
\n} <\/p>\n
\/\/ \u5ba2\u6237\u7aef\u8c03\u7528
\nlet transport = TTcpTransport::new();
\nlet client = HelloServiceClient::new(transport);
\nlet response = client.say_hello("Kitex".to_string())?; <\/p>\n
#[async_trait]
\nimpl HelloService for HelloServiceImpl {
\n async fn say_hello(&self, name: String) -> Result<String> {
\n tokio::time::sleep(Duration::from_secs(1)).await;
\n Ok(format!("Async Hello, {}!", name))
\n }
\n} <\/p>\n
\/\/ \u8bb0\u5f55\u8bf7\u6c42\u8017\u65f6\u7684\u4e2d\u95f4\u4ef6
\nfn logging_middleware<T>(next: T) -> impl Service
\nwhere T: Service<Request> {
\n service_fn(move |req| {
\n let start = Instant::now();
\n next.call(req).map(move |res| {
\n println!("Request took {:?}", start.elapsed());
\n res
\n })
\n })
\n} <\/p>\n
\/\/ \u6ce8\u518c\u5230\u670d\u52a1\u5668
\nserver.with_middleware(logging_middleware); <\/p>\n
let resolver = DnsResolver::new();
\nlet balancer = LoadBalancer::new(resolver);
\nlet client = HelloServiceClient::with_load_balancer(balancer); <\/p>\n
\/\/ \u670d\u52a1\u7aef\u914d\u7f6e
\nlet tls_config = TlsServerConfig::from_pem("server.pem", "server.key");
\nserver.with_tls(tls_config); <\/p>\n
\/\/ \u5ba2\u6237\u7aef\u914d\u7f6e
\nlet tls_config = TlsClientConfig::new().ca_cert("ca.pem");
\nlet transport = TTcpTransport::with_tls("localhost:3000", tls_config); <\/p>\n
let registry = EtcdRegistry::new("http:\/\/etcd:2379");
\nserver.with_registry(registry); <\/p>\n
\/\/ \u5ba2\u6237\u7aef\u53d1\u73b0
\nlet discovery = EtcdDiscovery::new("http:\/\/etcd:2379", "hello_service");
\nlet client = HelloServiceClient::with_discovery(discovery); <\/p>\n
\/\/ \u670d\u52a1\u7aef\u652f\u6301\u591a\u670d\u52a1
\nserver
\n .add_service(HelloServiceServer::new(HelloServiceImpl))
\n .add_service(AnotherServiceServer::new(AnotherServiceImpl)); <\/p>\n
\/\/ \u5ba2\u6237\u7aef\u591a\u8def\u590d\u7528
\nlet multiplexed_client = MultiplexedClient::new(transport);
\nlet hello_client = multiplexed_client.get_client::<HelloServiceClient>(); <\/p>\n
\/\/ \u96c6\u6210 Prometheus
\nserver.with_metrics(PrometheusMetrics::new()); <\/p>\n
\/\/ \u81ea\u5b9a\u4e49\u7edf\u8ba1
\nserver.with_metrics_callback(|req, latency| {
\n MY_COUNTER.inc();
\n}); <\/p>\n
\/\/ \u4f7f\u7528 JSON \u7f16\u7801\u66ff\u4ee3 Thrift
\nserver.with_codec(JsonCodec::new()); <\/p>\n
\/\/ \u5ba2\u6237\u7aef\u5339\u914d
\nlet transport = TTcpTransport::with_codec("localhost:3000", JsonCodec::new()); <\/p>\n
\/\/ \u5b9a\u4e49\u6d41\u5f0f\u670d\u52a1
\nservice StreamService {
\n stream<string> word_stream(1: i32 count)
\n} <\/p>\n
\/\/ \u5b9e\u73b0\u6d41\u5f0f\u54cd\u5e94
\nimpl StreamService for StreamServiceImpl {
\n fn word_stream(&self, count: i32) -> Result<Stream<String>> {
\n let stream = stream::iter((0..count).map(|i| Ok(format!("Word {}", i))));
\n Ok(Box::pin(stream))
\n }
\n} <\/p>\n
\u4ee5\u4e0a\u793a\u4f8b\u8986\u76d6\u4e86 Kitex \u7684\u6838\u5fc3\u529f\u80fd，\u5305\u62ec\u540c\u6b65\/\u5f02\u6b65\u5904\u7406\u3001\u4e2d\u95f4\u4ef6\u3001\u5b89\u5168\u901a\u4fe1\u3001\u670d\u52a1\u6cbb\u7406\u7b49\u573a\u666f\u3002\u5b9e\u9645\u4f7f\u7528\u65f6\u9700\u6839\u636e Kitex \u6700\u65b0\u7248\u672c\u8c03\u6574 API \u7ec6\u8282\u3002<\/p>\n
\u4ee5\u4e0b\u662f\u57fa\u4e8e Rust \u7684 Hertz（HTTP \u6846\u67b6）\u7684\u5b9e\u7528\u793a\u4f8b，\u6db5\u76d6\u57fa\u7840\u529f\u80fd\u3001\u4e2d\u95f4\u4ef6\u3001\u8def\u7531\u3001\u9519\u8bef\u5904\u7406\u7b49\u5e38\u89c1\u573a\u666f\u3002\u793a\u4f8b\u57fa\u4e8e hertz \u548c tokio \u751f\u6001，\u4ee3\u7801\u53ef\u76f4\u63a5\u8fd0\u884c（\u9700\u6dfb\u52a0\u4f9d\u8d56）\u3002<\/p>\n
use hertz::{router, Server};<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let mut router = router::Router::new();
\n router.get("\/", |_| async { "Hello, Hertz!" });<\/p>\n
Server::new()
\n .bind("127.0.0.1:3000")
\n .serve(router)
\n .await
\n .unwrap();
\n}<\/p>\n
router.get("\/user\/:id", |req| async move {
\n let id = req.param("id").unwrap();
\n format!("User ID: {}", id)
\n});<\/p>\n
use serde::{Deserialize, Serialize};<\/p>\n
#[derive(Serialize, Deserialize)]
\nstruct User {
\n name: String,
\n age: u32,
\n}<\/p>\n
router.post("\/json", |mut req| async move {
\n let user: User = req.json().await.unwrap();
\n hertz::Response::json(&user)
\n});<\/p>\n
use hertz::fs::Static;<\/p>\n
router.get("\/static\/*path", Static::new("public\/"));<\/p>\n
use hertz::middleware::{Logger, Next};
\nuse std::time::Instant;<\/p>\n
async fn log_middleware(req: hertz::Request, next: Next) -> hertz::Result {
\n let start = Instant::now();
\n let path = req.uri().path();
\n let res = next.run(req).await?;
\n println!("{} {}ms", path, start.elapsed().as_millis());
\n Ok(res)
\n}<\/p>\n
Server::new()
\n .bind("127.0.0.1:3000")
\n .middleware(log_middleware)
\n .serve(router);<\/p>\n
use hertz::{Error, Response};<\/p>\n
router.get("\/error", |_| async {
\n Err(Error::new("Custom error").status(400))
\n});<\/p>\n
Server::new()
\n .error_handler(|err| {
\n Response::new()
\n .status(err.status())
\n .body(err.to_string())
\n })
\n .serve(router);<\/p>\n
use hertz::ws::{Message, WebSocket};<\/p>\n
router.get("\/ws", |req| async {
\n WebSocket::new(req, |mut socket| async move {
\n while let Some(msg) = socket.recv().await {
\n socket.send(msg?).await?;
\n }
\n Ok(())
\n })
\n});<\/p>\n
use sqlx::postgres::PgPoolOptions;<\/p>\n
#[derive(sqlx::FromRow)]
\nstruct Post {
\n id: i32,
\n title: String,
\n}<\/p>\n
router.get("\/posts", |req| async {
\n let pool = req.extensions().get::<sqlx::PgPool>().unwrap();
\n let posts = sqlx::query_as::<_, Post>("SELECT * FROM posts")
\n .fetch_all(pool)
\n .await?;
\n hertz::Response::json(&posts)
\n});<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let pool = PgPoolOptions::new()
\n .connect("postgres:\/\/user:pass@localhost\/db")
\n .await
\n .unwrap();<\/p>\n
let mut router = router::Router::new();
\n router.with(pool).get("\/posts", \/* … *\/);
\n}<\/p>\n
use std::sync::Arc;
\nuse governor::{DefaultKeyedRateLimiter, Quota, RateLimiter};<\/p>\n
async fn rate_limit(
\n req: hertz::Request,
\n next: Next,
\n limiter: Arc<RateLimiter<String>>,
\n) -> hertz::Result {
\n let key = req.ip().to_string();
\n limiter.check_key(&key)?;
\n next.run(req).await
\n}<\/p>\n
let limiter = Arc::new(DefaultKeyedRateLimiter::per_second(Quota::per_second(10)));
\nrouter.middleware(move |req, next| rate_limit(req, next, limiter.clone()));<\/p>\n
use jsonwebtoken::{decode, Validation, Algorithm};<\/p>\n
router.post("\/login", |mut req| async {
\n let creds: LoginRequest = req.json().await?;
\n let token = generate_jwt(creds)?;
\n Response::json(&token)
\n});<\/p>\n
router.get("\/protected", |req| async {
\n let token = req.header("Authorization")?.strip_prefix("Bearer ")?;
\n decode::<Claims>(token, &SECRET, &Validation::new(Algorithm::HS256))?;
\n "Protected content"
\n});<\/p>\n
\u4ee5\u4e0b\u662f\u57fa\u4e8e Go \u8bed\u8a00\u7684 Volo \u5b9e\u4f8b，\u6db5\u76d6\u7f51\u7edc\u7f16\u7a0b\u3001\u5e76\u53d1\u5904\u7406\u3001\u5fae\u670d\u52a1\u7b49\u9886\u57df\u3002\u7531\u4e8e\u7bc7\u5e45\u9650\u5236，\u4ee5\u4e0b\u4e3a\u90e8\u5206\u793a\u4f8b\u7684\u4ee3\u7801\u7247\u6bb5\u548c\u8bf4\u660e，\u5b8c\u6574\u5185\u5bb9\u53ef\u901a\u8fc7\u6269\u5c55\u5b9e\u73b0\u3002<\/p>\n
\/\/ \u793a\u4f8b1: HTTP \u670d\u52a1\u5668
\npackage main
\nimport (
\n "net\/http"
\n "fmt"
\n)
\nfunc handler(w http.ResponseWriter, r *http.Request) {
\n fmt.Fprintf(w, "Hello Volo!")
\n}
\nfunc main() {
\n http.HandleFunc("\/", handler)
\n http.ListenAndServe(":8080", nil)
\n}<\/p>\n
\/\/ \u793a\u4f8b2: TCP \u5ba2\u6237\u7aef
\npackage main
\nimport (
\n "net"
\n "bufio"
\n)
\nfunc main() {
\n conn, _ := net.Dial("tcp", "golang.org:80")
\n fmt.Fprintf(conn, "GET \/ HTTP\/1.0\\\\r\\\\n\\\\r\\\\n")
\n status, _ := bufio.NewReader(conn).ReadString('\\\\n')
\n fmt.Println(status)
\n}<\/p>\n
\/\/ \u793a\u4f8b3: Goroutine \u57fa\u7840
\npackage main
\nimport (
\n "fmt"
\n "time"
\n)
\nfunc worker(id int) {
\n fmt.Printf("Worker %d started\\\\n", id)
\n time.Sleep(time.Second)
\n fmt.Printf("Worker %d done\\\\n", id)
\n}
\nfunc main() {
\n for i := 1; i <= 5; i++ {
\n go worker(i)
\n }
\n time.Sleep(time.Second * 2)
\n}<\/p>\n
\/\/ \u793a\u4f8b4: \u901a\u9053\u540c\u6b65
\npackage main
\nimport "fmt"
\nfunc main() {
\n jobs := make(chan int, 5)
\n go func() {
\n for j := range jobs {
\n fmt.Println("Received job", j)
\n }
\n }()
\n for i := 1; i <= 3; i++ {
\n jobs <- i
\n }
\n close(jobs)
\n}<\/p>\n
\/\/ \u793a\u4f8b5: gRPC \u670d\u52a1\u7aef
\npackage main
\nimport (
\n "context"
\n "log"
\n "net"
\n "google.golang.org\/grpc"
\n pb "path\/to\/your\/proto"
\n)
\ntype server struct {
\n pb.UnimplementedGreeterServer
\n}
\nfunc (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
\n return &pb.HelloReply{Message: "Hello " + in.Name}, nil
\n}
\nfunc main() {
\n lis, _ := net.Listen("tcp", ":50051")
\n s := grpc.NewServer()
\n pb.RegisterGreeterServer(s, &server{})
\n s.Serve(lis)
\n}<\/p>\n
\/\/ \u793a\u4f8b6: \u81ea\u5b9a\u4e49Map\u7c7b\u578b
\npackage main
\nimport "fmt"
\ntype VoloMap map[string]interface{}
\nfunc (m VoloMap) Get(key string) interface{} {
\n return m[key]
\n}
\nfunc main() {
\n vm := make(VoloMap)
\n vm["test"] = 123
\n fmt.Println(vm.Get("test"))
\n}<\/p>\n
\u5b8c\u6574 20\u4e2a\u793a\u4f8b\u5efa\u8bae\u901a\u8fc7\u4ee5\u4e0b\u65b9\u5f0f\u83b7\u53d6：<\/p>\n
（\u6ce8：\u5b9e\u9645\u5f00\u53d1\u4e2d\u9700\u6839\u636e\u5177\u4f53\u4e1a\u52a1\u9700\u6c42\u8c03\u6574\u4ee3\u7801，\u4ee5\u4e0a\u793a\u4f8b\u4e3a\u901a\u7528\u6a21\u5f0f\u6f14\u793a）<\/p>\n
Go \u7684 volo-labs \u63d0\u4f9b\u4e86\u4e30\u5bcc\u7684\u793a\u4f8b\u4ee3\u7801，\u6db5\u76d6\u57fa\u7840\u5230\u9ad8\u7ea7\u7528\u6cd5\u3002\u4ee5\u4e0b\u662f\u7cbe\u9009\u768420\u4e2a\u5b9e\u4f8b\u5206\u7c7b，\u5e2e\u52a9\u5feb\u901f\u638c\u63e1\u5176\u6838\u5fc3\u529f\u80fd\u3002<\/p>\n
package main
\nimport "fmt"
\nfunc main() {
\n fmt.Println("Hello, volo-labs!")
\n}<\/p>\n
var name string = "volo"
\nage := 25<\/p>\n
const PI = 3.14159<\/p>\n
arr := [3]int{1, 2, 3}
\nfmt.Println(arr[0])<\/p>\n
slice := []int{1, 2}
\nslice = append(slice, 3)<\/p>\n
m := map[string]int{"a": 1}
\nm["b"] = 2<\/p>\n
func swap(a, b int) (int, int) {
\n return b, a
\n}<\/p>\n
func adder() func(int) int {
\n sum := 0
\n return func(x int) int {
\n sum += x
\n return sum
\n }
\n}<\/p>\n
go func() {
\n fmt.Println("\u5f02\u6b65\u6267\u884c")
\n}()<\/p>\n
ch := make(chan string)
\ngo func() { ch <- "\u6d88\u606f" }()
\nmsg := <-ch<\/p>\n
result, err := someFunction()
\nif err != nil {
\n log.Fatal(err)
\n}<\/p>\n
type MyError struct{ Msg string }
\nfunc (e *MyError) Error() string { return e.Msg }<\/p>\n
data, err := os.ReadFile("test.txt")<\/p>\n
err := os.WriteFile("output.txt", []byte("\u5185\u5bb9"), 0644)<\/p>\n
http.HandleFunc("\/", func(w http.ResponseWriter, r *http.Request) {
\n w.Write([]byte("\u54cd\u5e94"))
\n})
\nhttp.ListenAndServe(":8080", nil)<\/p>\n
resp, err := http.Get("https:\/\/example.com")<\/p>\n
func TestAdd(t *testing.T) {
\n result := Add(2, 3)
\n if result != 5 {
\n t.Errorf("\u9884\u671f5，\u5f97\u5230%d", result)
\n }
\n}<\/p>\n
func BenchmarkLoop(b *testing.B) {
\n for i := 0; i < b.N; i++ {
\n _ = i * i
\n }
\n}<\/p>\n
t := reflect.TypeOf(42)
\nfmt.Println(t.Kind())<\/p>\n
data := map[string]interface{}{"name": "volo"}
\njsonStr, _ := json.Marshal(data)<\/p>\n
\u4ee5\u4e0b\u662f\u901a\u8fc7 Rust \u7ed3\u5408 SQLx \u548c Diesel \u5b9e\u73b0 CRUD \u64cd\u4f5c\u7684 10 \u4e2a\u5b9e\u7528\u793a\u4f8b，\u6db5\u76d6\u57fa\u672c\u64cd\u4f5c\u548c\u5e38\u89c1\u573a\u666f\u3002\u793a\u4f8b\u5206\u4e3a\u4e24\u90e8\u5206：SQLx（\u5f02\u6b65）\u548c Diesel（\u540c\u6b65），\u4f7f\u7528 PostgreSQL \u6570\u636e\u5e93\u4f5c\u4e3a\u793a\u4f8b\u3002<\/p>\n
use sqlx::postgres::PgPoolOptions;<\/p>\n
async fn init_pool() -> sqlx::Result<sqlx::PgPool> {
\n PgPoolOptions::new()
\n .max_connections(5)
\n .connect("postgres:\/\/user:pass@localhost\/db").await
\n}<\/p>\n
CREATE TABLE users (
\n id SERIAL PRIMARY KEY,
\n name VARCHAR NOT NULL,
\n email VARCHAR UNIQUE NOT NULL
\n);<\/p>\n
async fn create_user(pool: &sqlx::PgPool, name: &str, email: &str) -> sqlx::Result<i32> {
\n let id = sqlx::query!(
\n "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id",
\n name,
\n email
\n )
\n .fetch_one(pool)
\n .await?
\n .id;
\n Ok(id)
\n}<\/p>\n
async fn get_user(pool: &sqlx::PgPool, id: i32) -> sqlx::Result<Option<(i32, String, String)>> {
\n sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
\n .fetch_optional(pool)
\n .await
\n}<\/p>\n
async fn list_users(pool: &sqlx::PgPool) -> sqlx::Result<Vec<(i32, String, String)>> {
\n sqlx::query_as!(User, "SELECT * FROM users")
\n .fetch_all(pool)
\n .await
\n}<\/p>\n
async fn update_user(pool: &sqlx::PgPool, id: i32, new_name: &str) -> sqlx::Result<u64> {
\n let rows_affected = sqlx::query!(
\n "UPDATE users SET name = $1 WHERE id = $2",
\n new_name,
\n id
\n )
\n .execute(pool)
\n .await?
\n .rows_affected();
\n Ok(rows_affected)
\n}<\/p>\n
async fn delete_user(pool: &sqlx::PgPool, id: i32) -> sqlx::Result<u64> {
\n sqlx::query!("DELETE FROM users WHERE id = $1", id)
\n .execute(pool)
\n .await
\n .map(|res| res.rows_affected())
\n}<\/p>\n
use diesel::prelude::*;
\nuse diesel::pg::PgConnection;<\/p>\n
fn establish_connection() -> PgConnection {
\n PgConnection::establish("postgres:\/\/user:pass@localhost\/db")
\n .expect("Failed to connect to database")
\n}<\/p>\n
#[derive(Queryable, Insertable)]
\n#[diesel(table_name = users)]
\nstruct User {
\n id: i32,
\n name: String,
\n email: String,
\n}<\/p>\n
fn diesel_create_user(conn: &mut PgConnection, name: &str, email: &str) -> User {
\n diesel::insert_into(users::table)
\n .values((users::name.eq(name), users::email.eq(email)))
\n .returning(User::as_returning())
\n .get_result(conn)
\n .expect("Error inserting user")
\n}<\/p>\n
fn diesel_find_user(conn: &mut PgConnection, target_id: i32) -> Option<User> {
\n users::table
\n .filter(users::id.eq(target_id))
\n .first(conn)
\n .optional()
\n .expect("Error querying user")
\n}<\/p>\n
fn diesel_paginate_users(conn: &mut PgConnection, page: i64, per_page: i64) -> Vec<User> {
\n users::table
\n .limit(per_page)
\n .offset((page – 1) * per_page)
\n .load(conn)
\n .expect("Error loading users")
\n}<\/p>\n
fn diesel_transaction(conn: &mut PgConnection) -> Result<(), diesel::result::Error> {
\n conn.transaction(|tx| {
\n diesel::update(users::table)
\n .set(users::name.eq("New Name"))
\n .execute(tx)?;
\n diesel::delete(users::table.filter(users::id.eq(1)))
\n .execute(tx)?;
\n Ok(())
\n })
\n}<\/p>\n
#[derive(Queryable)]
\nstruct PostWithAuthor {
\n post_title: String,
\n user_name: String,
\n}<\/p>\n
fn diesel_join_query(conn: &mut PgConnection) -> Vec<PostWithAuthor> {
\n posts::table
\n .inner_join(users::table)
\n .select((posts::title, users::name))
\n .load(conn)
\n .expect("Error loading joined data")
\n}<\/p>\n
\u4e24\u79cd\u65b9\u5f0f\u5747\u9700\u5728 Cargo.toml \u4e2d\u6dfb\u52a0\u5bf9\u5e94\u4f9d\u8d56\u3002\u5b9e\u9645\u9879\u76ee\u4e2d\u53ef\u6839\u636e\u56e2\u961f\u504f\u597d\u548c\u6027\u80fd\u9700\u6c42\u9009\u62e9\u65b9\u6848\u3002<\/p>\n<\/p>\n
KubeWharf\u662f\u4e00\u4e2a\u5f00\u6e90\u7684Kubernetes\u591a\u79df\u6237\u7ba1\u7406\u7cfb\u7edf，\u7531\u5b57\u8282\u8df3\u52a8\u5f00\u53d1\u3002\u8981\u83b7\u53d6100\u4e2a\u5177\u4f53\u7684\u5b9e\u4f8b\u6216\u4f7f\u7528\u6848\u4f8b，\u53ef\u4ee5\u53c2\u8003\u5b98\u65b9\u6587\u6863\u3001GitHub\u4ed3\u5e93\u4ee5\u53ca\u793e\u533a\u8d21\u732e\u7684\u793a\u4f8b\u3002<\/p>\n
KubeWharf\u7684GitHub\u4ed3\u5e93\u548c\u5b98\u65b9\u6587\u6863\u662f\u6700\u6743\u5a01\u7684\u8d44\u6e90，\u63d0\u4f9b\u4e86\u8be6\u7ec6\u7684\u5b89\u88c5\u3001\u914d\u7f6e\u548c\u4f7f\u7528\u793a\u4f8b\u3002\u8bbf\u95eeGitHub\u4ed3\u5e93\u53ef\u4ee5\u627e\u5230\u5404\u79cd\u90e8\u7f72\u6a21\u677f\u548c\u914d\u7f6e\u793a\u4f8b\u3002<\/p>\n
https:\/\/github.com\/kubewharf<\/p>\n
Kubernetes\u548cKubeWharf\u7684\u793e\u533a\u8bba\u575b\u3001Slack\u9891\u9053\u6216Discord\u7fa4\u7ec4\u4e2d，\u7528\u6237\u7ecf\u5e38\u5206\u4eab\u5b9e\u9645\u4f7f\u7528\u6848\u4f8b\u3002\u53c2\u4e0e\u8fd9\u4e9b\u793e\u533a\u53ef\u4ee5\u83b7\u53d6\u5927\u91cf\u5b9e\u6218\u7ecf\u9a8c\u3002<\/p>\n
https:\/\/kubernetes.io\/community\/<\/p>\n
\u8bb8\u591a\u6280\u672f\u535a\u5ba2\u548c\u7f51\u7ad9\u4f1a\u53d1\u5e03\u5173\u4e8eKubeWharf\u7684\u6559\u7a0b\u548c\u6848\u4f8b\u7814\u7a76\u3002\u641c\u7d22\u5173\u952e\u8bcd\u201cKubeWharf examples\u201d\u6216\u201cKubeWharf use cases\u201d\u53ef\u4ee5\u627e\u5230\u76f8\u5173\u6587\u7ae0\u3002<\/p>\n
YouTube\u6216\u5176\u4ed6\u6280\u672f\u89c6\u9891\u5e73\u53f0\u4e0a\u6709\u8bb8\u591a\u5173\u4e8eKubeWharf\u7684\u6559\u7a0b，\u6db5\u76d6\u4ece\u57fa\u7840\u5230\u9ad8\u7ea7\u7684\u591a\u79cd\u7528\u4f8b\u3002\u89c2\u770b\u8fd9\u4e9b\u89c6\u9891\u53ef\u4ee5\u76f4\u89c2\u5730\u5b66\u4e60\u5b9e\u9645\u5e94\u7528\u3002<\/p>\n
https:\/\/www.youtube.com\/results?search_query=KubeWharf<\/p>\n
\u53c2\u4e0eKubeWharf\u7684\u5f00\u6e90\u9879\u76ee，\u67e5\u770b\u5176\u4ed6\u8d21\u732e\u8005\u63d0\u4ea4\u7684\u4ee3\u7801\u548c\u793a\u4f8b\u3002\u901a\u8fc7Pull Request\u548cIssue\u8ba8\u8bba，\u53ef\u4ee5\u5b66\u4e60\u5230\u66f4\u591a\u5b9e\u9645\u5e94\u7528\u573a\u666f\u3002<\/p>\n
https:\/\/github.com\/kubewharf\/kubeadmiral<\/p>\n
\u4e00\u4e9b\u4f01\u4e1a\u4f1a\u516c\u5f00\u5206\u4eab\u4ed6\u4eec\u4f7f\u7528KubeWharf\u7684\u7ecf\u9a8c\u548c\u6848\u4f8b\u3002\u67e5\u627e\u8fd9\u4e9b\u6848\u4f8b\u7814\u7a76\u53ef\u4ee5\u83b7\u5f97\u5927\u89c4\u6a21\u90e8\u7f72\u7684\u5b9e\u6218\u7ecf\u9a8c\u3002<\/p>\n
\u4ee5\u4e0b\u662f\u9002\u7528\u4e8eRust Web\u5f00\u53d1\u7684\u811a\u624b\u67b6\u5b9e\u4f8b，\u6db5\u76d6\u4e0d\u540c\u6846\u67b6\u548c\u573a\u666f\u7684\u5b9e\u7528\u6848\u4f8b\u3002\u6bcf\u4e2a\u4f8b\u5b50\u5747\u9644\u5173\u952e\u4ee3\u7801\u7247\u6bb5\u6216\u914d\u7f6e\u8bf4\u660e，\u53ef\u76f4\u63a5\u4f5c\u4e3a\u9879\u76ee\u6a21\u677f\u4f7f\u7528\u3002<\/p>\n
use axum::{Router, routing::get};
\nasync fn handler() -> &'static str { "Hello Axum!" }
\n#[tokio::main]
\nasync fn main() {
\n let app = Router::new().route("\/", get(handler));
\n axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
\n .serve(app.into_make_service())
\n .await.unwrap();
\n}<\/p>\n
#[macro_use] extern crate rocket;
\nuse rocket::fs::FileServer;
\n#[launch]
\nfn rocket() -> _ {
\n rocket::build().mount("\/static", FileServer::from("static\/"))
\n}<\/p>\n
use actix_web::{web, App, HttpResponse, HttpServer};
\nasync fn index() -> HttpResponse {
\n HttpResponse::Ok().body("API ready")
\n}
\n#[actix_web::main]
\nasync fn main() -> std::io::Result<()> {
\n HttpServer::new(|| App::new().route("\/", web::get().to(index)))
\n .bind("127.0.0.1:8080")?
\n .run()
\n .await
\n}<\/p>\n
use warp::Filter;
\nasync fn ws_handler(ws: warp::ws::Ws) {
\n \/\/ WebSocket\u8fde\u63a5\u5904\u7406\u903b\u8f91
\n}
\n#[tokio::main]
\nasync fn main() {
\n let ws_route = warp::path("chat").and(warp::ws()).map(ws_handler);
\n warp::serve(ws_route).run(([127, 0, 0, 1], 3030)).await;
\n}<\/p>\n
use poem::{get, middleware::JwtAuth, Route};
\nasync fn protected() -> &'static str { "Secret content" }
\n#[tokio::main]
\nasync fn main() {
\n let app = Route::new()
\n .at("\/", get(protected))
\n .with(JwtAuth::new("secret_key"));
\n poem::Server::bind("0.0.0.0:3000").run(app).await.unwrap();
\n}<\/p>\n
use sqlx::postgres::PgPoolOptions;
\n#[actix_web::main]
\nasync fn main() -> Result<(), sqlx::Error> {
\n let pool = PgPoolOptions::new()
\n .connect("postgres:\/\/user:pass@localhost\/db").await?;
\n \/\/ \u4f7f\u7528pool\u8fdb\u884c\u6570\u636e\u5e93\u64cd\u4f5c
\n Ok(())
\n}<\/p>\n
use async_graphql::{Schema, EmptyMutation, EmptySubscription};
\nstruct QueryRoot;
\n#[Object]
\nimpl QueryRoot { async fn version(&self) -> &str { "1.0" } }
\n#[tokio::main]
\nasync fn main() {
\n let schema = Schema::build(QueryRoot, EmptyMutation, EmptySubscription).finish();
\n let graphql_post = warp::path("graphql").and(async_graphql_warp::graphql(schema));
\n warp::serve(graphql_post).run(([127, 0, 0, 1], 8000)).await;
\n}<\/p>\n
use tide::Request;
\nasync fn upload(mut req: Request<()>) -> tide::Result<String> {
\n let file = req.body_file("file").await?;
\n Ok(format!("Saved: {:?}", file))
\n}
\n#[async_std::main]
\nasync fn main() -> tide::Result<()> {
\n let mut app = tide::new();
\n app.at("\/upload").post(upload);
\n app.listen("127.0.0.1:8080").await?;
\n Ok(())
\n}<\/p>\n
#[macro_use] extern crate rocket;
\nuse askama::Template;
\n#[derive(Template)]
\n#[template(path = "index.html")]
\nstruct IndexTemplate { title: String }
\n#[get("\/")]
\nfn index() -> IndexTemplate {
\n IndexTemplate { title: "Home".into() }
\n}
\n#[launch]
\nfn rocket() -> _ {
\n rocket::build().mount("\/", routes![index])
\n}<\/p>\n
use actix_web::{get, App, HttpResponse, HttpServer};
\n#[get("\/health")]
\nasync fn health() -> HttpResponse {
\n HttpResponse::Ok().json("OK")
\n}
\n#[actix_web::main]
\nasync fn main() -> std::io::Result<()> {
\n HttpServer::new(|| App::new().service(health))
\n .bind("127.0.0.1:8080")?
\n .run()
\n .await
\n}<\/p>\n
use config::Config;
\n#[derive(serde::Deserialize)]
\nstruct Settings { database_url: String }
\nfn load_config() -> Settings {
\n Config::builder()
\n .add_source(config::File::with_name("config"))
\n .build().unwrap()
\n .try_deserialize().unwrap()
\n}<\/p>\n
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
\n#[tokio::main]
\nasync fn main() {
\n tracing_subscriber::registry()
\n .with(tracing_subscriber::fmt::layer())
\n .init();
\n \/\/ \u542f\u52a8axum\u670d\u52a1
\n}<\/p>\n
use bb8_redis::RedisConnectionManager;
\nasync fn create_pool() -> bb8::Pool<RedisConnectionManager> {
\n let manager = RedisConnectionManager::new("redis:\/\/localhost").unwrap();
\n bb8::Pool::builder().build(manager).await.unwrap()
\n}<\/p>\n
#[tokio::test]
\nasync fn test_handler() {
\n let response = handler().await;
\n assert_eq!(response, "Hello Axum!");
\n}<\/p>\n
use actix_cors::Cors;
\nApp::new().wrap(
\n Cors::default()
\n .allow_any_origin()
\n .allowed_methods(vec!["GET", "POST"])
\n)<\/p>\n
use clap::Parser;
\n#[derive(Parser)]
\nstruct Args { port: u16 }
\nlet args = Args::parse();
\nprintln!("Server will run on port {}", args.port);<\/p>\n
#[derive(thiserror::Error, Debug)]
\nenum ApiError { #[error("Not Found")] NotFound }
\nimpl IntoResponse for ApiError {
\n fn into_response(self) -> axum::response::Response {
\n match self {
\n Self::NotFound => (StatusCode::NOT_FOUND, self.to_string()).into_response(),
\n }
\n }
\n}<\/p>\n
use actix_governor::{Governor, GovernorConfigBuilder};
\nlet governor_conf = GovernorConfigBuilder::default().per_second(2).burst_size(5).finish();
\nApp::new().wrap(Governor::new(&governor_conf))<\/p>\n
use metrics_exporter_prometheus::PrometheusBuilder;
\nPrometheusBuilder::new().install().unwrap();
\nmetrics::counter!("requests", 1);<\/p>\n
FROM rust:1.70 as builder
\nWORKDIR \/app
\nCOPY . .
\nRUN cargo build –release<\/p>\n
FROM debian:bullseye-slim
\nCOPY –from=builder \/app\/target\/release\/app \/usr\/local\/bin
\nCMD ["\/usr\/local\/bin\/app"]<\/p>\n
\u521b\u5efa\u65e0\u9501\u961f\u5217，\u591a\u4e2a\u7ebf\u7a0b\u901a\u8fc7crossbeam::channel\u53d1\u9001\u548c\u63a5\u6536\u6570\u636e\u3002\u53d1\u9001\u65b9\u4f7f\u7528send\u65b9\u6cd5，\u63a5\u6536\u65b9\u4f7f\u7528recv\u6216try_recv\u65b9\u6cd5\u3002<\/p>\n
use crossbeam::channel;
\nlet (sender, receiver) = channel::unbounded();
\nstd::thread::spawn(move || sender.send(42).unwrap());
\nassert_eq!(receiver.recv().unwrap(), 42);<\/p>\n
\u901a\u8fc7crossbeam::channel\u652f\u6301\u591a\u4e2a\u751f\u4ea7\u8005\u7ebf\u7a0b\u5411\u5355\u4e2a\u6d88\u8d39\u8005\u7ebf\u7a0b\u53d1\u9001\u6570\u636e\u3002<\/p>\n
let (sender, receiver) = channel::unbounded();
\nfor i in 0..3 {
\n let s = sender.clone();
\n std::thread::spawn(move || s.send(i).unwrap());
\n}
\nfor _ in 0..3 {
\n println!("{}", receiver.recv().unwrap());
\n}<\/p>\n
\u521b\u5efa\u5bb9\u91cf\u9650\u5236\u7684\u961f\u5217，\u907f\u514d\u5185\u5b58\u65e0\u9650\u589e\u957f\u3002\u53d1\u9001\u64cd\u4f5c\u5728\u961f\u5217\u6ee1\u65f6\u4f1a\u963b\u585e\u3002<\/p>\n
let (sender, receiver) = channel::bounded(2);
\nsender.send(1).unwrap();
\nsender.send(2).unwrap();
\nstd::thread::spawn(move || sender.send(3).unwrap());<\/p>\n
\u4f7f\u7528crossbeam::epoch\u5b9e\u73b0\u65e0\u9501\u6570\u636e\u7ed3\u6784，\u5982\u6808\u3002\u901a\u8fc7\u539f\u5b50\u6307\u9488\u548c\u5783\u573e\u56de\u6536\u673a\u5236\u786e\u4fdd\u5b89\u5168\u3002<\/p>\n
use crossbeam::epoch::{self, Atomic, Owned};
\nlet stack = Atomic::new(Stack::new());
\nepoch::pin(|scope| {
\n stack.push(10, scope);
\n assert_eq!(stack.pop(scope), Some(10));
\n});<\/p>\n
\u5229\u7528crossbeam::atomic::AtomicCell\u5b9e\u73b0\u7b80\u5355\u539f\u5b50\u64cd\u4f5c，\u66ff\u4ee3\u6807\u51c6\u5e93\u7684AtomicUsize\u3002<\/p>\n
use crossbeam::atomic::AtomicCell;
\nlet counter = AtomicCell::new(0);
\ncounter.fetch_add(1);
\nassert_eq!(counter.load(), 1);<\/p>\n
crossbeam::scope\u521b\u5efa\u7ebf\u7a0b\u4f5c\u7528\u57df，\u786e\u4fdd\u6240\u6709\u7ebf\u7a0b\u5728\u4f5c\u7528\u57df\u7ed3\u675f\u524d\u5b8c\u6210\u3002<\/p>\n
let array = [1, 2, 3];
\ncrossbeam::scope(|s| {
\n for i in &array {
\n s.spawn(move |_| println!("{}", i));
\n }
\n}).unwrap();<\/p>\n
\u7ed3\u5408crossbeam::deque\u5b9e\u73b0\u5de5\u4f5c\u7a83\u53d6\u7ebf\u7a0b\u6c60\u3002\u4efb\u52a1\u4ece\u5168\u5c40\u961f\u5217\u6216\u5176\u4ed6\u7ebf\u7a0b\u961f\u5217\u7a83\u53d6\u3002<\/p>\n
use crossbeam::deque;
\nlet (worker, stealer) = deque::fifo();
\nworker.push("task");
\nstd::thread::spawn(move || stealer.steal().unwrap());<\/p>\n
\u901a\u8fc7crossbeam::epoch\u6784\u5efa\u5e76\u53d1\u54c8\u5e0c\u8868，\u652f\u6301\u9ad8\u5e76\u53d1\u7684\u63d2\u5165\u548c\u67e5\u8be2\u3002<\/p>\n
use crossbeam::epoch::{Guard, Atomic};
\nlet map = Atomic::new(HashMap::new());
\nepoch::pin(|scope| {
\n map.insert("key", "value", scope);
\n assert_eq!(map.get("key", scope), Some("value"));
\n});<\/p>\n
\u4f7f\u7528crossbeam::sync::ShardedLock\u5b9e\u73b0\u9ad8\u6548\u7684\u8bfb\u5199\u5206\u79bb\u8ba1\u6570\u5668\u3002<\/p>\n
use crossbeam::sync::ShardedLock;
\nlet counter = ShardedLock::new(0);
\n*counter.write().unwrap() += 1;
\nassert_eq!(*counter.read().unwrap(), 1);<\/p>\n
crossbeam::atomic::SharedArc\u5141\u8bb8\u8de8\u7ebf\u7a0b\u5171\u4eab\u6570\u636e，\u65e0\u9700\u751f\u547d\u5468\u671f\u6807\u6ce8\u3002<\/p>\n
use crossbeam::atomic::SharedArc;
\nlet shared = SharedArc::new(42);
\nlet cloned = shared.clone();
\nstd::thread::spawn(move || assert_eq!(*cloned, 42)).join().unwrap();<\/p>\n
\u6784\u5efa\u7ebf\u7a0b\u5b89\u5168\u7684\u94fe\u8868，\u652f\u6301\u5e76\u53d1\u63d2\u5165\u548c\u5220\u9664\u3002\u4f9d\u8d56crossbeam::epoch\u7ba1\u7406\u5185\u5b58\u56de\u6536\u3002<\/p>\n
use crossbeam::epoch::{self, Atomic};
\nlet list = Atomic::new(LinkedList::new());
\nepoch::pin(|scope| {
\n list.push_front(1, scope);
\n assert_eq!(list.pop_front(scope), Some(1));
\n});<\/p>\n
crossbeam::channel\u652f\u6301\u8d85\u65f6\u63a5\u6536\u64cd\u4f5c，\u907f\u514d\u65e0\u9650\u7b49\u5f85\u3002<\/p>\n
use std::time::Duration;
\nlet (sender, receiver) = channel::bounded(1);
\nassert!(receiver.recv_timeout(Duration::from_millis(100)).is_err());
\nsender.send(1).unwrap();
\nassert_eq!(receiver.recv_timeout(Duration::from_millis(100)).unwrap(), 1);<\/p>\n
\u5229\u7528crossbeam::sync::ShardedLock\u6784\u5efa\u8bfb\u5199\u5206\u79bb\u7684\u7f13\u5b58\u7ed3\u6784\u3002<\/p>\n
use crossbeam::sync::ShardedLock;
\nuse std::collections::HashMap;
\nlet cache = ShardedLock::new(HashMap::new());
\ncache.write().unwrap().insert("key", "value");
\nassert_eq!(cache.read().unwrap().get("key"), Some(&"value"));<\/p>\n
\u4f7f\u7528crossbeam::deque\u5b9e\u73b0\u4efb\u52a1\u8c03\u5ea6，\u652f\u6301\u5de5\u4f5c\u7a83\u53d6\u4ee5\u63d0\u9ad8\u5e76\u884c\u6548\u7387\u3002<\/p>\n
use crossbeam::deque;
\nlet (worker, stealer) = deque::lifo();
\nworker.push("task1");
\nworker.push("task2");
\nstd::thread::spawn(move || stealer.steal_batch(&worker));<\/p>\n
\u901a\u8fc7crossbeam::channel\u5b9e\u73b0\u591a\u8ba2\u9605\u8005\u7684\u4e8b\u4ef6\u53d1\u5e03-\u8ba2\u9605\u6a21\u578b\u3002<\/p>\n
let (sender, receiver) = channel::unbounded();
\nlet subscriber = receiver.clone();
\nstd::thread::spawn(move || subscriber.recv().unwrap());
\nsender.send("event").unwrap();<\/p>\n
crossbeam::sync::SegQueue\u6784\u5efa\u53ef\u590d\u7528\u7684\u5bf9\u8c61\u6c60，\u51cf\u5c11\u5185\u5b58\u5206\u914d\u5f00\u9500\u3002<\/p>\n
use crossbeam::sync::SegQueue;
\nlet pool = SegQueue::new();
\npool.push("object");
\nassert_eq!(pool.pop(), Some("object"));<\/p>\n
crossbeam::thread::scope\u5206\u5272\u6570\u7ec4\u7ed9\u591a\u4e2a\u7ebf\u7a0b\u5e76\u884c\u5904\u7406\u3002<\/p>\n
let mut array = [1, 2, 3, 4];
\ncrossbeam::thread::scope(|s| {
\n for elem in &mut array {
\n s.spawn(move |_| *elem += 1);
\n }
\n}).unwrap();
\nassert_eq!(array, [2, 3, 4, 5]);<\/p>\n
crossbeam::queue::ArrayQueue\u63d0\u4f9b\u56fa\u5b9a\u5927\u5c0f\u7684\u975e\u963b\u585e\u961f\u5217，\u9002\u5408\u9ad8\u5e76\u53d1\u573a\u666f\u3002<\/p>\n
use crossbeam::queue::ArrayQueue;
\nlet queue = ArrayQueue::new(2);
\nqueue.push(1).unwrap();
\nassert_eq!(queue.pop(), Ok(1));<\/p>\n
\u901a\u8fc7crossbeam::channel\u53d1\u9001Result\u7c7b\u578b，\u4f20\u9012\u5b50\u7ebf\u7a0b\u9519\u8bef\u5230\u4e3b\u7ebf\u7a0b\u3002<\/p>\n
let (sender, receiver) = channel::unbounded();
\nstd::thread::spawn(move || sender.send(Err("error")).unwrap());
\nassert!(receiver.recv().unwrap().is_err());<\/p>\n
crossbeam::thread::Scope\u52a8\u6001\u751f\u6210\u7ebf\u7a0b，\u6839\u636e\u8d1f\u8f7d\u8c03\u6574\u5e76\u884c\u5ea6\u3002<\/p>\n
let data = vec![1, 2, 3];
\ncrossbeam::thread::scope(|s| {
\n for item in data {
\n s.spawn(move |_| println!("{}", item));
\n }
\n}).unwrap();<\/p>\n
\u4f7f\u7528Rust\u6784\u5efa\u9ad8\u6027\u80fdHTTP\u670d\u52a1\u5668，\u5982\u901a\u8fc7actix-web\u6216warp\u6846\u67b6\u5b9e\u73b0RESTful API\u3002<\/p>\n
use actix_web::{get, App, HttpServer, Responder};<\/p>\n
#[get("\/")]
\nasync fn index() -> impl Responder {
\n "Hello, Rust Server!"
\n}<\/p>\n
#[actix_web::main]
\nasync fn main() -> std::io::Result<()> {
\n HttpServer::new(|| App::new().service(index))
\n .bind("127.0.0.1:8080")?
\n .run()
\n .await
\n}<\/p>\n
\u5229\u7528Rust\u7684\u5e76\u53d1\u7279\u6027\u5f00\u53d1\u591a\u4eba\u6e38\u620f\u670d\u52a1\u5668，\u5982\u4f7f\u7528tokio\u5904\u7406\u5b9e\u65f6\u73a9\u5bb6\u4ea4\u4e92\u3002<\/p>\n
use tokio::net::{TcpListener, TcpStream};
\nuse tokio::io::{AsyncReadExt, AsyncWriteExt};<\/p>\n
async fn handle_client(mut stream: TcpStream) {
\n let mut buf = [0; 1024];
\n stream.read(&mut buf).await.unwrap();
\n stream.write_all(b"Welcome to Rust Game Server!").await.unwrap();
\n}<\/p>\n
\u6784\u5efa\u8f7b\u91cf\u7ea7\u5fae\u670d\u52a1，\u5982\u8ba2\u5355\u5904\u7406\u6216\u7528\u6237\u8ba4\u8bc1\u670d\u52a1，\u914d\u5408tonic\u5b9e\u73b0gRPC\u901a\u4fe1\u3002<\/p>\n
use tonic::{transport::Server, Request, Response, Status};<\/p>\n
pub mod order_service {
\n tonic::include_proto!("orders");
\n}<\/p>\n
#[derive(Default)]
\npub struct OrderService;<\/p>\n
#[tonic::async_trait]
\nimpl order_server::Order for OrderService {
\n async fn create_order(
\n &self,
\n request: Request<CreateOrderRequest>,
\n ) -> Result<Response<OrderResponse>, Status> {
\n Ok(Response::new(OrderResponse { id: 1 }))
\n }
\n}<\/p>\n
\u5f00\u53d1\u9ad8\u6027\u80fd\u6570\u636e\u5e93\u4e2d\u95f4\u4ef6，\u5982MySQL\u4ee3\u7406，\u4f7f\u7528mysql_async\u5e93\u4f18\u5316\u67e5\u8be2\u8def\u7531\u3002<\/p>\n
use mysql_async::prelude::*;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let pool = mysql_async::Pool::new("mysql:\/\/user:pass@localhost:3306\/db");
\n let mut conn = pool.get_conn().await.unwrap();
\n conn.query_iter("SELECT * FROM users").await.unwrap();
\n}<\/p>\n
\u901a\u8fc7tokio-tungstenite\u5b9e\u73b0WebSocket\u804a\u5929\u670d\u52a1\u5668，\u652f\u6301\u4f4e\u5ef6\u8fdf\u6d88\u606f\u5e7f\u64ad\u3002<\/p>\n
use tokio_tungstenite::accept_async;
\nuse tokio::net::TcpListener;<\/p>\n
async fn handle_connection(stream: TcpStream) {
\n let ws_stream = accept_async(stream).await.unwrap();
\n \/\/ \u5e7f\u64ad\u903b\u8f91
\n}<\/p>\n
\u5904\u7406\u7269\u8054\u7f51\u8bbe\u5907\u6570\u636e，\u4f7f\u7528rumqttd\u642d\u5efaMQTT\u6d88\u606f\u4ee3\u7406\u3002<\/p>\n
use rumqttd::{Broker, Config};<\/p>\n
fn main() {
\n let config = Config::default();
\n let mut broker = Broker::new(config);
\n broker.start().unwrap();
\n}<\/p>\n
\u6784\u5efaP2P\u6587\u4ef6\u540c\u6b65\u670d\u52a1\u5668，\u5982\u4f7f\u7528libp2p\u5b9e\u73b0\u8282\u70b9\u95f4\u6570\u636e\u4f20\u8f93\u3002<\/p>\n
use libp2p::{identity, PeerId, Swarm};
\nuse libp2p::swarm::SwarmEvent;<\/p>\n
let local_key = identity::Keypair::generate_ed25519();
\nlet local_peer_id = PeerId::from(local_key.public());
\nlet transport = libp2p::development_transport(local_key).await.unwrap();<\/p>\n
\u5f00\u53d1\u533a\u5757\u94fe\u7f51\u7edc\u8282\u70b9，\u5982\u57fa\u4e8esubstrate\u6846\u67b6\u6784\u5efa\u81ea\u5b9a\u4e49\u94fe\u3002<\/p>\n
use sc_service::GenericChainSpec;
\nuse node_template_runtime::GenesisConfig;<\/p>\n
fn chain_spec() -> Result<GenericChainSpec<GenesisConfig>, String> {
\n GenericChainSpec::from_json_bytes(&include_bytes!("..\/chain_spec.json")[..])
\n}<\/p>\n
\u5b9e\u73b0\u53cd\u5411\u4ee3\u7406\u670d\u52a1\u5668，\u5982\u901a\u8fc7hyper\u5e93\u5206\u53d1HTTP\u8bf7\u6c42\u3002<\/p>\n
use hyper::{Body, Request, Response, Server};
\nuse hyper::service::{make_service_fn, service_fn};<\/p>\n
async fn handle(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
\n Ok(Response::new(Body::from("Proxied Response")))
\n}<\/p>\n
\u6784\u5efa\u96c6\u4e2d\u5f0f\u65e5\u5fd7\u670d\u52a1\u5668，\u5982\u4f7f\u7528flume\u63a5\u6536\u5e76\u5904\u7406\u65e5\u5fd7\u6d41\u3002<\/p>\n
use flume::{Receiver, Sender};
\nlet (tx, rx): (Sender<String>, Receiver<String>) = flume::unbounded();
\nstd::thread::spawn(move || {
\n while let Ok(log) = rx.recv() {
\n println!("[LOG] {}", log);
\n }
\n});<\/p>\n
\u5f00\u53d1SMTP\u670d\u52a1\u7aef，\u5982\u901a\u8fc7lettre\u5e93\u5904\u7406\u90ae\u4ef6\u6536\u53d1\u3002<\/p>\n
use lettre::transport::smtp::SmtpTransport;
\nuse lettre::{Message, Transport};<\/p>\n
let email = Message::builder()
\n .from("sender@example.com".parse().unwrap())
\n .to("receiver@example.com".parse().unwrap())
\n .subject("Rust SMTP Test")
\n .body("Hello from Rust!".to_string())
\n .unwrap();<\/p>\n
let mailer = SmtpTransport::unencrypted_localhost();
\nmailer.send(&email).unwrap();<\/p>\n
\u901a\u8fc7tokio-rtmp\u5b9e\u73b0\u5b9e\u65f6\u89c6\u9891\u6d41\u5206\u53d1\u670d\u52a1\u5668\u3002<\/p>\n
use tokio_rtmp::server::Server;<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let server = Server::bind("0.0.0.0:1935").await.unwrap();
\n server.run().await.unwrap();
\n}<\/p>\n
\u6784\u5efa\u81ea\u5b9a\u4e49DNS\u89e3\u6790\u670d\u52a1，\u5982\u4f7f\u7528trust-dns-server\u5e93\u3002<\/p>\n
use trust_dns_server::authority::Catalog;
\nuse trust_dns_server::server::ServerFuture;<\/p>\n
let catalog = Catalog::new();
\nlet mut server = ServerFuture::new(catalog);
\nserver.register_listener(listener, Duration::from_secs(2)).await.unwrap();<\/p>\n
\u5f00\u53d1Memcached\u517c\u5bb9\u670d\u52a1\u5668，\u5982\u4f7f\u7528mio\u5904\u7406\u9ad8\u901f\u952e\u503c\u5b58\u50a8\u3002<\/p>\n
use mio::net::TcpListener;
\nuse std::collections::HashMap;<\/p>\n
let mut cache = HashMap::new();
\nlet listener = TcpListener::bind("127.0.0.1:11211".parse().unwrap()).unwrap();<\/p>\n
\u5b9e\u73b0Prometheus\u6307\u6807\u6536\u96c6\u670d\u52a1，\u4f7f\u7528prometheus\u5e93\u66b4\u9732metrics\u3002<\/p>\n
use prometheus::{Encoder, TextEncoder};<\/p>\n
let metric_family = prometheus::gather();
\nlet mut buffer = vec![];
\nlet encoder = TextEncoder::new();
\nencoder.encode(&metric_family, &mut buffer).unwrap();<\/p>\n
\u6784\u5efaAMQP\/RabbitMQ\u66ff\u4ee3\u670d\u52a1，\u5982\u57fa\u4e8elapin\u5b9e\u73b0\u6d88\u606f\u961f\u5217\u6838\u5fc3\u3002<\/p>\n
use lapin::{Connection, ConnectionProperties};<\/p>\n
#[tokio::main]
\nasync fn main() {
\n let conn = Connection::connect(
\n "amqp:\/\/guest:guest@localhost:5672",
\n ConnectionProperties::default(),
\n ).await.unwrap();
\n}<\/p>\n
\u5f00\u53d1\u7edf\u4e00\u5165\u53e3\u7f51\u5173，\u5982\u901a\u8fc7axum\u5b9e\u73b0\u8def\u7531\u548c\u9274\u6743\u6574\u5408\u3002<\/p>\n
use axum::{Router, routing::get};<\/p>\n
async fn handler() -> &'static str { "Gateway Response" }<\/p>\n
let app = Router::new().route("\/", get(handler));
\naxum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
\n .serve(app.into_make_service())
\n .await
\n .unwrap();<\/p>\n
\u5b9e\u73b0OAuth2.0\u670d\u52a1\u5668，\u5982\u4f7f\u7528oxide-auth\u5e93\u5904\u7406\u4ee4\u724c\u9881\u53d1\u3002<\/p>\n
use oxide_auth::endpoint::Endpoint;
\nuse oxide_auth::frontends::simple::endpoint::Generic;<\/p>\n
let mut endpoint = Generic::new(());
\nlet response = endpoint.authorization(&mut request).unwrap();<\/p>\n
\u5f00\u53d1\u5206\u5e03\u5f0f\u914d\u7f6e\u7ba1\u7406\u670d\u52a1\u5668，\u5982\u901a\u8fc7serde\u548cconfig\u5e93\u52a8\u6001\u52a0\u8f7d\u914d\u7f6e\u3002<\/p>\n
use config::{Config, File};
\nlet mut settings = Config::default();
\nsettings.merge(File::with_name("config")).unwrap();<\/p>\n
\u6784\u5efaTSDB\u67e5\u8be2\u5f15\u64ce，\u5982\u4f7f\u7528arrow\u548cparquet\u5904\u7406\u65f6\u5e8f\u6570\u636e\u3002<\/p>\n
use arrow::array::{Float64Array, TimestampNanosecondArray};
\nuse arrow::record_batch::RecordBatch;<\/p>\n
let timestamps = TimestampNanosecondArray::from(vec![1, 2, 3]);
\nlet values = Float64Array::from(vec![10.5, 11.3, 9.8]);
\nRecordBatch::try_new(
\n schema,
\n vec![Arc::new(timestamps), Arc::new(values)],
\n).unwrap();<\/p>\n
#[post("\/login")]
\nasync fn login(user: web::Json<UserLogin>) -> impl Responder {
\n let token = generate_jwt(&user.username);
\n HttpResponse::Ok().json(LoginResponse { token })
\n}<\/p>\n
#[post("\/register")]
\nasync fn register(user: web::Json<UserRegister>) -> impl Responder {
\n let hashed = bcrypt::hash(user.password, 10)?;
\n let new_user = User {
\n username: user.username,
\n password: hashed
\n };
\n HttpResponse::Created().json(new_user)
\n}<\/p>\n
#[put("\/users\/{id}")]
\nasync fn update_user(
\n id: web::Path<i32>,
\n user: web::Json<UserUpdate>,
\n req: HttpRequest
\n) -> impl Responder {
\n validate_admin(req)?;
\n HttpResponse::Ok().json(format!("Updated user {}", id))
\n}<\/p>\n
#[get("\/data")]
\nasync fn list_data(query: web::Query<Pagination>) -> impl Responder {
\n let items = fetch_data(query.page, query.size).await?;
\n HttpResponse::Ok().json(items)
\n}<\/p>\n
#[get("\/data\/filter")]
\nasync fn filter_data(params: web::Query<FilterParams>) -> impl Responder {
\n let results = apply_filters(params).await?;
\n HttpResponse::Ok().json(results)
\n}<\/p>\n
#[get("\/stats")]
\nasync fn data_stats() -> impl Responder {
\n let stats = calculate_stats().await?;
\n HttpResponse::Ok().json(stats)
\n}<\/p>\n
#[post("\/upload")]
\nasync fn upload_file(mut payload: web::Payload) -> impl Responder {
\n let filepath = save_uploaded_file(&mut payload).await?;
\n HttpResponse::Ok().json(filepath)
\n}<\/p>\n
#[get("\/download\/{filename}")]
\nasync fn download_file(filename: web::Path<String>) -> impl Responder {
\n let file = File::open(format!(".\/files\/{}", filename))?;
\n HttpResponse::Ok().streaming(file)
\n}<\/p>\n
#[get("\/health")]
\nasync fn health_check() -> impl Responder {
\n HttpResponse::Ok().json("OK")
\n}<\/p>\n
#[get("\/metrics")]
\nasync fn system_metrics() -> impl Responder {
\n let metrics = collect_metrics();
\n HttpResponse::Ok().json(metrics)
\n}<\/p>\n
\u5178\u578b Actix-web \u5e94\u7528\u7ed3\u6784：<\/p>\n
src\/
\n\u251c\u2500\u2500 main.rs # \u670d\u52a1\u5668\u542f\u52a8
\n\u251c\u2500\u2500 routes\/ # \u8def\u7531\u6a21\u5757
\n\u251c\u2500\u2500 handlers\/ # \u4e1a\u52a1\u903b\u8f91
\n\u251c\u2500\u2500 models\/ # \u6570\u636e\u7ed3\u6784
\n\u251c\u2500\u2500 middleware\/ # \u4e2d\u95f4\u4ef6
\n\u2514\u2500\u2500 database\/ # \u6570\u636e\u5e93\u8fde\u63a5<\/p>\n
\u6570\u636e\u5e93\u8fde\u63a5\u6c60\u914d\u7f6e\u793a\u4f8b：<\/p>\n
pub fn configure_db(cfg: &mut web::ServiceConfig) {
\n let pool = PgPool::connect("postgres:\/\/user:pass@localhost\/db");
\n cfg.data(pool);
\n}<\/p>\n
JWT \u4e2d\u95f4\u4ef6\u793a\u4f8b：<\/p>\n
pub struct JwtMiddleware;<\/p>\n
impl<S> Transform<S, ServiceRequest> for JwtMiddleware {
\n type Response = ServiceResponse;
\n type Error = Error;
\n type Transform = JwtMiddlewareService<S>;
\n type InitError = ();
\n type Future = Ready<Result<Self::Transform, Self::InitError>>;<\/p>\n
fn new_transform(&self, service: S) -> Self::Future {
\n ready(Ok(JwtMiddlewareService { service }))
\n }
\n}<\/p>\n
\u4ee5\u4e0a\u793a\u4f8b\u5c55\u793a\u4e86 MIS \u7cfb\u7edf\u7684\u6838\u5fc3\u63a5\u53e3\u5b9e\u73b0\u6a21\u5f0f\u3002\u5b9e\u9645\u5f00\u53d1\u4e2d\u9700\u8981\u7ed3\u5408\u5177\u4f53\u4e1a\u52a1\u9700\u6c42\u6269\u5c55\u4ee5\u4e0b\u65b9\u9762：<\/p>\n
\u5b8c\u6574\u9879\u76ee\u5efa\u8bae\u91c7\u7528\u5206\u5c42\u67b6\u6784\u8bbe\u8ba1，\u901a\u8fc7 actix-web::Scope \u7ec4\u7ec7\u8def\u7531\u5206\u7ec4，\u4f7f\u7528 derive_more \u5e93\u7b80\u5316\u9519\u8bef\u5904\u7406，\u96c6\u6210 sqlx \u6216 diesel \u8fdb\u884c\u6570\u636e\u5e93\u64cd\u4f5c\u3002<\/p>\n
\u4ee5\u4e0b\u662f\u57fa\u4e8eRust\u7f16\u5199\u624b\u673a\u756a\u8304\u8bfb\u4e66\u5e94\u7528\u768420\u4e2a\u5b9e\u4f8b\u4ee3\u7801\u7247\u6bb5，\u6db5\u76d6\u6838\u5fc3\u529f\u80fd\u5b9e\u73b0：<\/p>\n
\/\/ \u5b9e\u4f8b1：\u5b9a\u4e49\u756a\u8304\u949f\u72b6\u6001\u679a\u4e3e
\nenum PomodoroState {
\n Focus,
\n ShortBreak,
\n LongBreak,
\n}<\/p>\n
\/\/ \u5b9e\u4f8b2：\u8bfb\u4e66\u4efb\u52a1\u7ed3\u6784\u4f53
\nstruct ReadingTask {
\n title: String,
\n pages: u32,
\n completed: bool,
\n current_page: u32,
\n}<\/p>\n
\/\/ \u5b9e\u4f8b3：\u5012\u8ba1\u65f6\u5b9e\u73b0
\nuse std::time::Duration;
\nuse std::thread;<\/p>\n
fn countdown(seconds: u64) {
\n for i in (1..=seconds).rev() {
\n println!("Remaining: {}s", i);
\n thread::sleep(Duration::from_secs(1));
\n }
\n}<\/p>\n
\/\/ \u5b9e\u4f8b4：\u8ba1\u65f6\u5668\u7ed3\u6784\u4f53
\nstruct Timer {
\n duration: Duration,
\n remaining: Duration,
\n is_running: bool,
\n}<\/p>\n
\/\/ \u5b9e\u4f8b5：\u7ec8\u7aefUI\u6e32\u67d3
\nuse tui::{
\n Terminal,
\n backend::Backend,
\n layout::{Layout, Direction, Constraint},
\n widgets::{Block, Borders, Paragraph},
\n};<\/p>\n
fn render_ui<B: Backend>(terminal: &mut Terminal<B>) {
\n terminal.draw(|f| {
\n let chunks = Layout::default()
\n .direction(Direction::Vertical)
\n .constraints([Constraint::Percentage(100)].as_ref())
\n .split(f.size());<\/p>\n
let block = Block::default()
\n .title("\u756a\u8304\u8bfb\u4e66")
\n .borders(Borders::ALL);
\n f.render_widget(block, chunks[0]);
\n }).unwrap();
\n}<\/p>\n
\/\/ \u5b9e\u4f8b6：\u79fb\u52a8\u7aef\u6309\u94ae\u7ec4\u4ef6
\nstruct MobileButton {
\n text: String,
\n position: (u32, u32),
\n size: (u32, u32),
\n callback: Box<dyn Fn()>,
\n}<\/p>\n
\/\/ \u5b9e\u4f8b7：JSON\u4efb\u52a1\u5b58\u50a8
\nuse serde::{Serialize, Deserialize};
\nuse std::fs;<\/p>\n
#[derive(Serialize, Deserialize)]
\nstruct TaskList {
\n tasks: Vec<ReadingTask>,
\n}<\/p>\n
fn save_tasks(tasks: &TaskList, path: &str) -> std::io::Result<()> {
\n let json = serde_json::to_string(tasks)?;
\n fs::write(path, json)
\n}<\/p>\n
\/\/ \u5b9e\u4f8b8：SQLite\u6570\u636e\u5e93\u64cd\u4f5c
\nuse rusqlite::{Connection, Result};<\/p>\n
fn init_db() -> Result<Connection> {
\n let conn = Connection::open("reading.db")?;
\n conn.execute(
\n "CREATE TABLE IF NOT EXISTS tasks (
\n id INTEGER PRIMARY KEY,
\n title TEXT NOT NULL,
\n pages INTEGER NOT NULL
\n )",
\n [],
\n )?;
\n Ok(conn)
\n}<\/p>\n
\/\/ \u5b9e\u4f8b9：\u7cfb\u7edf\u901a\u77e5
\n#[cfg(target_os = "android")]
\nuse jni::{JNIEnv, objects::JObject};<\/p>\n
fn send_notification(title: &str, message: &str) {
\n #[cfg(target_os = "android")]
\n {
\n let env = JNIEnv::from_thread();
\n let context = JObject::null();
\n \/\/ \u5b9e\u9645\u8c03\u7528Android\u901a\u77e5API
\n }
\n}<\/p>\n
\/\/ \u5b9e\u4f8b10：\u632f\u52a8\u53cd\u9988
\n#[cfg(target_os = "android")]
\nfn vibrate(duration_ms: i64) {
\n \/\/ \u8c03\u7528Android\u632f\u52a8API
\n}<\/p>\n
\/\/ \u5b9e\u4f8b11：\u9605\u8bfb\u8fdb\u5ea6\u8ba1\u7b97
\nimpl ReadingTask {
\n fn progress(&self) -> f32 {
\n if self.pages == 0 {
\n 0.0
\n } else {
\n self.current_page as f32 \/ self.pages as f32 * 100.0
\n }
\n }
\n}<\/p>\n
\/\/ \u5b9e\u4f8b12：\u5468\u7edf\u8ba1\u7ed3\u6784
\nstruct WeeklyStats {
\n focus_sessions: u32,
\n pages_read: u32,
\n completion_rate: f32,
\n}<\/p>\n
\/\/ \u5b9e\u4f8b13：API\u5ba2\u6237\u7aef
\nuse reqwest::Client;<\/p>\n
async fn sync_tasks(api_url: &str, tasks: &TaskList) -> Result<(), reqwest::Error> {
\n let client = Client::new();
\n client.post(api_url)
\n .json(tasks)
\n .send()
\n .await?;
\n Ok(())
\n}<\/p>\n
\/\/ \u5b9e\u4f8b14：WebSocket\u76d1\u542c
\nuse tokio_tungstenite::connect_async;<\/p>\n
async fn connect_to_server(url: &str) {
\n let (ws_stream, _) = connect_async(url).await.unwrap();
\n \/\/ \u5904\u7406\u6d88\u606f
\n}<\/p>\n
\/\/ \u5b9e\u4f8b15：\u5355\u5143\u6d4b\u8bd5
\n#[cfg(test)]
\nmod tests {
\n use super::*;<\/p>\n
#[test]
\n fn test_progress_calculation() {
\n let task = ReadingTask {
\n current_page: 50,
\n pages: 100,
\n ..Default::default()
\n };
\n assert_eq!(task.progress(), 50.0);
\n }
\n}<\/p>\n
\/\/ \u5b9e\u4f8b16：\u96c6\u6210\u6d4b\u8bd5
\n#[cfg(test)]
\nmod integration_tests {
\n #[test]
\n fn test_db_operations() {
\n let conn = init_db().unwrap();
\n \/\/ \u6d4b\u8bd5\u6570\u636e\u5e93\u64cd\u4f5c
\n }
\n}<\/p>\n
\/\/ \u5b9e\u4f8b17：\u6761\u4ef6\u7f16\u8bd1
\n#[cfg(target_os = "android")]
\nfn platform_specific() {
\n \/\/ Android\u7279\u5b9a\u4ee3\u7801
\n}<\/p>\n
#[cfg(target_os = "ios")]
\nfn platform_specific() {
\n \/\/ iOS\u7279\u5b9a\u4ee3\u7801
\n}<\/p>\n
\/\/ \u5b9e\u4f8b18：FFI\u7ed1\u5b9a
\n#[no_mangle]
\npub extern "C" fn start_timer(duration: u32) {
\n \/\/ \u4f9b\u539f\u751f\u5e73\u53f0\u8c03\u7528\u7684\u63a5\u53e3
\n}<\/p>\n
\/\/ \u5b9e\u4f8b19：\u6587\u672c\u5206\u6790
\nuse rayon::prelude::*;<\/p>\n
fn analyze_text(text: &str) -> HashMap<String, u32> {
\n text.par_split_whitespace()
\n .fold(HashMap::new, |mut acc, word| {
\n *acc.entry(word.to_lowercase()).or_default() += 1;
\n acc
\n })
\n .reduce(HashMap::new, |mut a, b| {
\n for (k, v) in b {
\n *a.entry(k).or_default() += v;
\n }
\n a
\n })
\n}<\/p>\n
\/\/ \u5b9e\u4f8b20：\u673a\u5668\u5b66\u4e60\u96c6\u6210
\nuse tract_onnx::prelude::*;<\/p>\n
fn predict_reading_time(model_path: &str, input: &[f32]) -> Result<f32> {
\n let model = tract_onnx::onnx().model_for_path(model_path)?;
\n let plan = SimplePlan::new(model)?;
\n let result = plan.run(tensor1(input))?;
\n Ok(result[0].to_scalar::<f32>()?)
\n}<\/p>\n
\u8fd9\u4e9b\u5b9e\u4f8b\u6db5\u76d6\u4e86\u4ece\u57fa\u7840\u7ed3\u6784\u5230\u9ad8\u7ea7\u529f\u80fd\u7684\u5404\u4e2a\u65b9\u9762，\u53ef\u6839\u636e\u5b9e\u9645\u9700\u6c42\u8fdb\u884c\u7ec4\u5408\u548c\u6269\u5c55\u3002\u5bf9\u4e8e\u79fb\u52a8\u7aef\u5f00\u53d1，\u5efa\u8bae\u7ed3\u5408rust-android\u6216rust-ios\u5de5\u5177\u94fe\u8fdb\u884c\u539f\u751f\u5e73\u53f0\u96c6\u6210\u3002<\/p>\n","protected":false},"excerpt":{"rendered":"
\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb832\u6b21\uff0c\u70b9\u8d5e26\u6b21\uff0c\u6536\u85cf12\u6b21\u3002\u8fd9\u7bc7\u6280\u672f\u6587\u7ae0\u6458\u8981\u6db5\u76d6\u4e86\u591a\u4e2aRust\u5f00\u53d1\u573a\u666f\u7684\u5b9e\u7528\u4ee3\u7801\u793a\u4f8b\uff0c\u4e3b\u8981\u5305\u62ec\uff1a \u5b57\u8282\u8df3\u52a8\u7ea7\u670d\u52a1\u5668\u5f00\u53d1 \u7f51\u7edc\u901a\u4fe1\uff08\u5f02\u6b65TCP\/HTTP\u670d\u52a1\u5668\uff09 \u9ad8\u5e76\u53d1\u5904\u7406\uff08\u65e0\u9501\u961f\u5217\/\u5f02\u6b65\u4efb\u52a1\u6c60\uff09 \u6570\u636e\u5b58\u50a8\uff08Redis\/\u6570\u636e\u5e93\u64cd\u4f5c\uff09 \u6027\u80fd\u4f18\u5316\uff08SIMD\/\u5185\u5b58\u6c60\uff09 \u4e91\u539f\u751f\u6846\u67b6Volo\u5b9e\u8df5 HTTP\/gRPC\u670d\u52a1\u642d\u5efa Kubernetes\u5065\u5eb7\u68c0\u67e5 \u81ea\u5b9a\u4e49\u4e2d\u95f4\u4ef6 \u5206\u5e03\u5f0f\u8ffd\u8e2a\u7b49\u4e91\u539f\u751f\u529f\u80fd Tokio\u5f02\u6b65\u8fd0\u884c\u65f6\u5e94\u7528 \u57fa\u7840\u5f02\u6b65\u4efb\u52a1 TCP\u670d\u52a1\u5668\/\u5ba2\u6237\u7aef \u5b9a\u65f6\u5668\/\u6587\u4ef6I\/O WebSocket\u901a\u4fe1\u7b49 \u5176\u4ed6\u5e94\u7528\u573a\u666f \u6570\u636e\u5e93CRUD\u64cd\u4f5c Web\u5f00\u53d1\u6846\u67b6 _rust\u9ad8\u5e76\u53d1<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[206,190,43],"topic":[],"class_list":["post-46030","post","type-post","status-publish","format-standard","hentry","category-server","tag-rust","tag-190","tag-43"],"yoast_head":"\n