使用Golang创建包含1000个端点的REST CRUD API

Sibert:

有没有更好的方法？

一个选择可以是使用 gorilla 工具包 🤷‍♂️

Gorilla, the golang web toolkit

Gorilla 是 Go 编程语言的 Web 工具包

你的原型展示了正确的思路，但需要改进以支持1000个端点。以下是基于你代码的增强版本，使用httprouter实现动态路由和内存存储：

package main

import (
	"encoding/json"
	"net/http"
	"sync"
	"github.com/julienschmidt/httprouter"
)

type Resource struct {
	Value string `json:"value"`
}

var (
	resources = make(map[string]Resource)
	mu        sync.RWMutex
)

func main() {
	router := httprouter.New()
	
	// 动态端点处理
	router.GET("/:resource", GetResource)
	router.GET("/:resource/:id", GetResourceByID)
	router.POST("/:resource", CreateResource)
	router.PUT("/:resource/:id", UpdateResource)
	router.DELETE("/:resource/:id", DeleteResource)
	router.OPTIONS("/*path", HandleCORS)
	
	http.ListenAndServe(":9999", router)
}

func HandleCORS(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "*")
	w.WriteHeader(http.StatusOK)
}

func GetResource(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	mu.RLock()
	defer mu.RUnlock()
	
	resourceName := ps.ByName("resource")
	response := make(map[string]Resource)
	
	for key, resource := range resources {
		if strings.HasPrefix(key, resourceName+"/") {
			response[key] = resource
		}
	}
	
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

func GetResourceByID(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	mu.RLock()
	defer mu.RUnlock()
	
	key := ps.ByName("resource") + "/" + ps.ByName("id")
	if resource, exists := resources[key]; exists {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(resource)
		return
	}
	
	http.Error(w, "Resource not found", http.StatusNotFound)
}

func CreateResource(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	var resource Resource
	if err := json.NewDecoder(r.Body).Decode(&resource); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}
	
	mu.Lock()
	key := ps.ByName("resource") + "/" + generateID()
	resources[key] = resource
	mu.Unlock()
	
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(map[string]string{"id": key, "value": resource.Value})
}

func UpdateResource(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	var resource Resource
	if err := json.NewDecoder(r.Body).Decode(&resource); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}
	
	key := ps.ByName("resource") + "/" + ps.ByName("id")
	mu.Lock()
	defer mu.Unlock()
	
	if _, exists := resources[key]; !exists {
		http.Error(w, "Resource not found", http.StatusNotFound)
		return
	}
	
	resources[key] = resource
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(resource)
}

func DeleteResource(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	key := ps.ByName("resource") + "/" + ps.ByName("id")
	mu.Lock()
	defer mu.Unlock()
	
	if _, exists := resources[key]; !exists {
		http.Error(w, "Resource not found", http.StatusNotFound)
		return
	}
	
	delete(resources, key)
	w.WriteHeader(http.StatusNoContent)
}

func generateID() string {
	return fmt.Sprintf("%d", time.Now().UnixNano())
}

回答你的问题：

1. 你的方向正确，但需要更结构化的路由处理
2. 使用httprouter或gorilla/mux比标准库多路复用器更适合大量端点
3. httprouter确实更快，它使用基数树路由，时间复杂度O(n)，而标准库是O(n²)

这个实现支持：

• 动态资源端点（如/users、/products）
• 每个资源的CRUD操作
• 并发安全的存储
• 正确的HTTP状态码
• JSON请求/响应处理

要扩展到1000个端点，建议：

1. 添加数据库持久化层
2. 实现请求限流
3. 添加监控和日志
4. 考虑使用gRPC提高性能