gf/net/ghttp/ghttp_server_router_group.go

430 lines
12 KiB
Go
Raw Normal View History

2021-01-17 21:46:25 +08:00
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
2018-12-19 14:45:39 +08:00
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
2018-12-19 14:45:39 +08:00
package ghttp
import (
2021-09-27 21:27:24 +08:00
"context"
"fmt"
2021-11-13 23:23:55 +08:00
"reflect"
2021-10-11 21:41:56 +08:00
"github.com/gogf/gf/v2/debug/gdebug"
2021-11-07 21:31:33 +08:00
"github.com/gogf/gf/v2/internal/utils"
2021-10-11 21:41:56 +08:00
"github.com/gogf/gf/v2/text/gstr"
"github.com/gogf/gf/v2/util/gconv"
)
type (
// RouterGroup is a group wrapping multiple routes and middleware.
RouterGroup struct {
parent *RouterGroup // Parent group.
server *Server // Server.
domain *Domain // Domain.
prefix string // Prefix for sub-route.
middleware []HandlerFunc // Middleware array.
}
// preBindItem is item for lazy registering feature of router group. preBindItem is not really registered
// to server when route function of the group called but is lazily registered when server starts.
preBindItem struct {
group *RouterGroup
bindType string
pattern string
object interface{} // Can be handler, controller or object.
params []interface{} // Extra parameters for route registering depending on the type.
source string // Handler is register at certain source file path:line.
bound bool // Is this item bound to server.
}
)
const (
groupBindTypeHandler = "HANDLER"
groupBindTypeRest = "REST"
groupBindTypeHook = "HOOK"
groupBindTypeMiddleware = "MIDDLEWARE"
)
var (
preBindItems = make([]*preBindItem, 0, 64)
)
// handlePreBindItems is called when server starts, which does really route registering to the server.
2021-09-27 21:27:24 +08:00
func (s *Server) handlePreBindItems(ctx context.Context) {
2020-01-21 22:18:49 +08:00
if len(preBindItems) == 0 {
return
}
for _, item := range preBindItems {
if item.bound {
continue
}
// Handle the items of current server.
if item.group.server != nil && item.group.server != s {
continue
}
if item.group.domain != nil && item.group.domain.server != s {
continue
}
2021-09-27 21:27:24 +08:00
item.group.doBindRoutersToServer(ctx, item)
item.bound = true
}
}
// Group creates and returns a RouterGroup object.
2019-11-30 20:41:53 +08:00
func (s *Server) Group(prefix string, groups ...func(group *RouterGroup)) *RouterGroup {
2019-10-30 23:01:24 +08:00
if len(prefix) > 0 && prefix[0] != '/' {
prefix = "/" + prefix
}
if prefix == "/" {
prefix = ""
}
group := &RouterGroup{
2019-06-19 09:06:52 +08:00
server: s,
prefix: prefix,
}
if len(groups) > 0 {
for _, v := range groups {
v(group)
}
2019-06-19 09:06:52 +08:00
}
return group
2018-12-19 14:45:39 +08:00
}
// Group creates and returns a RouterGroup object, which is bound to a specified domain.
2019-11-30 20:41:53 +08:00
func (d *Domain) Group(prefix string, groups ...func(group *RouterGroup)) *RouterGroup {
2019-10-30 23:01:24 +08:00
if len(prefix) > 0 && prefix[0] != '/' {
prefix = "/" + prefix
}
if prefix == "/" {
prefix = ""
}
2021-11-07 21:31:33 +08:00
routerGroup := &RouterGroup{
2019-07-28 17:37:13 +08:00
domain: d,
2021-11-07 21:31:33 +08:00
server: d.server,
prefix: prefix,
2019-07-28 17:37:13 +08:00
}
if len(groups) > 0 {
2021-11-07 21:31:33 +08:00
for _, nestedGroup := range groups {
nestedGroup(routerGroup)
}
}
2021-11-07 21:31:33 +08:00
return routerGroup
}
// Group creates and returns a sub-group of current router group.
2019-11-30 20:41:53 +08:00
func (g *RouterGroup) Group(prefix string, groups ...func(group *RouterGroup)) *RouterGroup {
if prefix == "/" {
prefix = ""
}
group := &RouterGroup{
parent: g,
server: g.server,
domain: g.domain,
2019-08-10 14:10:47 +08:00
prefix: prefix,
}
if len(g.middleware) > 0 {
group.middleware = make([]HandlerFunc, len(g.middleware))
copy(group.middleware, g.middleware)
}
if len(groups) > 0 {
for _, v := range groups {
v(group)
}
2019-06-19 09:06:52 +08:00
}
return group
}
2018-12-19 14:45:39 +08:00
// Clone returns a new router group which is a clone of current group.
func (g *RouterGroup) Clone() *RouterGroup {
newGroup := &RouterGroup{
parent: g.parent,
server: g.server,
domain: g.domain,
prefix: g.prefix,
middleware: make([]HandlerFunc, len(g.middleware)),
}
copy(newGroup.middleware, g.middleware)
return newGroup
}
// Bind does batch route registering feature for router group.
2021-11-07 21:31:33 +08:00
func (g *RouterGroup) Bind(handlerOrObject ...interface{}) *RouterGroup {
2021-09-27 21:27:24 +08:00
var (
ctx = context.TODO()
group = g.Clone()
)
2021-11-07 21:31:33 +08:00
for _, v := range handlerOrObject {
var (
item = v
originValueAndKind = utils.OriginValueAndKind(item)
)
switch originValueAndKind.OriginKind {
case reflect.Func, reflect.Struct:
group = group.preBindToLocalArray(
groupBindTypeHandler,
"/",
item,
)
default:
2021-11-07 21:31:33 +08:00
g.server.Logger().Fatalf(ctx, "invalid bind parameter type: %v", originValueAndKind.InputValue.Type())
2019-06-19 09:06:52 +08:00
}
}
return group
2018-12-19 14:45:39 +08:00
}
// ALL registers a http handler to given route pattern and all http methods.
func (g *RouterGroup) ALL(pattern string, object interface{}, params ...interface{}) *RouterGroup {
2021-11-07 21:31:33 +08:00
return g.Clone().preBindToLocalArray(
groupBindTypeHandler,
defaultMethod+":"+pattern,
object,
params...,
)
2018-12-19 14:45:39 +08:00
}
2020-11-24 21:19:01 +08:00
// ALLMap registers http handlers for http methods using map.
2020-12-29 13:39:40 +08:00
func (g *RouterGroup) ALLMap(m map[string]interface{}) {
2020-11-24 21:19:01 +08:00
for pattern, object := range m {
2020-12-29 13:39:40 +08:00
g.ALL(pattern, object)
2020-11-24 21:19:01 +08:00
}
}
// Map registers http handlers for http methods using map.
func (g *RouterGroup) Map(m map[string]interface{}) {
for pattern, object := range m {
g.preBindToLocalArray(groupBindTypeHandler, pattern, object)
}
}
// GET registers a http handler to given route pattern and http method: GET.
func (g *RouterGroup) GET(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "GET:"+pattern, object, params...)
}
// PUT registers a http handler to given route pattern and http method: PUT.
func (g *RouterGroup) PUT(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "PUT:"+pattern, object, params...)
}
// POST registers a http handler to given route pattern and http method: POST.
func (g *RouterGroup) POST(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "POST:"+pattern, object, params...)
}
// DELETE registers a http handler to given route pattern and http method: DELETE.
func (g *RouterGroup) DELETE(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "DELETE:"+pattern, object, params...)
2018-12-19 14:45:39 +08:00
}
// PATCH registers a http handler to given route pattern and http method: PATCH.
func (g *RouterGroup) PATCH(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "PATCH:"+pattern, object, params...)
2018-12-19 14:45:39 +08:00
}
// HEAD registers a http handler to given route pattern and http method: HEAD.
func (g *RouterGroup) HEAD(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "HEAD:"+pattern, object, params...)
2018-12-19 14:45:39 +08:00
}
// CONNECT registers a http handler to given route pattern and http method: CONNECT.
func (g *RouterGroup) CONNECT(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "CONNECT:"+pattern, object, params...)
2018-12-19 14:45:39 +08:00
}
// OPTIONS registers a http handler to given route pattern and http method: OPTIONS.
func (g *RouterGroup) OPTIONS(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "OPTIONS:"+pattern, object, params...)
2018-12-19 14:45:39 +08:00
}
// TRACE registers a http handler to given route pattern and http method: TRACE.
func (g *RouterGroup) TRACE(pattern string, object interface{}, params ...interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, "TRACE:"+pattern, object, params...)
2018-12-19 14:45:39 +08:00
}
// REST registers a http handler to given route pattern according to REST rule.
func (g *RouterGroup) REST(pattern string, object interface{}) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeRest, pattern, object)
2018-12-19 14:45:39 +08:00
}
// Hook registers a hook to given route pattern.
func (g *RouterGroup) Hook(pattern string, hook string, handler HandlerFunc) *RouterGroup {
return g.Clone().preBindToLocalArray(groupBindTypeHandler, pattern, handler, hook)
2018-12-19 14:45:39 +08:00
}
// Middleware binds one or more middleware to the router group.
func (g *RouterGroup) Middleware(handlers ...HandlerFunc) *RouterGroup {
g.middleware = append(g.middleware, handlers...)
return g
}
// preBindToLocalArray adds the route registering parameters to internal variable array for lazily registering feature.
func (g *RouterGroup) preBindToLocalArray(bindType string, pattern string, object interface{}, params ...interface{}) *RouterGroup {
_, file, line := gdebug.CallerWithFilter([]string{utils.StackFilterKeyForGoFrame})
preBindItems = append(preBindItems, &preBindItem{
group: g,
bindType: bindType,
pattern: pattern,
object: object,
params: params,
source: fmt.Sprintf(`%s:%d`, file, line),
})
return g
}
2018-12-19 14:45:39 +08:00
// getPrefix returns the route prefix of the group, which recursively retrieves its parent's prefixo.
func (g *RouterGroup) getPrefix() string {
prefix := g.prefix
parent := g.parent
for parent != nil {
prefix = parent.prefix + prefix
parent = parent.parent
}
return prefix
2018-12-19 14:45:39 +08:00
}
// doBindRoutersToServer does really register for the group.
2021-09-27 21:27:24 +08:00
func (g *RouterGroup) doBindRoutersToServer(ctx context.Context, item *preBindItem) *RouterGroup {
var (
bindType = item.bindType
pattern = item.pattern
object = item.object
params = item.params
source = item.source
)
prefix := g.getPrefix()
// Route check.
if len(prefix) > 0 {
2019-06-19 09:06:52 +08:00
domain, method, path, err := g.server.parsePattern(pattern)
if err != nil {
2021-09-27 21:27:24 +08:00
g.server.Logger().Fatalf(ctx, "invalid pattern: %s", pattern)
2019-06-19 09:06:52 +08:00
}
// If there is already a domain, unset the domain field in the pattern.
if g.domain != nil {
domain = ""
}
if bindType == groupBindTypeRest {
2021-11-07 21:31:33 +08:00
pattern = path
2019-06-25 23:03:29 +08:00
} else {
pattern = g.server.serveHandlerKey(
2021-11-07 21:31:33 +08:00
method, path, domain,
)
2019-06-19 09:06:52 +08:00
}
}
// Filter repeated char '/'.
pattern = gstr.Replace(pattern, "//", "/")
// Convert params to string array.
extras := gconv.Strings(params)
// Check whether it's a hook handler.
if _, ok := object.(HandlerFunc); ok && len(extras) > 0 {
bindType = groupBindTypeHook
2019-06-19 09:06:52 +08:00
}
switch bindType {
case groupBindTypeHandler:
if reflect.ValueOf(object).Kind() == reflect.Func {
funcInfo, err := g.server.checkAndCreateFuncInfo(object, "", "", "")
if err != nil {
g.server.Logger().Fatal(ctx, err.Error())
return g
}
2021-11-07 21:31:33 +08:00
in := doBindHandlerInput{
Prefix: prefix,
Pattern: pattern,
FuncInfo: funcInfo,
Middleware: g.middleware,
Source: source,
}
if g.domain != nil {
g.domain.doBindHandler(ctx, in)
2019-06-19 09:06:52 +08:00
} else {
2021-11-07 21:31:33 +08:00
g.server.doBindHandler(ctx, in)
2019-06-19 09:06:52 +08:00
}
} else {
if len(extras) > 0 {
2021-11-07 21:31:33 +08:00
if gstr.Contains(extras[0], ",") {
in := doBindObjectInput{
Prefix: prefix,
Pattern: pattern,
Object: object,
Method: extras[0],
Middleware: g.middleware,
Source: source,
}
if g.domain != nil {
g.domain.doBindObject(ctx, in)
} else {
2021-11-07 21:31:33 +08:00
g.server.doBindObject(ctx, in)
}
2019-06-19 09:06:52 +08:00
} else {
2021-11-07 21:31:33 +08:00
in := doBindObjectMethodInput{
Prefix: prefix,
Pattern: pattern,
Object: object,
Method: extras[0],
Middleware: g.middleware,
Source: source,
}
if g.domain != nil {
g.domain.doBindObjectMethod(ctx, in)
} else {
2021-11-07 21:31:33 +08:00
g.server.doBindObjectMethod(ctx, in)
}
2019-06-19 09:06:52 +08:00
}
} else {
2021-11-07 21:31:33 +08:00
in := doBindObjectInput{
Prefix: prefix,
Pattern: pattern,
Object: object,
Method: "",
Middleware: g.middleware,
Source: source,
}
// At last, it treats the `object` as Object registering type.
2021-11-07 21:31:33 +08:00
if g.domain != nil {
g.domain.doBindObject(ctx, in)
2019-06-19 09:06:52 +08:00
} else {
2021-11-07 21:31:33 +08:00
g.server.doBindObject(ctx, in)
2019-06-19 09:06:52 +08:00
}
}
}
case groupBindTypeRest:
2021-11-07 21:31:33 +08:00
in := doBindObjectInput{
Prefix: prefix,
Pattern: pattern,
Object: object,
Method: "",
Middleware: g.middleware,
Source: source,
}
if g.domain != nil {
g.domain.doBindObjectRest(ctx, in)
2019-06-19 09:06:52 +08:00
} else {
2021-11-07 21:31:33 +08:00
g.server.doBindObjectRest(ctx, in)
2019-06-19 09:06:52 +08:00
}
case groupBindTypeHook:
2021-11-07 21:31:33 +08:00
if handler, ok := object.(HandlerFunc); ok {
in := doBindHookHandlerInput{
Prefix: prefix,
Pattern: pattern,
HookName: extras[0],
Handler: handler,
Source: source,
}
if g.domain != nil {
g.domain.doBindHookHandler(ctx, in)
2019-06-19 09:06:52 +08:00
} else {
2021-11-07 21:31:33 +08:00
g.server.doBindHookHandler(ctx, in)
2019-06-19 09:06:52 +08:00
}
} else {
2021-09-27 21:27:24 +08:00
g.server.Logger().Fatalf(ctx, "invalid hook handler for pattern: %s", pattern)
2019-06-19 09:06:52 +08:00
}
}
return g
2018-12-19 14:45:39 +08:00
}