mux

package module
v6.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 20, 2022 License: MIT Imports: 14 Imported by: 2

README

mux

Go Go version Go Report Card license codecov PkgGoDev

mux 功能完备的 Go 路由器：

  • 路由参数；
  • 支持正则表达式作为路由项匹配方式；
  • 拦截正则表达式的行为；
  • 自动生成 OPTIONS 请求处理方式；
  • 自动生成 HEAD 请求处理方式；
  • 根据路由反向生成地址；
  • 任意风格的路由，比如 discuz 这种不以 / 作为分隔符的；
  • 分组路由，比如按域名，或是版本号等；
  • CORS 跨域资源的处理；
  • 支持中间件；
  • 自动生成 OPTIONS * 请求；
  • 静态文件系统；
  • TRACE 请求方法的支持；
  • panic 处理；
  • 支持泛型，可轻易实现自定义的路由处理方式；
import "github.com/issue9/middleware/v5/auth/basic"
import "github.com/issue9/mux/v6"

c := basic.New()

router := mux.NewRouter("", &mux.Options{}, c)
router.Get("/users/1", h).
    Post("/login", h).
    Get("/pages/{id:\\d+}.html", h). // 匹配 /pages/123.html 等格式，path = 123
    Get("/posts/{path}.html", h).    // 匹配 /posts/2020/11/11/title.html 等格式，path = 2020/11/11/title

// 统一前缀路径的路由
p := router.Prefix("/api")
p.Get("/logout", h) // 相当于 m.Get("/api/logout", h)
p.Post("/login", h) // 相当于 m.Get("/api/login", h)

// 对同一资源的不同操作
res := p.Resource("/users/{id:\\d+}")
res.Get(h)   // 相当于 m.Get("/api/users/{id:\\d+}", h)
res.Post(h)  // 相当于 m.Post("/api/users/{id:\\d+}", h)
res.URL(map[string]string{"id": "5"}) // 构建一条基于此路由项的路径：/users/5

http.ListenAndServe(":8080", router)

语法

路由参数采用大括号包含，内部包含名称和规则两部分：{name:rule}， 其中的 name 表示参数的名称，rule 表示对参数的约束规则。

name 可以包含 - 前缀，表示在实际执行过程中，不捕获该名称的对应的值， 可以在一定程序上提升性能。

rule 表示对参数的约束，一般为正则或是空，为空表示匹配任意值， 拦截器一栏中有关 rule 的高级用法。以下是一些常见的示例。

/posts/{id}.html                  // 匹配 /posts/1.html
/posts-{id}-{page}.html           // 匹配 /posts-1-10.html
/posts/{path:\\w+}.html           // 匹配 /posts/2020/11/11/title.html
/tags/{tag:\\w+}/{path}           // 匹配 /tags/abc/title.html
路径匹配规则

可能会出现多条记录与同一请求都匹配的情况，这种情况下， 系统会找到一条认为最匹配的路由来处理，判断规则如下：

  1. 普通路由优先于正则路由；
  2. 拦截器优先于正则路由；
  3. 正则路由优先于命名路由；

比如：

/posts/{id}.html              // 1
/posts/{id:\\d+}.html         // 2
/posts/1.html                 // 3

/posts/1.html      // 匹配 3
/posts/11.html     // 匹配 2
/posts/index.html  // 匹配 1

路径的匹配是以从左到右的顺序进行的，父节点不会因为没有子节点匹配而扩大自己的匹配范围， 比如 /posts/{id}-{page:digit}.html 可以匹配 /posts/1-1.html，但无法匹配 /posts/1-1-1.html，虽然理论上 1-1- 也能匹配 {id}，但是 1- 已经优先匹配了， 在子元素找不到的情况下，并不会将父元素的匹配范围扩大到 1-1-。

路由参数

通过正则表达式匹配的路由，其中带命名的参数可通过 GetParams() 获取：

import "github.com/issue9/mux/v6"

params := mux.GetParams(r)

id, err := params.Int("id")
 // 或是
id := params.MustInt("id", 0) // 在无法获取 id 参数时采用 0 作为默认值返回

高级用法

分组路由

可以通过匹配 Matcher 接口，定义了一组特定要求的路由项。

// server.go

import "github.com/issue9/mux/v6"
import "github.com/issue9/mux/v6/muxutil"

m := mux.NewRouters(...)

