baize/api/router.go

package api

import (
	"github.com/gin-gonic/gin"
)

// Handler 请求处理函数
type Handler func(c *Context)

type Router interface {
	AddMiddlewares(middlewares ...Handler) Router
	RegisterVersionedRouter(version string, middlewares ...Handler) Router
	GetVersionedRouter(version string) Router
	AddRoute(method string, relativePath string, middlewares ...Handler) Router
	Static(relativePath string, root string)
	StaticFile(relativePath string, filepath string)
	BasePath() string
}

type RootRouter struct {
	engine    *gin.Engine
	versioned map[string]*PrefixRouter
}

func newRootRouter(engine *gin.Engine) *RootRouter {
	return &RootRouter{
		engine:    engine,
		versioned: make(map[string]*PrefixRouter),
	}
}

func (r *RootRouter) AddMiddlewares(middlewares ...Handler) Router {
	r.engine.Use(transferHandlers(middlewares...)...)
	return r
}

func (r *RootRouter) RegisterVersionedRouter(version string, middlewares ...Handler) Router {
	versioned := r.engine.Group(version, transferHandlers(middlewares...)...)
	r.versioned[version] = newPrefixRouter(versioned)

	return r.versioned[version]
}

func (r *RootRouter) Static(relativePath string, root string) {
	r.engine.Static(relativePath, root)
}

func (r *RootRouter) StaticFile(relativePath string, filepath string) {
	r.engine.StaticFile(relativePath, filepath)
}

func (r *RootRouter) BasePath() string {
	return r.engine.BasePath()
}

func (r *RootRouter) GetVersionedRouter(version string) Router {
	return r.versioned[version]
}

func (r *RootRouter) AddRoute(method string, relativePath string, middlewares ...Handler) Router {
	r.engine.Handle(method, relativePath, transferHandlers(middlewares...)...)
	return r
}

type PrefixRouter struct {
	groupRouter *gin.RouterGroup
	versioned   map[string]*PrefixRouter
}

func newPrefixRouter(group *gin.RouterGroup) *PrefixRouter {
	return &PrefixRouter{
		groupRouter: group,
		versioned:   make(map[string]*PrefixRouter),
	}
}

func (r *PrefixRouter) AddMiddlewares(middlewares ...Handler) Router {
	r.groupRouter.Use(transferHandlers(middlewares...)...)
	return r
}

func (r *PrefixRouter) RegisterVersionedRouter(version string, middlewares ...Handler) Router {
	ginMiddlewares := make([]gin.HandlerFunc, 0)
	for _, m := range middlewares {
		innerM := m
		ginMiddlewares = append(ginMiddlewares, func(c *gin.Context) {
			innerM(&Context{Context: c})
		})
	}

	versioned := r.groupRouter.Group(version, ginMiddlewares...)
	r.versioned[version] = newPrefixRouter(versioned)

	return r.versioned[version]
}

func (r *PrefixRouter) GetVersionedRouter(version string) Router {
	return r.versioned[version]
}

func (r *PrefixRouter) AddRoute(method string, relativePath string, middlewares ...Handler) Router {
	r.groupRouter.Handle(method, relativePath, transferHandlers(middlewares...)...)
	return r
}

func (r *PrefixRouter) Static(relativePath string, root string) {
	r.groupRouter.Static(relativePath, root)
}

func (r *PrefixRouter) StaticFile(relativePath string, filepath string) {
	r.groupRouter.StaticFile(relativePath, filepath)
}

func (r *PrefixRouter) BasePath() string {
	return r.groupRouter.BasePath()
}

func transferHandlers(handlers ...Handler) []gin.HandlerFunc {
	ginHandlers := make([]gin.HandlerFunc, 0)
	for _, handler := range handlers {
		innerHandler := handler
		ginHandlers = append(ginHandlers, func(c *gin.Context) {
			innerHandler(&Context{Context: c})
		})
	}

	return ginHandlers
}