ozzo-routing：Golang极速HTTP路由及RESTful API构建插件库

ozzo-routing是一个轻量级但功能强大的Go语言HTTP路由库，专为构建高性能RESTful API而设计。它提供了简洁的API、中间件支持和丰富的功能扩展。

主要特性

1. 极高性能：基于高效路由算法，处理速度接近原生net/http
2. RESTful支持：天然支持RESTful风格API设计
3. 中间件链：灵活的中间件机制
4. 错误处理：统一的错误处理机制
5. 数据绑定：自动将请求数据绑定到结构体
6. 数据验证：内置数据验证功能

安装

go get github.com/go-ozzo/ozzo-routing/v2

基础使用示例

package main

import (
	"net/http"
	
	"github.com/go-ozzo/ozzo-routing/v2"
	"github.com/go-ozzo/ozzo-routing/v2/content"
	"github.com/go-ozzo/ozzo-routing/v2/cors"
)

func main() {
	router := routing.New()
	
	// 使用JSON响应中间件
	router.Use(
		content.TypeNegotiator(content.JSON),
		cors.Handler(cors.Options{
			AllowOrigins: "*",
			AllowHeaders: "*",
			AllowMethods: "*",
		}),
	)
	
	// 定义路由组
	api := router.Group("/api")
	
	// GET /api/ping
	api.Get("/ping", func(c *routing.Context) error {
		return c.Write("pong")
	})
	
	// POST /api/echo
	api.Post("/echo", func(c *routing.Context) error {
		var data struct {
			Message string `json:"message"`
		}
		
		// 绑定JSON请求体
		if err := c.Read(&data); err != nil {
			return err
		}
		
		return c.Write(map[string]string{
			"received": data.Message,
		})
	})
	
	http.Handle("/", router)
	http.ListenAndServe(":8080", nil)
}

RESTful资源路由

// 用户资源控制器
type UserController struct{}

func (uc *UserController) Get(c *routing.Context) error {
	id := c.Param("id")
	// 这里应该是从数据库获取用户逻辑
	return c.Write(map[string]string{
		"id":   id,
		"name": "User " + id,
	})
}

func (uc *UserController) Post(c *routing.Context) error {
	var user struct {
		Name  string `json:"name"`
		Email string `json:"email"`
	}
	
	if err := c.Read(&user); err != nil {
		return err
	}
	
	// 这里应该是创建用户逻辑
	return c.Write(map[string]interface{}{
		"status": "created",
		"user":   user,
	})
}

func main() {
	router := routing.New()
	router.Use(content.TypeNegotiator(content.JSON))
	
	// RESTful路由
	router.To("GET,POST", "/users", new(UserController))
	router.To("GET,PUT,DELETE", "/users/<id>", new(UserController))
	
	http.ListenAndServe(":8080", router)
}

中间件使用

ozzo-routing的中间件机制非常灵活：

func AuthMiddleware(c *routing.Context) error {
	token := c.Request.Header.Get("Authorization")
	if token != "valid-token" {
		return c.WriteWithStatus(map[string]string{
			"error": "Unauthorized",
		}, http.StatusUnauthorized)
	}
	return nil
}

func LoggingMiddleware(c *routing.Context) error {
	// 请求前处理
	start := time.Now()
	
	// 继续处理请求
	err := c.Next()
	
	// 请求后处理
	log.Printf(
		"[%s] %s %s %s %v",
		c.Request.Method,
		c.Request.URL.Path,
		c.Request.RemoteAddr,
		time.Since(start),
		err,
	)
	
	return err
}

func main() {
	router := routing.New()
	
	// 全局中间件
	router.Use(
		LoggingMiddleware,
		content.TypeNegotiator(content.JSON),
	)
	
	// 需要认证的路由组
	authGroup := router.Group("")
	authGroup.Use(AuthMiddleware)
	
	authGroup.Get("/secure", func(c *routing.Context) error {
		return c.Write("Secure content")
	})
	
	http.ListenAndServe(":8080", router)
}

错误处理

ozzo-routing提供了统一的错误处理机制：

type ErrorResponse struct {
	Error  string `json:"error"`
	Status int    `json:"status"`
}

func ErrorHandler(status int, err error) routing.Handler {
	return func(c *routing.Context) error {
		return c.WriteWithStatus(ErrorResponse{
			Error:  err.Error(),
			Status: status,
		}, status)
	}
}

func main() {
	router := routing.New()
	router.Use(
		content.TypeNegotiator(content.JSON),
	)
	
	// 注册错误处理器
	router.Get("/error", func(c *routing.Context) error {
		// 模拟错误
		return routing.NewHTTPError(http.StatusBadRequest, "Invalid request")
	})
	
	// 自定义错误处理中间件
	router.Use(func(c *routing.Context) error {
		err := c.Next()
		
		if err == nil {
			return nil
		}
		
		if httpErr, ok := err.(routing.HTTPError); ok {
			return ErrorHandler(httpErr.StatusCode(), httpErr)(c)
		}
		
		return ErrorHandler(http.StatusInternalServerError, err)(c)
	})
	
	http.ListenAndServe(":8080", router)
}

数据验证

ozzo-routing内置了数据验证功能：

type User struct {
	Name     string `json:"name"`
	Email    string `json:"email"`
	Password string `json:"password"`
}

func (u User) Validate() error {
	return validation.ValidateStruct(&u,
		validation.Field(&u.Name, validation.Required, validation.Length(2, 50)),
		validation.Field(&u.Email, validation.Required, validation.Length(5, 100)),
		validation.Field(&u.Password, validation.Required, validation.Length(6, 50)),
	)
}

func main() {
	router := routing.New()
	router.Use(content.TypeNegotiator(content.JSON))
	
	router.Post("/users", func(c *routing.Context) error {
		var user User
		if err := c.Read(&user); err != nil {
			return err
		}
		
		// 验证数据
		if err := user.Validate(); err != nil {
			return err
		}
		
		// 处理有效数据...
		return c.Write(map[string]string{"status": "created"})
	})
	
	http.ListenAndServe(":8080", router)
}

性能优化建议

1. 尽量减少中间件数量，只添加必要的中间件
2. 对于高并发场景，考虑使用路由缓存
3. 避免在中间件中进行耗时的同步操作
4. 使用路由组来组织相关路由，提高匹配效率

ozzo-routing是一个非常适合构建高性能RESTful API的轻量级框架，它的设计简洁但功能强大，是传统重量级框架如Gin或Echo之外的优秀选择。