def := mux.NewRouter("default")
m.AddRouter(muxutil.NewPathVersion("version-key", "v1"), def)
def.Get("/path", h1)

host := mux.NewRouter("host")
m.AddRouter(muxutil.NewHosts("*.example.com"), host)
host.Get("/path", h2)

http.ListenAndServe(":8080", m)

// client.go

// 访问 h2 的内容
r := http.NewRequest(http.MethodGet, "https://abc.example.com/path", nil)
r.Do()

// 访问 h1 的内容
r := http.NewRequest(http.MethodGet, "https://other_domain.com/v1/path", nil)
r.Do()
拦截器

正常情况下，/posts/{id:\d+} 或是 /posts/{id:[0-9]+} 会被当作正则表达式处理， 但是正则表达式的性能并不是很好，这个时候我们可以通过在 NewRouter 传递 Interceptor 进行拦截：

import "github.com/issue9/mux/v6"

func digit(path string) bool {
    for _, c := range path {
        if c < '0' || c > '9' {
            return false
        }
    }
    return len(path) > 0
}

// 路由中的 \d+ 和 [0-9]+ 均采用 digit 函数进行处理，不再是正则表达式。
opt := mux.Options{Interceptors: map[string]mux.InterceptorFunc{"\\d+": digit, "[0-9]+": digit}
r := mux.NewRouter("", opt)

这样在所有路由项中的 [0-9]+ 和 \\d+ 将由 digit 函数处理， 不再会被编译为正则表达式，在性能上会有很大的提升。 通过该功能，也可以自定义一些非正常的正则表达这式，然后进行拦截，比如：

/posts/{id:digit}/.html

如果不拦截，最终传递给正则表达式，可能会出现编译错误，通过拦截器可以将 digit 合法化。 目前提供了以下几个拦截器：

  • InterceptorDigit 限定为数字字符，相当于正则的 [0-9]；
  • InterceptorWord 相当于正则的 [a-zA-Z0-9]；
  • InterceptorAny 表示匹配任意非空内容；

用户也可以自行实现 InterceptorFunc 作为拦截器。具体可参考 OptionsOf.Interceptors。

CORS

CORS 不再是以中间件的形式提供，而是通过 NewRouter 直接传递有关 CORS 的配置信息， 这样可以更好地处理每个地址支持的请求方法。

OPTIONS 请求方法由系统自动生成。

import "github.com/issue9/mux/v6"

r := mux.NewRouter("name" ,&mux.Options{CORS: AllowedCORS}) // 任意跨域请求

r.Get("/posts/{id}", nil)     // 默认情况下， OPTIONS 的报头为 GET, OPTIONS

http.ListenAndServe(":8080", m)

// client.go

// 访问 h2 的内容
r := http.NewRequest(http.MethodGet, "https://localhost:8080/posts/1", nil)
r.Header.Set("Origin", "https://example.com")
r.Do() // 跨域，可以正常访问


r = http.NewRequest(http.MethodOptions, "https://localhost:8080/posts/1", nil)
r.Header.Set("Origin", "https://example.com")
r.Header.Set("Access-Control-Request-Method", "GET")
r.Do() // 预检请求，可以正常访问
静态文件

可以使用 ServeFile 与命名参数相结合的方式实现静态文件的访问：

r := NewRouter("")
r.Get("/assets/{path}", func(w http.ResponseWriter, r *http.Request){
    err := muxutil.ServeFile(os.DirFS("/static/"), "path", "index.html", w, r)
    if err!= nil {
        http.Error(err.Error(), http.StatusInternalServerError)
    }
})
自定义路由

官方提供的 http.Handler 未必是符合每个人的要求，通过 RouterOf 用户可以很方便地实现自定义格式的 http.Handler， 只需要以下几个步骤：

  1. 定义一个专有的路由处理类型，可以是类也可以是函数；
  2. 根据此类型，生成对应的 RouterOf、PrefixOf、ResourceOf、MiddlewareFuncOf 等类型；
  3. 定义 CallOf 函数；
  4. 将 CallOf 传递给 NewOf；
type Context struct {
    *http.Request
    W http.ResponseWriter
    P Params
}

type HandlerFunc func(ctx *Context)

type Router = RouterOf[HandlerFunc]
type Prefix = PrefixOf[HandlerFunc]
type Resource = ResourceOf[HandlerFunc]
type MiddlewareFunc = MiddlewareFuncOf[HandlerFunc]
type Middleware = MiddlewareOf[HandlerFunc]

func New(name string, ms []Middleware)* Router {
    f := func(w http.ResponseWriter, r *http.Request, ps Params, h HandlerFunc) {
        ctx := &Context {
            R: r,
            W: w,
            P: ps,
        }
        h(ctx)
    }
    return NewRouterOf[HandlerFunc](name, f, ms...)
}

以上就是自定义路由的全部功能，之后就可以直接使用：

r := New("router", nil)

r.Get("/path", func(ctx *Context){
    // TODO
    ctx.W.WriteHeader(200)
})

r.Prefix("/admin").Get("/login", func(ctx *Context){
    // TODO
    ctx.W.WriteHeader(501)
})

更多自定义路由的介绍可参考 https://caixw.io/posts/2022/build-go-router-with-generics.html

性能

https://caixw.github.io/go-http-routers-testing/ 提供了与其它几个框架的对比情况。

版权

本项目采用 MIT 开源授权许可证，完整的授权说明可在 LICENSE 文件中找到。

Documentation

Overview

Package mux 功能完备的路由中间件

提供了泛型版本 RouterOf，适用第三方框架自由实现路由。 同时基于 RouterOf 提供了适配 http.Handler 路由 Router。

语法

路由参数采用大括号包含，内部包含名称和规则两部分：`{name:rule}`， 其中的 name 表示参数的名称，rule 表示对参数的约束规则。

name 可以包含 `-` 前缀，表示在实际执行过程中，不捕获该名称的对应的值， 可以在一定程序上提升性能。

rule 表示对参数的约束，一般为正则或是空，为空表示匹配任意值， 拦截器一栏中有关 rule 的高级用法。以下是一些常见的示例。 

/posts/{id}.html                  // 匹配 /posts/1.html
/posts-{id}-{page}.html           // 匹配 /posts-1-10.html
/posts/{path:\\w+}.html           // 匹配 /posts/2020/11/11/title.html
/tags/{tag:\\w+}/{path}           // 匹配 /tags/abc/title.html

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func CheckSyntax 

func CheckSyntax(pattern string) error

CheckSyntax 检测路由项的语法格式

func DefaultCall 

func DefaultCall(w http.ResponseWriter, r *http.Request, ps Params, h http.Handler)

DefaultCall 针对 http.Handler 的 CallOf 实现

func InterceptorAny 

func InterceptorAny(rule string) bool

InterceptorAny 任意非空字符的拦截器

func InterceptorDigit 

func InterceptorDigit(rule string) bool

InterceptorDigit 任意数字字符的拦截器

func InterceptorWord 

func InterceptorWord(rule string) bool

InterceptorWord 任意英文单词的拦截器

func Methods 

func Methods() []string

Methods 返回所有支持的请求方法

func URL 

func URL(pattern string, params map[string]string) (string, error)

URL 根据参数生成地址

pattern 为路由项的定义内容； params 为路由项中的参数，键名为参数名，键值为参数值。

NOTE: 仅仅是将 params 填入到 pattern 中， 不会判断参数格式是否正确。

func WithValue 

func WithValue(r *http.Request, ps Params) *http.Request

WithValue 将参数 ps 附加在 r 上

与 context.WithValue 功能相同，但是考虑了在同一个 r 上调用多次 WithValue 的情况。

NOTE: 仅适用于 Router 而不是所有 RouterOf。

Types

type CORS 

type CORS struct {
	// Origins 对应 Origin 报头
	//
	// 如果包含了 *，那么其它的设置将不再启作用。
	// 如果此值为空，表示不启用跨域的相关设置；
	Origins []string

	// AllowHeaders 对应 Access-Control-Allow-Headers
	//
	// 可以包含 *，表示可以是任意值，其它值将不再启作用；
	AllowHeaders []string

	// ExposedHeaders 对应 Access-Control-Expose-Headers
	ExposedHeaders []string

	// MaxAge 对应 Access-Control-Max-Age
	//
	// 有以下几种取值：
	// 0 不输出该报头；
	// -1 表示禁用；
	// 其它 >= -1 的值正常输出数值；
	MaxAge int

	// AllowCredentials 对应 Access-Control-Allow-Credentials
	AllowCredentials bool
	// contains filtered or unexported fields
}

CORS 自定义跨域请求设置项

https://developer.mozilla.org/zh-CN/docs/Web/HTTP/cors

func AllowedCORS 

func AllowedCORS() *CORS

AllowedCORS 允许跨域请求

type CallOf 

type CallOf[T any] func(http.ResponseWriter, *http.Request, Params, T)

CallOf 指定如何调用用户自定义的对象 T

type InterceptorFunc 

type InterceptorFunc = syntax.InterceptorFunc

InterceptorFunc 拦截器的函数原型

type Matcher 

type Matcher interface {
	// Match 验证请求是否符合当前对象的要求
	//
	// ps 为匹配过程中生成的参数信息，可以返回 nil；
	// ok 表示是否匹配成功；
	Match(r *http.Request) (ps params.Params, ok bool)
}

Matcher 验证一个请求是否符合要求

Matcher 用于路由项的前置判断，用于对路由项进行归类， 符合同一个 Matcher 的路由项，再各自进行路由。比如按域名进行分组路由。

type MatcherFunc 

type MatcherFunc func(r *http.Request) (ps Params, ok bool)

MatcherFunc 验证请求是否符合要求

ps 为匹配过程中生成的参数信息，可以返回 nil； ok 表示是否匹配成功；

func (MatcherFunc) Match 

func (f MatcherFunc) Match(r *http.Request) (params.Params, bool)

Match 实现 Matcher 接口

type Middleware 

type Middleware = MiddlewareOf[http.Handler]

type MiddlewareFunc 

type MiddlewareFunc = MiddlewareFuncOf[http.Handler]

type MiddlewareFuncOf 

type MiddlewareFuncOf[T any] func(T) T

MiddlewareFuncOf 中间件处理函数

func (MiddlewareFuncOf[T]) Middleware 

func (f MiddlewareFuncOf[T]) Middleware(next T) T

type MiddlewareOf 

type MiddlewareOf[T any] interface {
	Middleware(T) T
}

MiddlewareOf 中间件对象需要实现的接口

type Options 

type Options struct {
	// CaseInsensitive 忽略大小写
	//
	// 该操作仅是将客户端的请求路径转换为小之后再次进行匹配，
	// 如果服务端的路由项设置为大写，则依然是不匹配的。
	CaseInsensitive bool

	// Lock 是否加锁
	//
	// 在调用 RouterOf.Add 添加路由时，有可能会改变整个路由树的结构，
	// 如果需要频繁在运行时添加和删除路由项，那么应当添加此选项。
	Lock bool

	// CORS 自定义跨域请求设置项
	//
	// 为空表示禁用跨域；
	CORS *CORS

	// Interceptors 针对带参数类型路由的拦截处理
	//
	// 在解析诸如 /authors/{id:\\d+} 带参数的路由项时，
	// 用户可以通过拦截并自定义对参数部分 {id:\\d+} 的解析，
	// 从而不需要走正则表达式的那一套解析流程，可以在一定程度上增强性能。
	//
	// 一旦正则表达式被拦截，则节点类型也将不再是正则表达式，
	// 其处理优先级会比正则表达式类型高。 在某些情况下，可能会造成处理结果不相同。比如：
	//  /authors/{id:\\d+}     // 1
	//  /authors/{id:[0-9]+}   // 2
	// 以上两条记录是相同的，但因为表达式不同，也能正常添加，
	// 处理流程，会按添加顺序优先比对第一条，所以第二条是永远无法匹配的。
	// 但是如果你此时添加了 (InterceptorDigit, "[0-9]+")，
	// 使第二个记录的优先级提升，会使第一条永远无法匹配到数据。
	Interceptors map[string]InterceptorFunc

	// URLDomain 为 RouterOf.URL 生成的地址带上域名
	URLDomain string

	// RecoverFunc 用于指路由 panic 之后的处理方法
	RecoverFunc RecoverFunc

	NotFound,
	MethodNotAllowed http.Handler
	// contains filtered or unexported fields
}

type Params 

type Params = params.Params

Params 路由参数

func GetParams 

func GetParams(r *http.Request) Params

GetParams 获取当前请求实例上的参数列表

NOTE: 仅适用于 Router 而不是所有 RouterOf。

func NewParams 

func NewParams() Params

type Prefix 

type Prefix = PrefixOf[http.Handler]

type PrefixOf 

type PrefixOf[T any] struct {
	// contains filtered or unexported fields
}

PrefixOf 操纵统一前缀的路由

func (*PrefixOf[T]) Any 

func (p *PrefixOf[T]) Any(pattern string, h T) *PrefixOf[T]

func (*PrefixOf[T]) Clean 

func (p *PrefixOf[T]) Clean()

Clean 清除所有以 PrefixOf.prefix 开头的路由项

当指定多个相同的 PrefixOf 时，调用其中的一个 Clean 也将会清除其它的： 

r := NewRouterOf(...)
p1 := r.Prefix("prefix")
p2 := r.Prefix("prefix")
p2.Clean() 将同时清除 p1 的内容，因为有相同的前缀。

func (*PrefixOf[T]) Delete 

func (p *PrefixOf[T]) Delete(pattern string, h T) *PrefixOf[T]

func (*PrefixOf[T]) Get 

func (p *PrefixOf[T]) Get(pattern string, h T) *PrefixOf[T]

func (*PrefixOf[T]) Handle 

func (p *PrefixOf[T]) Handle(pattern string, h T, methods ...string) *PrefixOf[T]

func (*PrefixOf[T]) Patch 

func (p *PrefixOf[T]) Patch(pattern string, h T) *PrefixOf[T]

func (*PrefixOf[T]) Post 

func (p *PrefixOf[T]) Post(pattern string, h T) *PrefixOf[T]

func (*PrefixOf[T]) Prefix 

func (p *PrefixOf[T]) Prefix(prefix string, m ...MiddlewareOf[T]) *PrefixOf[T]

Prefix 在现有 PrefixOf 的基础上声明一个新的 PrefixOf 实例

m 中间件函数，按顺序调用，会继承 p 的中间件并按在 m 之前；

func (*PrefixOf[T]) Put 

func (p *PrefixOf[T]) Put(pattern string, h T) *PrefixOf[T]

func (*PrefixOf[T]) Remove 

func (p *PrefixOf[T]) Remove(pattern string, methods ...string)

Remove 删除指定匹配模式的路由项

func (*PrefixOf[T]) Resource 

func (p *PrefixOf[T]) Resource(pattern string, m ...MiddlewareOf[T]) *ResourceOf[T]

Resource 创建一个资源路由项

pattern 资源地址； m 中间件函数，按顺序调用，会继承 p 的中间件并按在 m 之前；

func (*PrefixOf[T]) Router 

func (p *PrefixOf[T]) Router() *RouterOf[T]

Router 返回与当前关联的 *Router 实例

func (*PrefixOf[T]) URL 

func (p *PrefixOf[T]) URL(strict bool, pattern string, params map[string]string) (string, error)

URL 根据参数生成地址

type RecoverFunc 

type RecoverFunc func(http.ResponseWriter, any)

func HTTPRecovery 

func HTTPRecovery(status int) RecoverFunc

HTTPRecovery 仅向客户端输出 status 状态码

func LogRecovery 

func LogRecovery(status int, l *log.Logger) RecoverFunc

LogRecovery 将错误信息输出到日志

status 表示向客户端输出的状态码； l 为输出的日志；

func WriterRecovery 

func WriterRecovery(status int, out io.Writer) RecoverFunc

WriterRecovery 向 io.Writer 输出错误信息

status 表示向客户端输出的状态码； out 输出的 io.Writer，比如 os.Stderr 等；

type Resource 

type Resource = ResourceOf[http.Handler]

type ResourceOf 

type ResourceOf[T any] struct {
	// contains filtered or unexported fields
}

ResourceOf 以资源地址为对象的路由

func (*ResourceOf[T]) Any 

func (r *ResourceOf[T]) Any(h T) *ResourceOf[T]

func (*ResourceOf[T]) Clean 

func (r *ResourceOf[T]) Clean()

Clean 清除当前资源的所有路由项

func (*ResourceOf[T]) Delete 

func (r *ResourceOf[T]) Delete(h T) *ResourceOf[T]

func (*ResourceOf[T]) Get 

func (r *ResourceOf[T]) Get(h T) *ResourceOf[T]

func (*ResourceOf[T]) Handle 

func (r *ResourceOf[T]) Handle(h T, methods ...string) *ResourceOf[T]

func (*ResourceOf[T]) Patch 

func (r *ResourceOf[T]) Patch(h T) *ResourceOf[T]

func (*ResourceOf[T]) Post 

func (r *ResourceOf[T]) Post(h T) *ResourceOf[T]

func (*ResourceOf[T]) Put 

func (r *ResourceOf[T]) Put(h T) *ResourceOf[T]

func (*ResourceOf[T]) Remove 

func (r *ResourceOf[T]) Remove(methods ...string)

Remove 删除指定匹配模式的路由项

func (*ResourceOf[T]) Router 

func (r *ResourceOf[T]) Router() *RouterOf[T]

Router 返回与当前资源关联的 *Router 实例

func (*ResourceOf[T]) URL 

func (r *ResourceOf[T]) URL(strict bool, params map[string]string) (string, error)

URL 根据参数构建一条 URL

params 匹配路由参数中的同名参数，或是不存在路由参数，比如普通的字符串路由项， 该参数不启作用； 

res, := m.Resource("/posts/{id}")
res.URL(map[string]string{"id": "1"}, "") // /posts/1

res, := m.Resource("/posts/{id}/{path}")
res.URL(map[string]string{"id": "1","path":"author/profile"}) // /posts/1/author/profile

type Router 

type Router = RouterOf[http.Handler]

func NewRouter 

func NewRouter(name string, o *Options) *Router

NewRouter 声明适用于官方 http.Handler 接口的路由

这是对 NewRouterOf 的实例化，相当于 NewRouterOf[http.Handler]。

type RouterOf 

type RouterOf[T any] struct {
	// contains filtered or unexported fields
}

RouterOf 路由

可以对路径按正则或是请求方法进行匹配。用法如下： 

router := NewRouterOf[http.Handler](...)
router.Get("/abc/h1", h1).
    Post("/abc/h2", h2).
    Handle("/api/{version:\\d+}",h3, http.MethodGet, http.MethodPost) // 只匹配 GET 和 POST
http.ListenAndServe(router)

如果需要同时对多个 RouterOf 实例进行路由，可以采用 RoutersOf 对象管理多个 RouterOf 实例。

func NewRouterOf 

func NewRouterOf[T any](name string, call CallOf[T], o *Options) *RouterOf[T]

NewRouterOf 声明路由

name string 路由名称，可以为空；

o 修改路由的默认形为。比如 CaseInsensitive 会让路由忽略大小写，可以为空。

T 表示用户用于处理路由项的方法，该类型最终通过 NewRouterOf 中的 call 参数与 http.ResponseWriter 和 *http.Request 相关联。

func (*RouterOf[T]) Any 

func (r *RouterOf[T]) Any(pattern string, h T) *RouterOf[T]

func (*RouterOf[T]) Clean 

func (r *RouterOf[T]) Clean()

Clean 清除当前路由组的所有路由项

func (*RouterOf[T]) Delete 

func (r *RouterOf[T]) Delete(pattern string, h T) *RouterOf[T]

func (*RouterOf[T]) Get 

func (r *RouterOf[T]) Get(pattern string, h T) *RouterOf[T]

Get 相当于 RouterOf.Handle(pattern, h, http.MethodGet) 的简易写法

h 不应该主动调用 WriteHeader，否则会导致 HEAD 请求获取不到 Content-Length 报头。

func (*RouterOf[T]) Handle 

func (r *RouterOf[T]) Handle(pattern string, h T, methods ...string) *RouterOf[T]

Handle 添加一条路由数据

pattern 为路由匹配模式，可以是正则匹配也可以是字符串匹配， 若语法不正确，则直接 panic，可以通过 CheckSyntax 检测语法的有效性，其它接口也相同。 methods 该路由项对应的请求方法，如果未指定值，则表示所有支持的请求方法， 但不包含 OPTIONS 和 HEAD。

func (*RouterOf[T]) Name 

func (r *RouterOf[T]) Name() string

Name 路由名称

func (*RouterOf[T]) Patch 

func (r *RouterOf[T]) Patch(pattern string, h T) *RouterOf[T]

func (*RouterOf[T]) Post 

func (r *RouterOf[T]) Post(pattern string, h T) *RouterOf[T]

func (*RouterOf[T]) Prefix 

func (r *RouterOf[T]) Prefix(prefix string, m ...MiddlewareOf[T]) *PrefixOf[T]

Prefix 声明一个 Prefix 实例

prefix 路由前缀字符串，可以为空； m 中间件函数，按顺序调用，会继承 r 的中间件并按在 m 之前；

func (*RouterOf[T]) Put 

func (r *RouterOf[T]) Put(pattern string, h T) *RouterOf[T]

func (*RouterOf[T]) Remove 

func (r *RouterOf[T]) Remove(pattern string, methods ...string)

Remove 移除指定的路由项

当未指定 methods 时，将删除所有 method 匹配的项。 指定错误的 methods 值，将自动忽略该值。

func (*RouterOf[T]) Resource 

func (r *RouterOf[T]) Resource(pattern string, m ...MiddlewareOf[T]) *ResourceOf[T]

Resource 创建一个资源路由项

pattern 资源地址； m 中间件函数，按顺序调用，会继承 r 的中间件并按在 m 之前；

func (*RouterOf[T]) Routes 

func (r *RouterOf[T]) Routes() map[string][]string

Routes 返回当前路由组的路由项

键名为请求地址，键值为对应的请求方法。

func (*RouterOf[T]) ServeHTTP 

func (r *RouterOf[T]) ServeHTTP(w http.ResponseWriter, req *http.Request)

func (*RouterOf[T]) URL 

func (r *RouterOf[T]) URL(strict bool, pattern string, params map[string]string) (string, error)

URL 根据参数生成地址

strict 是否检查路由是否真实存在以及参数是否符合要求； pattern 为路由项的定义内容； params 为路由项中的参数，键名为参数名，键值为参数值。

func (*RouterOf[T]) Use added in v6.1.0 

func (r *RouterOf[T]) Use(m ...MiddlewareOf[T])

Use 添加全局中间件

type Routers 

type Routers = RoutersOf[http.Handler]

func NewRouters 

func NewRouters(notFound http.Handler) *Routers

type RoutersOf 

type RoutersOf[T any] struct {
	// contains filtered or unexported fields
}

RoutersOf 一组路由的集合

func NewRoutersOf 

func NewRoutersOf[T any](b CallOf[T], notFound http.Handler) *RoutersOf[T]

NewRoutersOf 声明一个新的 RoutersOf

notFound 表示所有路由都不匹配时的处理方式，如果为空，则调用 http.NotFoundHandler。

func (*RoutersOf[T]) Add 

func (rs *RoutersOf[T]) Add(matcher Matcher, r *RouterOf[T])

Add 添加路由

matcher 用于判断进入 r 的条件，如果为空，则表示不作判断。 如果有多个 matcher 都符合条件，第一个符合条件的 r 获得优胜；

func (*RoutersOf[T]) New 

func (rs *RoutersOf[T]) New(name string, matcher Matcher, o *Options) *RouterOf[T]

New 声明新路由

func (*RoutersOf[T]) Remove 

func (rs *RoutersOf[T]) Remove(name string)

func (*RoutersOf[T]) Router 

func (rs *RoutersOf[T]) Router(name string) *RouterOf[T]

Router 返回指定名称的路由

func (*RoutersOf[T]) Routers 

func (rs *RoutersOf[T]) Routers() []*RouterOf[T]

Routers 返回路由列表

func (*RoutersOf[T]) Routes 

func (rs *RoutersOf[T]) Routes() map[string]map[string][]string

func (*RoutersOf[T]) ServeHTTP 

func (rs *RoutersOf[T]) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*RoutersOf[T]) Use added in v6.2.0 

func (rs *RoutersOf[T]) Use(m ...MiddlewareOf[T])

Use 为所有已经注册的路由添加中间件

Source Files

View all Source files

Directories

Path Synopsis
internal
syntax
Package syntax 负责处理路由语法
 Package syntax 负责处理路由语法
tree
Package tree 提供了以树形结构保存路由项的相关操作
 Package tree 提供了以树形结构保存路由项的相关操作
Package muxutil 为 mux 提供的一些额外工具
 Package muxutil 为 mux 提供的一些额外工具
Package params 路由参数的相关声明
 Package params 路由参数的相关声明
Package routertest 提供针对路由的测试用例 NOTE: 只提供针对不同的类型参数 T 可能造成不周结果的测试。
 Package routertest 提供针对路由的测试用例 NOTE: 只提供针对不同的类型参数 T 可能造成不周结果的测试。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.