golang,go,博客,开源,编程

golang每日一库之valyala/fasthttp

Published on with 0 views and 0 comments

fasthttp 是 Go 语言中一个专为 高吞吐量 HTTP 服务器 设计的库，它相较于 net/http 提供了 更高的性能 和 更低的内存开销，特别适用于 Web 服务器、API 网关、CDN 边缘计算等高并发场景。

1. fasthttp 主要特性

✅ 高性能

  • 比 net/http 更快（通常是 4~10 倍）
  • 更少的 GC 压力，减少内存分配
  • 零拷贝优化，提高数据处理效率

✅ 低内存占用

  • 采用 对象池 复用 RequestCtx、Request 和 Response，避免频繁分配和释放内存
  • 采用 字节切片 ([]byte) 处理字符串，减少字符串分配

✅ 易于扩展

  • 兼容 net/http 大部分功能，但 API 设计不同
  • 内置 gzip、streaming 支持
  • 异步 I/O 设计，比 net/http 的阻塞模式更高效

2. fasthttp 安装

go get -u github.com/valyala/fasthttp

3. 基本使用

3.1 搭建 HTTP 服务器

package main

import (
	"fmt"
	"github.com/valyala/fasthttp"
)

// 处理 HTTP 请求
func requestHandler(ctx *fasthttp.RequestCtx) {
	switch string(ctx.Path()) {
	case "/":
		fmt.Fprint(ctx, "Hello, Fasthttp!")
	case "/ping":
		fmt.Fprint(ctx, "pong")
	default:
		ctx.Error("Not Found", fasthttp.StatusNotFound)
	}
}

func main() {
	fmt.Println("Server is running on :8080")
	if err := fasthttp.ListenAndServe(":8080", requestHandler); err != nil {
		fmt.Println("Error:", err)
	}
}

测试：

curl http://localhost:8080/
curl http://localhost:8080/ping

3.2 搭建 HTTPS 服务器

package main

import (
	"fmt"
	"github.com/valyala/fasthttp"
)

// HTTPS 处理函数
func requestHandler(ctx *fasthttp.RequestCtx) {
	fmt.Fprint(ctx, "Hello, Secure Fasthttp!")
}

func main() {
	fmt.Println("HTTPS Server running on :8443")
	err := fasthttp.ListenAndServeTLS(":8443", "cert.pem", "key.pem", requestHandler)
	if err != nil {
		fmt.Println("Error:", err)
	}
}

4. HTTP 客户端

4.1 发送 GET 请求

package main

import (
	"fmt"
	"github.com/valyala/fasthttp"
)

func main() {
	// 创建请求对象
	req := fasthttp.AcquireRequest()
	defer fasthttp.ReleaseRequest(req)
	req.SetRequestURI("http://example.com")

	// 创建响应对象
	resp := fasthttp.AcquireResponse()
	defer fasthttp.ReleaseResponse(resp)

	// 发送请求
	client := &fasthttp.Client{}
	if err := client.Do(req, resp); err != nil {
		fmt.Println("Request failed:", err)
		return
	}

	// 输出响应
	fmt.Println("Response:", string(resp.Body()))
}

4.2 发送 POST 请求

package main

import (
	"fmt"
	"github.com/valyala/fasthttp"
)

func main() {
	req := fasthttp.AcquireRequest()
	defer fasthttp.ReleaseRequest(req)

	req.SetRequestURI("http://example.com")
	req.Header.SetMethod(fasthttp.MethodPost)
	req.SetBody([]byte(`{"username": "john", "password": "123456"}`))
	req.Header.SetContentType("application/json")

	resp := fasthttp.AcquireResponse()
	defer fasthttp.ReleaseResponse(resp)

	client := &fasthttp.Client{}
	if err := client.Do(req, resp); err != nil {
		fmt.Println("Request failed:", err)
		return
	}

	fmt.Println("Response:", string(resp.Body()))
}

5. 解析 JSON

package main

import (
	"encoding/json"
	"fmt"
	"github.com/valyala/fasthttp"
)

type Message struct {
	Status  string `json:"status"`
	Message string `json:"message"`
}

func jsonHandler(ctx *fasthttp.RequestCtx) {
	ctx.Response.Header.SetContentType("application/json")
	msg := Message{
		Status:  "success",
		Message: "Hello, Fasthttp!",
	}
	json.NewEncoder(ctx).Encode(msg)
}

func main() {
	fmt.Println("Server running on :8080")
	fasthttp.ListenAndServe(":8080", jsonHandler)
}

6. 路由支持（fasthttprouter）

fasthttp不直接提供路由功能，但可以使用 fasthttprouter 进行路由管理：

go get -u github.com/fasthttp/router

package main

import (
	"fmt"
	"github.com/fasthttp/router"
	"github.com/valyala/fasthttp"
)

func main() {
	r := router.New()
	r.GET("/", func(ctx *fasthttp.RequestCtx) {
		fmt.Fprint(ctx, "Welcome to Fasthttp Router!")
	})
	r.GET("/hello/{name}", func(ctx *fasthttp.RequestCtx) {
		name := ctx.UserValue("name").(string)
		fmt.Fprintf(ctx, "Hello, %s!", name)
	})

	fmt.Println("Server running on :8080")
	fasthttp.ListenAndServe(":8080", r.Handler)
}

测试：

curl http://localhost:8080/hello/John

7. WebSocket（fasthttp/websocket）

fasthttp 本身不支持 WebSocket，可以使用 fasthttp/websocket：

go get -u github.com/fasthttp/websocket

package main

import (
	"fmt"
	"log"
	"github.com/valyala/fasthttp"
	"github.com/fasthttp/websocket"
)

var upgrader = websocket.FastHTTPUpgrader{}

func wsHandler(ctx *fasthttp.RequestCtx) {
	err := upgrader.Upgrade(ctx, func(conn *websocket.Conn) {
		defer conn.Close()
		for {
			_, msg, err := conn.ReadMessage()
			if err != nil {
				log.Println("Read error:", err)
				break
			}
			log.Println("Received:", string(msg))
			conn.WriteMessage(websocket.TextMessage, msg)
		}
	})
	if err != nil {
		log.Println("Upgrade error:", err)
	}
}

func main() {
	fmt.Println("WebSocket server running on :8080/ws")
	fasthttp.ListenAndServe(":8080", wsHandler)
}

8. 为什么使用 fasthttp 而不是 net/http？

特性net/httpfasthttp
性能普通极高
GC 压力大低
内存占用高低
路由支持内置需要第三方
WebSocket内置需额外库

适用场景

✅ 高并发 API
✅ CDN 代理服务
✅ WebSocket 服务
✅ 负载均衡器

如果你需要极致的 HTTP 处理性能，fasthttp 是一个优秀的选择！你想用它做什么项目呢？

标题：golang每日一库之valyala/fasthttp
作者：mooncakeee
地址：http://blog.dd95828.com/articles/2025/02/28/1740703947059.html
联系：scotttu@163.com
↑ ↓