选型矩阵
| C++ | Go | Rust | Python | Java |
|---|
| 吞吐 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐ |
| 开发效率 | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
| 内存管理 | 手动/RAII | GC | 所有权 | GC | GC |
| 并发模型 | 线程+锁 | goroutine | async/tokio | asyncio/多进程 | 线程池 |
| 生态 | Qt/Boost/grpc | 标准库全 | 年轻 | Django/FastAPI | Spring |
| 适合场景 | 工业上位机/游戏后端 | 微服务/API网关 | 安全/嵌入式 | 快速原型/AI | 企业系统 |
C++ — REST API with Drogon
// 适合：需要极致性能 + Qt 生态融合的场景
#include <drogon/drogon.h>
using namespace drogon;
int main() {
app().registerHandler("/api/data?userId={}",
[](const HttpRequestPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
int userId) {
Json::Value ret;
ret["userId"] = userId;
ret["status"] = "ok";
auto resp = HttpResponse::newHttpJsonResponse(ret);
callback(resp);
});
app().addListener("0.0.0.0", 8080).run();
}
// 编译: g++ -std=c++17 $(pkg-config --cflags drogon) main.cpp
Go — goroutine 并发 + 标准库
// 适合：高并发微服务、API 网关
package main
import (
"encoding/json"
"net/http"
"sync"
)
type Server struct {
mu sync.RWMutex
data map[int]string
}
func (s *Server) handleGet(w http.ResponseWriter, r *http.Request) {
s.mu.RLock()
defer s.mu.RUnlock()
json.NewEncoder(w).Encode(s.data)
}
func main() {
s := &Server{data: map[int]string{1: "active"}}
http.HandleFunc("/api/data", s.handleGet)
http.ListenAndServe(":8080", nil) // 每个请求自动 goroutine
}
// 编译: go build -o server main.go
// 千万级并发连接开销 ~3KB/goroutine
Rust — axum 异步框架
// 适合：安全关键系统、WebAssembly 后端
use axum::{Router, routing::get, extract::Path, Json};
use serde::Serialize;
use std::collections::HashMap;
use tokio::sync::RwLock;
use std::sync::Arc;
type Db = Arc<RwLock<HashMap<i32, String>>>;
#[derive(Serialize)]
struct Response { user_id: i32, status: String }
async fn get_user(Path(id): Path<i32>, db: axum::extract::State<Db>) -> Json<Response> {
let data = db.read().await;
Json(Response {
user_id: id,
status: data.get(&id).cloned().unwrap_or_default(),
})
}
#[tokio::main]
async fn main() {
let db: Db = Arc::new(RwLock::new(HashMap::from([(1, "active".into())])));
let app = Router::new()
.route("/api/data/{id}", get(get_user))
.with_state(db);
axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())
.serve(app.into_make_service()).await.unwrap();
}
Python — FastAPI
# 适合：快速原型 + AI/ML 集成
from fastapi import FastAPI
from pydantic import BaseModel
import asyncio
app = FastAPI()
class DataOut(BaseModel):
user_id: int
status: str
@app.get("/api/data/{user_id}", response_model=DataOut)
async def get_data(user_id: int):
await asyncio.sleep(0.01) # 模拟 DB 查询
return DataOut(user_id=user_id, status="active")
# 启动: uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
# 多 worker + async 组合异步 IO
Java — Spring Boot
// 适合：企业级、事务密集型
@RestController
@RequestMapping("/api")
public class DataController {
record DataOut(int userId, String status) {}
@GetMapping("/data/{userId}")
public DataOut getData(@PathVariable int userId) {
return new DataOut(userId, "active");
}
}
// 启动: mvn spring-boot:run
// 嵌入式 Tomcat, 连接池自动管理
并发模型对比
# Python asyncio — 单线程协作式
async def handle(request):
data = await db.query("...") # await 处让出 CPU
return data
# Go goroutine — 抢占式 + channel
func handle(w http.ResponseWriter, r *http.Request) {
ch := make(chan Result)
go func() { ch <- db.Query("...") }() // 自动调度
result := <-ch
}
# Rust tokio — 零成本异步
async fn handle(Path(id): Path<i32>, db: State<Db>) -> Json<...> {
let data = db.read().await; // .await 编译为状态机
Json(data)
}
选型决策树
需要和 Qt/C++ 生态无缝集成？
├─ 是 → C++ (Drogon / Qt HttpServer)
└─ 否 → 需要极致安全性（内存+类型）？
├─ 是 → Rust
└─ 否 → 高并发微服务 + 运维简单？
├─ 是 → Go
└─ 否 → 快速迭代 / AI 集成？
├─ 是 → Python (FastAPI)
└─ 否 → 企业级 + 事务 → Java (Spring)
性能边界（经验值）
| 指标 | C++ | Go | Rust | Python | Java |
|---|
| 单机 QPS（简单 JSON） | 50k+ | 30k+ | 50k+ | 5k | 25k |
| 内存占用（1k 并发） | 15MB | 25MB | 12MB | 80MB | 200MB |
| 冷启动 | <1s | <1s | <1s | 1s | 5s |
| Docker 镜像 | 20MB | 5MB | 5MB | 100MB | 200MB |