eudore

package module
Version: v0.0.0-...-b80422e Latest Latest
Warning

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

Go to latest
Published: Apr 30, 2022 License: MIT Imports: 40 Imported by: 8

README

Eudore

godoc go report card codecov

eudore是一个golang轻量级web框架核心,可以轻松扩展成一个技术栈专用框架,具有完整框架设计体系。

反馈和交流请加群组:QQ群373278915

Features

  • 易扩展:主要设计目标、核心全部解耦,接口即为逻辑。
  • 简单:对象语义明确,框架代码量少复杂度低,无依赖库。
  • 易用:允许Appcation和Context自由添加功能方法。
  • 高性能:各部分实现与同类库相比性能相似。
  • 两项创新:新Radix路由实现处理函数扩展机制

安装

eudore基于go version go1.10.1 linux/amd64下开发,运行依赖go1.9+版本。

go get -v -u github.com/eudore/eudore

文档

Documentation

Overview

Package eudore golang http framework, less is more.

source: https://github.com/eudore/eudore

document: https://www.eudore.cn

exapmle: https://github.com/eudore/eudore/tree/master/_example

wiki: https://github.com/eudore/eudore/wiki

godoc: https://godoc.org/github.com/eudore/eudore

godev: https://pkg.go.dev/github.com/eudore/eudore

Index

Constants

View Source
const (

	// EnvEudoreIsDaemon 用于表示是否fork后台启动。
	EnvEudoreIsDaemon = "EUDORE_IS_DEAMON"
	// EnvEudoreIsNotify 表示使用使用了Notify组件。
	EnvEudoreIsNotify = "EUDORE_IS_NOTIFY"
	// EnvEudoreDisablePidfile 用于Command组件不写入pidfile,Notify组件启动的子程序不写入pidfile。
	EnvEudoreDisablePidfile = "EUDORE_DISABLE_PIDFILE"

	StatusContinue           = 100 // RFC 7231, 6.2.1
	StatusSwitchingProtocols = 101 // RFC 7231, 6.2.2
	StatusProcessing         = 102 // RFC 2518, 10.1

	StatusOK                   = 200 // RFC 7231, 6.3.1
	StatusCreated              = 201 // RFC 7231, 6.3.2
	StatusAccepted             = 202 // RFC 7231, 6.3.3
	StatusNonAuthoritativeInfo = 203 // RFC 7231, 6.3.4
	StatusNoContent            = 204 // RFC 7231, 6.3.5
	StatusResetContent         = 205 // RFC 7231, 6.3.6
	StatusPartialContent       = 206 // RFC 7233, 4.1
	StatusMultiStatus          = 207 // RFC 4918, 11.1
	StatusAlreadyReported      = 208 // RFC 5842, 7.1
	StatusIMUsed               = 226 // RFC 3229, 10.4.1

	StatusMultipleChoices  = 300 // RFC 7231, 6.4.1
	StatusMovedPermanently = 301 // RFC 7231, 6.4.2
	StatusFound            = 302 // RFC 7231, 6.4.3
	StatusSeeOther         = 303 // RFC 7231, 6.4.4
	StatusNotModified      = 304 // RFC 7232, 4.1
	StatusUseProxy         = 305 // RFC 7231, 6.4.5

	StatusTemporaryRedirect = 307 // RFC 7231, 6.4.7
	StatusPermanentRedirect = 308 // RFC 7538, 3

	StatusBadRequest                   = 400 // RFC 7231, 6.5.1
	StatusUnauthorized                 = 401 // RFC 7235, 3.1
	StatusPaymentRequired              = 402 // RFC 7231, 6.5.2
	StatusForbidden                    = 403 // RFC 7231, 6.5.3
	StatusNotFound                     = 404 // RFC 7231, 6.5.4
	StatusMethodNotAllowed             = 405 // RFC 7231, 6.5.5
	StatusNotAcceptable                = 406 // RFC 7231, 6.5.6
	StatusProxyAuthRequired            = 407 // RFC 7235, 3.2
	StatusRequestTimeout               = 408 // RFC 7231, 6.5.7
	StatusConflict                     = 409 // RFC 7231, 6.5.8
	StatusGone                         = 410 // RFC 7231, 6.5.9
	StatusLengthRequired               = 411 // RFC 7231, 6.5.10
	StatusPreconditionFailed           = 412 // RFC 7232, 4.2
	StatusRequestEntityTooLarge        = 413 // RFC 7231, 6.5.11
	StatusRequestURITooLong            = 414 // RFC 7231, 6.5.12
	StatusUnsupportedMediaType         = 415 // RFC 7231, 6.5.13
	StatusRequestedRangeNotSatisfiable = 416 // RFC 7233, 4.4
	StatusExpectationFailed            = 417 // RFC 7231, 6.5.14
	StatusTeapot                       = 418 // RFC 7168, 2.3.3
	StatusMisdirectedRequest           = 421 // RFC 7540, 9.1.2
	StatusUnprocessableEntity          = 422 // RFC 4918, 11.2
	StatusLocked                       = 423 // RFC 4918, 11.3
	StatusFailedDependency             = 424 // RFC 4918, 11.4
	StatusTooEarly                     = 425 // RFC 8470, 5.2.
	StatusUpgradeRequired              = 426 // RFC 7231, 6.5.15
	StatusPreconditionRequired         = 428 // RFC 6585, 3
	StatusTooManyRequests              = 429 // RFC 6585, 4
	StatusRequestHeaderFieldsTooLarge  = 431 // RFC 6585, 5
	StatusUnavailableForLegalReasons   = 451 // RFC 7725, 3

	StatusInternalServerError           = 500 // RFC 7231, 6.6.1
	StatusNotImplemented                = 501 // RFC 7231, 6.6.2
	StatusBadGateway                    = 502 // RFC 7231, 6.6.3
	StatusServiceUnavailable            = 503 // RFC 7231, 6.6.4
	StatusGatewayTimeout                = 504 // RFC 7231, 6.6.5
	StatusHTTPVersionNotSupported       = 505 // RFC 7231, 6.6.6
	StatusVariantAlsoNegotiates         = 506 // RFC 2295, 8.1
	StatusInsufficientStorage           = 507 // RFC 4918, 11.5
	StatusLoopDetected                  = 508 // RFC 5842, 7.2
	StatusNotExtended                   = 510 // RFC 2774, 7
	StatusNetworkAuthenticationRequired = 511 // RFC 6585, 6

	HeaderAccept                          = "Accept"
	HeaderAcceptCharset                   = "Accept-Charset"
	HeaderAcceptEncoding                  = "Accept-Encoding"
	HeaderAcceptLanguage                  = "Accept-Language"
	HeaderAcceptRanges                    = "Accept-Ranges"
	HeaderAccessControlAllowCredentials   = "Access-Control-Allow-Credentials"
	HeaderAccessControlAllowHeaders       = "Access-Control-Allow-Headers"
	HeaderAccessControlAllowMethods       = "Access-Control-Allow-Methods"
	HeaderAccessControlAllowOrigin        = "Access-Control-Allow-Origin"
	HeaderAccessControlExposeHeaders      = "Access-Control-Expose-Headers"
	HeaderAccessControlMaxAge             = "Access-Control-Max-Age"
	HeaderAccessControlRequestHeaders     = "Access-Control-Request-Headers"
	HeaderAccessControlRequestMethod      = "Access-Control-Request-Method"
	HeaderAge                             = "Age"
	HeaderAllow                           = "Allow"
	HeaderAltSvc                          = "Alt-Svc"
	HeaderAuthorization                   = "Authorization"
	HeaderCacheControl                    = "Cache-Control"
	HeaderClearSiteData                   = "Clear-Site-Data"
	HeaderConnection                      = "Connection"
	HeaderContentDisposition              = "Content-Disposition"
	HeaderContentEncoding                 = "Content-Encoding"
	HeaderContentLanguage                 = "Content-Language"
	HeaderContentLength                   = "Content-Length"
	HeaderContentLocation                 = "Content-Location"
	HeaderContentRange                    = "Content-Range"
	HeaderContentSecurityPolicy           = "Content-Security-Policy"
	HeaderContentSecurityPolicyReportOnly = "Content-Security-Policy-Report-Only"
	HeaderContentType                     = "Content-Type"
	HeaderCookie                          = "Cookie"
	HeaderDate                            = "Date"
	HeaderETag                            = "Etag"
	HeaderEarlyData                       = "Early-Data"
	HeaderExpect                          = "Expect"
	HeaderExpectCT                        = "Expect-Ct"
	HeaderExpires                         = "Expires"
	HeaderFeaturePolicy                   = "Feature-Policy"
	HeaderForwarded                       = "Forwarded"
	HeaderFrom                            = "From"
	HeaderHost                            = "Host"
	HeaderIfMatch                         = "If-Match"
	HeaderIfModifiedSince                 = "If-Modified-Since"
	HeaderIfNoneMatch                     = "If-None-Match"
	HeaderIfRange                         = "If-Range"
	HeaderIfUnmodifiedSince               = "If-Unmodified-Since"
	HeaderIndex                           = "Index"
	HeaderKeepAlive                       = "Keep-Alive"
	HeaderLastModified                    = "Last-Modified"
	HeaderLocation                        = "Location"
	HeaderOrigin                          = "Origin"
	HeaderPragma                          = "Pragma"
	HeaderProxyAuthenticate               = "Proxy-Authenticate"
	HeaderProxyAuthorization              = "Proxy-Authorization"
	HeaderPublicKeyPins                   = "Public-Key-Pins"
	HeaderPublicKeyPinsReportOnly         = "Public-Key-Pins-Report-Only"
	HeaderRange                           = "Range"
	HeaderReferer                         = "Referer"
	HeaderReferrerPolicy                  = "Referrer-Policy"
	HeaderRetryAfter                      = "Retry-After"
	HeaderSecWebSocketAccept              = "Sec-WebSocket-Accept"
	HeaderServer                          = "Server"
	HeaderServerTiming                    = "Server-Timing"
	HeaderSetCookie                       = "Set-Cookie"
	HeaderSourceMap                       = "SourceMap"
	HeaderStrictTransportSecurity         = "Strict-Transport-Security"
	HeaderTE                              = "Te"
	HeaderTimingAllowOrigin               = "Timing-Allow-Origin"
	HeaderTk                              = "Tk"
	HeaderTrailer                         = "Trailer"
	HeaderTransferEncoding                = "Transfer-Encoding"
	HeaderUpgrade                         = "Upgrade"
	HeaderUpgradeInsecureRequests         = "Upgrade-Insecure-Requests"
	HeaderUserAgent                       = "User-Agent"
	HeaderVary                            = "Vary"
	HeaderVia                             = "Via"
	HeaderWWWAuthenticate                 = "Www-Authenticate"
	HeaderWarning                         = "Warning"
	HeaderXContentTypeOptions             = "X-Content-Type-Options"
	HeaderXCSRFToken                      = "X-Csrf-Token"
	HeaderXDNSPrefetchControl             = "X-Dns-Prefetch-Control"
	HeaderXForwardedFor                   = "X-Forwarded-For"
	HeaderXForwardedHost                  = "X-Forwarded-Host"
	HeaderXForwardedProto                 = "X-Forwarded-Proto"
	HeaderXFrameOptions                   = "X-Frame-Options"
	HeaderXXSSProtection                  = "X-Xss-Protection"
	HeaderXRealIP                         = "X-Real-Ip"
	HeaderXRequestID                      = "X-Request-Id"
	HeaderXTraceID                        = "X-Trace-Id"
	HeaderXEudoreAdmin                    = "X-Eudore-Admin"
	HeaderXMatchRoute                     = "X-Match-Route"

	MethodAny     = "ANY"
	MethodGet     = "GET"
	MethodPost    = "POST"
	MethodPut     = "PUT"
	MethodDelete  = "DELETE"
	MethodHead    = "HEAD"
	MethodPatch   = "PATCH"
	MethodOptions = "OPTIONS"
	MethodConnect = "CONNECT"
	MethodTrace   = "TRACE"

	MimeCharsetUtf8                = "charset=utf-8"
	MimeText                       = "text/*"
	MimeTextPlain                  = "text/plain"
	MimeTextPlainCharsetUtf8       = MimeTextPlain + "; " + MimeCharsetUtf8
	MimeTextHTML                   = "text/html"
	MimeTextHTMLCharsetUtf8        = MimeTextHTML + "; " + MimeCharsetUtf8
	MimeTextCSS                    = "text/css"
	MimeTextCSSUtf8                = MimeTextCSS + "; " + MimeCharsetUtf8
	MimeTextJavascript             = "text/javascript"
	MimeTextJavascriptUtf8         = MimeTextJavascript + "; " + MimeCharsetUtf8
	MimeTextMarkdown               = "text/markdown"
	MimeTextMarkdownUtf8           = MimeTextMarkdown + "; " + MimeCharsetUtf8
	MimeTextXML                    = "text/xml"
	MimeTextXMLCharsetUtf8         = MimeTextXML + "; " + MimeCharsetUtf8
	MimeApplicationJSON            = "application/json"
	MimeApplicationJSONUtf8        = MimeApplicationJSON + "; " + MimeCharsetUtf8
	MimeApplicationXML             = "application/xml"
	MimeApplicationxmlCharsetUtf8  = MimeApplicationXML + "; " + MimeCharsetUtf8
	MimeApplicationForm            = "application/x-www-form-urlencoded"
	MimeApplicationFormCharsetUtf8 = MimeApplicationForm + "; " + MimeCharsetUtf8
	MimeMultipartForm              = "multipart/form-data"

	ParamAction          = "action"
	ParamAllow           = "allow"
	ParamBasicAuth       = "basicauth"
	ParamCaller          = "caller"
	ParamControllerGroup = "controllergroup"
	ParamRegister        = "register"
	ParamTemplate        = "template"
	ParamRoute           = "route"
	ParamUserid          = "Userid"
	ParamPolicy          = "Policy"
	ParamResource        = "Resource"
)

定义eudore定义各种常量。

Variables

View Source
var (
	// ContextKeyApp 定义获取app的Key。
	ContextKeyApp = NewContextKey("app")
	// ContextKeyLogger 定义获取logger的Key。
	ContextKeyLogger = NewContextKey("logger")
	// ContextKeyConfig 定义获取config的Key。
	ContextKeyConfig = NewContextKey("config")
	// ContextKeyDatabase 定义获取database的Key。
	ContextKeyDatabase = NewContextKey("database")
	// ContextKeyClient 定义获取client的Key。
	ContextKeyClient = NewContextKey("client")
	// ContextKeyServer 定义获取server的Key。
	ContextKeyServer = NewContextKey("server")
	// ContextKeyRouter 定义获取router的Key。
	ContextKeyRouter = NewContextKey("router")
	// ContextKeyContextPool 定义获取context-pool的Key。
	ContextKeyContextPool = NewContextKey("context-pool")
	// ContextKeyError 定义获取error的Key。
	ContextKeyError = NewContextKey("error")
	// ContextKeyBind 定义获取bind的Key。
	ContextKeyBind = NewContextKey("bind")
	// ContextKeyValidate 定义获取validate的Key。
	ContextKeyValidate = NewContextKey("validate")
	// ContextKeyFilte 定义获取filte的Key。
	ContextKeyFilte = NewContextKey("filte")
	// ContextKeyRender 定义获取render的Key。
	ContextKeyRender = NewContextKey("render")
	// ContextKeyFuncCreator 定义获取func-creator的Key。
	ContextKeyFuncCreator = NewContextKey("func-creator")
	// ContextKeyTempldate 定义获取templdate的Key。
	ContextKeyTempldate = NewContextKey("templdate")

	// DefaultBodyMaxMemory 默认Body解析占用内存。
	DefaultBodyMaxMemory int64 = 32 << 20 // 32 MB
	// DefaultGetSetTags 定义Get/Set函数使用的默认tag。
	DefaultGetSetTags = []string{"alias"}
	// DefaultConvertTags 定义默认转换使用的结构体tags。
	DefaultConvertTags = []string{"alias"}
	// DefaultConvertFormTags 定义bind form使用tags。
	DefaultConvertFormTags = []string{"form", "alias"}
	// DefaultConvertURLTags 定义bind url使用tags。
	DefaultConvertURLTags = []string{"url", "alias"}
	// DefaultNewValidateFieldTag 定义NewValidateField获取校验规则的结构体tag。
	DefaultNewValidateFieldTag = "validate"
	// DefaultClientHost 定义ClientWarp默认使用的Host。
	DefaultClientHost = "localhost:80"
	// DefaultLoggerTimeFormat 定义默认日志输出和contextBase.WriteError的时间格式
	DefaultLoggerTimeFormat = "2006-01-02 15:04:05"
	// DefaulerServerShutdownWait 定义Server优雅退出等待时间。
	DefaulerServerShutdownWait = 30 * time.Second
	// DefaultRecoverDepth 定义GetPanicStack函数默认显示栈最大层数。
	DefaultRecoverDepth = 64
	// LogLevelString 定义日志级别输出字符串。
	LogLevelString = [5]string{"DEBUG", "INFO", "WARNING", "ERROR", "FATAL"}
	// RouterAllMethod 定义路由器允许注册的全部方法,注册其他方法别忽略,前六种方法始终存在。
	RouterAllMethod = []string{MethodGet, MethodPost, MethodPut, MethodDelete, MethodHead, MethodPatch, MethodOptions, MethodConnect, MethodTrace}
	// RouterAnyMethod 定义Any方法的注册使用的方法。
	RouterAnyMethod = []string{MethodGet, MethodPost, MethodPut, MethodDelete, MethodHead, MethodPatch}

	// ConfigAllParseFunc 定义ConfigMap和ConfigEudore默认使用的解析函数。
	ConfigAllParseFunc = []ConfigParseFunc{NewConfigParseJSON("config"), NewConfigParseArgs(nil), NewConfigParseEnvs("ENV_"), NewConfigParseWorkdir("workdir"), NewConfigParseHelp("help")}
	// DefaultFuncCreator 定义全局默认FuncCreator,RouetrCoreStd默认使用。
	DefaultFuncCreator = NewFuncCreator()
	// DefaultHandlerExtend 为默认的函数扩展处理者,是RouterStd使用的最顶级的函数扩展处理者。
	DefaultHandlerExtend = NewHandlerExtendBase()
	// DefaultLoggerNull 定义空日志输出器。
	DefaultLoggerNull = NewLoggerNull()
	// DefaultHandlerExtendAllowType 定义handlerExtendBase允许使用的参数类型。
	DefaultHandlerExtendAllowType = map[reflect.Kind]struct{}{
		reflect.Func:      {},
		reflect.Interface: {},
		reflect.Map:       {},
		reflect.Ptr:       {},
		reflect.Slice:     {},
		reflect.Struct:    {},
	}
)
View Source
var (
	// ErrApplicationStop 在app正常退出时返回。
	ErrApplicationStop = errors.New("stop application success")
	// ErrConverterInputDataNil 在Converter方法时,输出参数是空。
	ErrConverterInputDataNil = errors.New("Converter input value is nil")
	// ErrConverterInputDataNotPtr 在Converter方法时,输出参数是空。
	ErrConverterInputDataNotPtr = errors.New("Converter input value not is ptr")
	// ErrConverterTargetDataNil 在Converter方法时,目标参数是空。
	ErrConverterTargetDataNil = errors.New("Converter target data is nil")
	// ErrLoggerLevelUnmarshalText 日志级别解码错误,请检查输出的[]byte是否有效。
	ErrLoggerLevelUnmarshalText = errors.New("logger level UnmarshalText error")
	ErrRenderHandlerSkip        = errors.New("render hander skip")
	// ErrRegisterNewHandlerParamNotFunc 调用RegisterHandlerExtend函数时,参数必须是一个函数。
	ErrRegisterNewHandlerParamNotFunc = errors.New("The parameter type of RegisterNewHandler must be a function")
	// ErrResponseWriterHTTPNotHijacker ResponseWriterHTTP对象没有实现http.Hijacker接口。
	ErrResponseWriterHTTPNotHijacker = errors.New("http.Hijacker interface is not supported")
	// ErrSeterNotSupportField Seter对象不支持设置当前属性。
	ErrSeterNotSupportField = errors.New("Converter seter not support set field")
	// ErrMiddlewareRequestEntityTooLarge middleware/BodyLimit 分段请求body读取时限制长队返回错误。
	ErrMiddlewareRequestEntityTooLarge = errors.New("Request Entity Too Large")

	// ErrFormatBindDefaultNotSupportContentType BindDefault函数不支持当前的Content-Type Header。
	ErrFormatBindDefaultNotSupportContentType = "BindDefault not support content type header: %s"
	// ErrFormatConverterGet 在Get方法路径查找返回错误。
	ErrFormatConverterGet = "Get path '%s' error: %s"
	// ErrFormatConverterNotCanset 在Set方法时,结构体不支持该项属性。
	ErrFormatConverterNotCanset = "The attribute '%s' of structure %s is not set, please use public field"
	// ErrFormatConverterSetArrayIndexInvalid 在Set方法时,设置数组的索引的无效
	ErrFormatConverterSetArrayIndexInvalid = "the Set function obtained array index '%s' is invalid, array len is %d"
	// ErrFormatConverterSetStringUnknownType setWithString函数遇到未定义的反射类型
	ErrFormatConverterSetStringUnknownType = "setWithString unknown type %s"
	// ErrFormatConverterSetStructNotField 在Set时,结构体没有当前属性。
	ErrFormatConverterSetStructNotField = "Setting the structure has no attribute '%s', or this attribute is not exportable"
	// ErrFormatConverterSetTypeError 在Set时,类型异常,无法继续设置值。
	ErrFormatConverterSetTypeError = "The type of the set value is %s, which is not configurable, key: %v, val: %s"
	// ErrFormatConverterSetWithValue setWithValue函数中类型无法赋值。
	ErrFormatConverterSetWithValue = "The setWithValue method type %s cannot be assigned to type %s"
	// ErrFormatRegisterHandlerExtendInputParamError RegisterHandlerExtend函数注册的函数参数错误。
	ErrFormatRegisterHandlerExtendInputParamError = "The '%s' input parameter is illegal and should be one func/interface/ptr/struct"
	// ErrFormatRegisterHandlerExtendOutputParamError RegisterHandlerExtend函数注册的函数返回值错误。
	ErrFormatRegisterHandlerExtendOutputParamError = "The '%s' output parameter is illegal and should be a HandlerFunc object"
	// ErrFormatRouterStdAddController RouterStd控制器路由注入错误
	ErrFormatRouterStdAddController = "The RouterStd.AddController Inject %s error: %v"
	// ErrFormatRouterStdAddHandlerExtend RouterStd添加扩展错误
	ErrFormatRouterStdAddHandlerExtend = "The RouterStd.AddHandlerExtend path is '%s' RegisterHandlerExtend error: %v"
	// ErrFormatRouterStdRegisterHandlersMethodInvalid RouterStd.registerHandlers 的添加的是无效的,全部有效方法为RouterAnyMethod。
	ErrFormatRouterStdRegisterHandlersMethodInvalid = "The RouterStd.registerHandlers arg method '%s' is invalid, complete method: '%s', add fullpath: '%s'"
	// ErrFormatRouterStdRegisterHandlersRecover RouterStd出现panic。
	ErrFormatRouterStdRegisterHandlersRecover = "The RouterStd.registerHandlers arg method is '%s' and path is '%s', recover error: %v"
	// ErrFormatRouterStdNewHandlerFuncsUnregisterType RouterStd添加处理对象或中间件的第n个参数类型未注册,需要先使用RegisterHandlerExtend或AddHandlerExtend注册该函数类型。
	ErrFormatRouterStdNewHandlerFuncsUnregisterType = "The RouterStd.newHandlerFuncs path is '%s', %dth handler parameter type is '%s', this is the unregistered handler type"

	ErrFormarRouterStdLoadInvalidFunc       = "loadCheckFunc path is invalid, load path '%s' error: %v "
	ErrFormatParseValidateFieldError        = "validateField %s.%s parse field %s create rule %s error: %s"
	ErrFormatFuncCreatorRegisterInvalidType = "Register func %s type is %T, must 'func(T) bool' or 'func(string) (func(T) bool, error)'"
	ErrFormatFuncCreatorNotFunc             = "not found or create func %s"
)

定义默认错误

View Source
var DefaultEmbedTime time.Time

EmbedTime 设置http返回embed文件的最后修改时间,使用http 304缓冲,默认为服务启动时间。

如果服务存在多副本部署,通过设置相同的值保持多副本间的版本一样。

Functions

func BindForm

func BindForm(ctx Context, i interface{}) error

BindForm 函数使用form格式body实现bind。

func BindHeader

func BindHeader(ctx Context, i interface{}) error

BindHeader 函数实现使用header数据bind。

func BindJSON

func BindJSON(ctx Context, i interface{}) error

BindJSON 函数使用json格式body实现bind。

func BindURL

func BindURL(ctx Context, i interface{}) error

BindURL 函数使用url参数实现bind。

func BindXML

func BindXML(ctx Context, i interface{}) error

BindXML 函数使用xml格式body实现bind。

func ControllerInjectAutoRoute

func ControllerInjectAutoRoute(controller Controller, router Router) error

ControllerInjectAutoRoute function generates routing rules based on the controller rules, and the usage method is converted into a processing function to support routers.

Routing group: If the'ControllerGroup(string) string' method is implemented, the routing group is returned; if the routing parameter ParamControllerGroup is included, it is used; otherwise, the controller name is used to turn the path.

Routing path: Convert the method with the request method as the prefix to the routing method and path, and then use the map[method]path returned by the'ControllerRoute() map[string]string' method to overwrite the routing path.

Method conversion rules: The method prefix must be a valid request method (within RouterAllMethod), the remaining path is converted to a path, ByName is converted to variable matching/:name, and the last By of the method path is converted to /*; The return path of ControllerRoute is'-' and the method is ignored. The first character is”, which means it is a path append parameter.

Routing parameters: If you implement the'ControllerParam(string, string, string) string' method to return routing parameters, otherwise use "controllername=%s.%s controllermethod=%s".

Controller combination: If the controller combines other objects, only the methods of the object whose name suffix is ​​Controller are reserved, and other methods with embedded properties will be ignored.

ControllerInjectAutoRoute 函数基于控制器规则生成路由规则,使用方法转换成处理函数支持路由器。

路由组: 如果实现'ControllerGroup(string) string'方法返回路由组;如果包含路由参数ParamControllerGroup则使用;否则使用控制器名称驼峰转路径。

路由路径: 将请求方法为前缀的方法转换成路由方法和路径,然后使用'ControllerRoute() map[string]string'方法返回的map[method]path覆盖路由路径。

方法转换规则: 方法前缀必须是有效的请求方法(RouterAllMethod之内),剩余路径驼峰转路径,ByName转换成变量匹配/:name,方法路径最后一个By转换成/*; ControllerRoute返回路径为'-'则忽略方法,第一个字符为' '表示为路径追加参数。

路由参数: 如果实现'ControllerParam(string, string, string) string'方法返回路由参数,否则使用"controllername=%s.%s controllermethod=%s"。

控制器组合: 如果控制器组合了其他对象,仅保留名称后缀为Controller的对象的方法,其他嵌入属性的方法将被忽略。

func ConvertMap

func ConvertMap(i interface{}) map[interface{}]interface{}

ConvertMap 函数将一个map或struct转换成map[interface{}]interface{}。

func ConvertMapString

func ConvertMapString(i interface{}) map[string]interface{}

ConvertMapString 函数将一个map或struct转换成map[string]interface{}。

func ConvertMapStringWithTags

func ConvertMapStringWithTags(i interface{}, tags []string) map[string]interface{}

ConvertMapStringWithTags 函数与ConvertMapString相同,允许使用额外的tags。

func ConvertMapWithTags

func ConvertMapWithTags(i interface{}, tags []string) map[interface{}]interface{}

ConvertMapWithTags 函数与ConvertMap相同,允许使用额外的tags。

func ConvertTo

func ConvertTo(source interface{}, target interface{}) error

ConvertTo 将一个对象属性复制给另外一个对象,可转换对象属性会覆盖原值。

func ConvertToWithTags

func ConvertToWithTags(source interface{}, target interface{}, tags []string) error

ConvertToWithTags 函数与ConvertTo相同,允许使用额外的tags。

func Get

func Get(i interface{}, key string) interface{}

Get method A more path to get an attribute from an object.

The path will be split using '.' and then look for the path in turn.

Structure attributes can use the structure tag 'alias' to match attributes.

Returns a null value if the match fails.

根据路径来从一个对象获得一个属性。

路径将使用'.'分割,然后依次寻找路径。

结构体属性可以使用结构体标签'alias'来匹配属性。

如果匹配失败直接返回空值。

func GetBool

func GetBool(i interface{}) bool

GetBool 函数转换bool、int、uint、float、string成bool。

func GetBytes

func GetBytes(i interface{}) []byte

GetBytes 方法断言[]byte类型或使用GetString方法转换成string类型

func GetFloat32

func GetFloat32(i interface{}, nums ...float32) float32

GetFloat32 函数转换一个bool、int、uint、float、string类型成float32,或者返回第一个非零值。

func GetFloat64

func GetFloat64(i interface{}, nums ...float64) float64

GetFloat64 函数转换一个bool、int、uint、float、string类型成float64,或者返回第一个非零值。

func GetInt

func GetInt(i interface{}, nums ...int) int

GetInt 函数转换一个bool、int、uint、float、string类型成int,或者返回第一个非零值。

func GetInt64

func GetInt64(i interface{}, nums ...int64) int64

GetInt64 函数转换一个bool、int、uint、float、string类型成int64,或者返回第一个非零值。

func GetPanicStack

func GetPanicStack(depth int) []string

GetPanicStack 函数返回panic栈信息。

func GetString

func GetString(i interface{}, strs ...string) string

GetString 方法转换一个bool、int、uint、float、string成string类型,或者返回第一个非零值,如果参数类型是string必须是非空才会作为返回值。

func GetStringBool

func GetStringBool(str string) bool

GetStringBool 使用strconv.ParseBool解析。

func GetStringFloat32

func GetStringFloat32(str string, nums ...float32) float32

GetStringFloat32 使用strconv.ParseFloa解析数据,如果解析返回错误使用第一个第一个非零值。

func GetStringFloat64

func GetStringFloat64(str string, nums ...float64) float64

GetStringFloat64 使用strconv.ParseFloa解析数据,如果解析返回错误使用第一个第一个非零值。

func GetStringInt

func GetStringInt(str string, nums ...int) int

GetStringInt 使用strconv.Atoi解析返回数据,如果解析返回错误使用第一个非零值。

func GetStringInt64

func GetStringInt64(str string, nums ...int64) int64

GetStringInt64 使用strconv.ParseInt解析返回数据,如果解析返回错误使用第一个非零值。

func GetStringUint

func GetStringUint(str string, nums ...uint) uint

GetStringUint 使用strconv.ParseUint解析返回数据,如果解析返回错误使用第一个非零值。

func GetStringUint64

func GetStringUint64(str string, nums ...uint64) uint64

GetStringUint64 使用strconv.ParseUint解析返回数据,如果解析返回错误使用第一个非零值。

func GetStrings

func GetStrings(i interface{}) []string

GetStrings 转换string、[]strng、[]interface{}成[]string。

func GetUint

func GetUint(i interface{}, nums ...uint) uint

GetUint 函数转换一个bool、int、uint、float、string类型成uint,或者返回第一个非零值。

func GetUint64

func GetUint64(i interface{}, nums ...uint64) uint64

GetUint64 函数转换一个bool、int、uint、float、string类型成uint64,或者返回第一个非零值。

func GetWithTags

func GetWithTags(i interface{}, key string, tags []string, all bool) (interface{}, error)

GetWithTags 函数和Get函数相同,可以额外设置tags,同时会返回error。

func GetWithValue

func GetWithValue(i interface{}, key string, tags []string, all bool) (reflect.Value, error)

GetWithValue 函数和Get函数相同,可以允许查找私有属性并返回reflect.Value。

func HandlerEmpty

func HandlerEmpty(Context)

HandlerEmpty 函数定义一个空的请求上下文处理函数。

func HandlerRouter404

func HandlerRouter404(ctx Context)

HandlerRouter404 function defines the default 404 processing.

HandlerRouter404 函数定义默认404处理。

func HandlerRouter405

func HandlerRouter405(ctx Context)

HandlerRouter405 function defines the default 405 processing and returns Allow and X-Match-Route Header.

HandlerRouter405 函数定义默认405处理,返回Allow和X-Match-Route Header。

func NewContextBaseFunc

func NewContextBaseFunc(ctx context.Context) func() Context

NewContextBaseFunc 函数使用context.Context创建Context构造函数,用于获取自定义Context。

func NewContextBasePool

func NewContextBasePool(ctx context.Context) *sync.Pool

NewContextBasePool 函数从上下文创建一个Context sync.Pool。

需要从上下文加载ContextKeyApp实现Logger Database Client接口。

ContextBase相关方法文档点击NewContextBase函数跳转到源码查看。

func NewContextKey

func NewContextKey(key string) interface{}

NewContextKey 定义context key。

func NewErrorCode

func NewErrorCode(err error, code int) error

NewErrorCode 封装error实现Code方法。

func NewErrorStatus

func NewErrorStatus(err error, status int) error

NewErrorStatus 封装error实现Status方法。

func NewPrintFunc

func NewPrintFunc(log Logger) func(...interface{})

NewPrintFunc 函数使用Logger创建一个输出函数。

如果第一个参数Fields类型,则调用WithFields方法。

如果参数是一个error则输出error级别日志,否在输出info级别日志。

func RenderHTML

func RenderHTML(ctx Context, data interface{}) error

RenderHTML 函数使用模板创建一个模板Renderer。

从ctx.Value(eudore.ContextKeyTempldate)加载*template.Template, 从ctx.GetParam("template")加载模板函数。

func RenderJSON

func RenderJSON(ctx Context, data interface{}) error

RenderJSON 函数使用encoding/json库实现json反序列化。

如果请求Accept不为"application/json",使用json indent格式输出。

func RenderText

func RenderText(ctx Context, data interface{}) error

RenderText 函数Render Text,使用fmt.Fprint函数写入。

func RenderXML

func RenderXML(ctx Context, data interface{}) error

RenderXML 函数Render Xml,使用encoding/xml库实现xml反序列化。

func Set

func Set(i interface{}, key string, val interface{}) error

Set the properties of an object. The object must be a pointer type. If the target implements the Seter interface, the Set method is called.

The path will be split using '.' and then look for the path in turn.

When the object type selected in the path is ptr, it will check if it is empty. If the object is empty, it will be initialized by default.

When the object type selected in the path is interface{}, if the object is empty, it will be initialized to map[string]interface{}, otherwise the value will be judged according to the value type.

When the object type selected in the path is array, the path is converted to an object index to set the array element. If it cannot be converted, the element is appended.

When the object type in the path is selected as a struct, the attribute name and the attribute tag 'alias' are used to match when selecting the attribute.

If the type of the value is a string, it will be converted according to the target type set.

If the target type is a string, the value is output as a string and then assigned.

If the target type is an array, map, or struct, the json deserializes the set object.

If the target type passed in is an array, map, or struct, the json deserializes the set object.

设置一个对象的属性,改对象必须是指针类型,如果目标实现Seter接口,调用Set方法。

路径将使用'.'分割,然后依次寻找路径。

当路径中选择对象类型为ptr时,会检查是否为空,对象为空会默认进行初始化。

当路径中选择对象类型为interface{}时,如果对象为空会初始化为map[string]interface{},否则按值类型来判断下一步操作。

当路径中选择对象类型为array时,路径会转换成对象索引来设置数组元素,无法转换则追加元素。

当路径中选择对象类型为struct时,选择属性时会使用属性名称和属性标签'alias'来匹配。

如果值的类型是字符串,会根据设置的目标类型来转换。

如果目标类型是字符串,将会值输出成字符串然后赋值。

如果目标类型是数组、map、结构体,会使用json反序列化设置对象。

如果传入的目标类型是数组、map、结构体,会使用json反序列化设置对象。

func SetHandlerAliasName

func SetHandlerAliasName(i interface{}, name string)

SetHandlerAliasName 函数设置一个函数处理对象原始名称,如果扩展未生成名称,使用此值。

在handlerExtendBase对象和ControllerInjectSingleton函数中使用到,用于传递控制器函数名称。

func SetHandlerFuncName

func SetHandlerFuncName(i HandlerFunc, name string)

SetHandlerFuncName function sets the name of a request context handler.

Note: functions are not comparable, the method names of objects are overwritten by other method names.

SetHandlerFuncName 函数设置一个请求上下文处理函数的名称。

注意:函数不具有可比性,对象的方法的名称会被其他方法名称覆盖。

func SetWithTags

func SetWithTags(i interface{}, key string, val interface{}, tags []string, all bool) error

SetWithTags 函数和Set函数相同,可以额外设置tags。

Types

type App

type App struct {
	context.Context    `alias:"context"`
	context.CancelFunc `alias:"cancelfunc"`
	Logger             `alias:"logger"`
	Config             `alias:"config"`
	Database           `alias:"database"`
	Client             `alias:"client"`
	Server             `alias:"server"`
	Router             `alias:"router"`
	GetWarp            `alias:"getwarp"`
	HandlerFuncs       HandlerFuncs `alias:"handlerfuncs"`
	ContextPool        *sync.Pool   `alias:"contextpool"`
	CancelError        error        `alias:"cancelerror"`

	Values []interface{}
	// contains filtered or unexported fields
}

App combines the main functional interfaces and only implements simple basic methods.

The following functions are realized in addition to the functions of the combined components:

Global middleware
Start port monitoring
Block running service
Get configuration value and convert type

App 组合主要功能接口,本身仅实现简单的基本方法。

组合各组件功能外实现下列功能:

全局中间件
启动端口监听
阻塞运行服务
获取配置值并转换类型

func NewApp

func NewApp() *App

NewApp function creates an App object.

NewApp 函数创建一个App对象。

func (*App) AddMiddleware

func (app *App) AddMiddleware(hs ...interface{}) error

AddMiddleware If the first parameter of the AddMiddleware method is the string "global", it will be added to the App as a global request middleware (using DefaultHandlerExtend to create a request processing function), otherwise it is equivalent to calling the app.Rputer.AddMiddleware method.

AddMiddleware 方法如果第一个参数为字符串"global",则作为全局请求中间件添加给App(使用DefaultHandlerExtend创建请求处理函数), 否则等同于调用app.Rputer.AddMiddleware方法。

func (*App) Err

func (app *App) Err() error

Err method returns an error at the end of the App Context.

Err 方法返回App Context结束时错误。

func (*App) Listen

func (app *App) Listen(addr string) error

Listen method listens to an http port.

Listen 方法监听一个http端口。

func (*App) ListenTLS

func (app *App) ListenTLS(addr, key, cert string) error

ListenTLS method listens to an https port, if h2 is enabled by default.

ListenTLS 方法监听一个https端口,如果默认开启h2。

func (*App) Run

func (app *App) Run() error

Run method starts the App to block and wait for the App to end.

Run 方法启动App阻塞等待App结束。

func (*App) Serve

func (app *App) Serve(ln net.Listener)

Serve method starts a Server monitor non-blocking, and uses the app to process the monitor and return an error.

Serve 方法非阻塞启动一个Server监听,并使用app处理监听结束返回错误。

func (*App) ServeHTTP

func (app *App) ServeHTTP(w http.ResponseWriter, r *http.Request)

The ServeHTTP method implements the http.Handler interface to process http requests.

Create and initialize a Context, then set app.HandlerFuncs as the handler of the Context to handle the global middleware chain. When app.HandlerFuncs is processed for the last time, the app.serveContext method is called, and the route of this request is matched using app.Router The middleware and routing processing functions perform secondary request processing.

ServeHTTP 方法实现http.Handler接口,处理http请求。

创建并初始化一个Context,然后设置app.HandlerFuncs为Context的处理者处理全局中间件链, 在app.HandlerFuncs最后一次处理时,调用了app.serveContext方法,使用app.Router匹配出这个请求的路由中间件和路由处理函数进行二次请求处理。

func (*App) SetValue

func (app *App) SetValue(key, val interface{})

SetValue method sets the specified key value from the App. If the value implements the Mount/Unmount method, this method is automatically called when setting and unsetting.

SetValue 方法从App设置指定键值,如果值实现Mount/Unmount方法在设置和取消设置时自动调用该方法。

func (*App) Value

func (app *App) Value(key interface{}) interface{}

Value method gets the specified key value from the App.

Value 方法从App获取指定键值。

type Client

type Client interface {
	Do(*http.Request) (*http.Response, error)
}

Client 定义http协议客户端。

使用http.Handler处理请求
构建json form
httptrace

func NewClientStd

func NewClientStd(options ...interface{}) Client

NewClientStd 函数创建一个net/http.Client。

如果DialContext的host为DefaultClientHost,上下文获取ContextKeyServer实现ServeConn方法会使用net.Pipe连接。

type ClientWarp

type ClientWarp struct {
	Client  `alias:"client" json:"client"`
	Context context.Context `alias:"context" json:"context"`
	Querys  url.Values      `alias:"querys" json:"querys"`
	Headers http.Header     `alias:"headers" json:"headers"`
	Cookies http.CookieJar  `alias:"cookies" json:"cookies"`
}

ClientWarp 定义http客户端包装方法

func NewClientWarp

func NewClientWarp(options ...interface{}) *ClientWarp

NewClientWarp 函数创建ClientWarp对象,提供http请求创建方法。

func (*ClientWarp) AddBasicAuth

func (client *ClientWarp) AddBasicAuth(name, pass string)

AddBasicAuth 方法给客户端添加Basic Auth信息。

func (*ClientWarp) AddCookie

func (client *ClientWarp) AddCookie(host, key, val string)

AddCookie 方法给指定host下添加cookie。

func (*ClientWarp) AddHeader

func (client *ClientWarp) AddHeader(key, val string)

AddHeader 方法给客户端增加Header,客户端发起每个请求都会附加Header。

func (*ClientWarp) AddHeaders

func (client *ClientWarp) AddHeaders(headers http.Header)

AddHeaders 方法给客户端增加Header,客户端发起每个请求都会附加Header。

func (*ClientWarp) AddQuery

func (client *ClientWarp) AddQuery(key, val string)

AddQuery 方法给客户端增加请求参数,客户端发起每个请求都会附加参数。

func (*ClientWarp) AddQuerys

func (client *ClientWarp) AddQuerys(querys url.Values)

AddQuerys 方法给客户端增加请求参数,客户端发起每个请求都会附加参数。

func (*ClientWarp) GetCookie

func (client *ClientWarp) GetCookie(host, key string) string

GetCookie 方法读取指定host的cookie。

func (*ClientWarp) Mount

func (client *ClientWarp) Mount(ctx context.Context)

Mount 方法保存context.Context作为Client默认发起请求的context.Context

func (*ClientWarp) NewRequest

func (client *ClientWarp) NewRequest(method string, path string) *RequestWriterWarp

NewRequest 方法从客户端创建http请求。

如果schme为空默认为http,如果host为空默认为eudore.DefaultClientHost(go1.9 运行将异常阻塞)

type Config

type Config interface {
	Get(string) interface{}
	Set(string, interface{}) error
	ParseOption([]ConfigParseFunc) []ConfigParseFunc
	Parse() error
}

Config defines configuration management and uses configuration read-write and analysis functions.

Get/Set read and write data implementation:

Use custom map or struct as data storage
Support Lock concurrency safety
Access attributes based on string path hierarchy

The default analysis function implementation:

Custom configuration analysis function
Parse multiple json files
Parse the length and short parameters of the command line
Parse Env environment variables
Switch working directory
Generate help information based on the structure

Config 定义配置管理,使用配置读写和解析功能。

Get/Set读写数据实现下列功能:

使用自定义map或struct作为数据存储
支持Lock并发安全
基于字符串路径层次访问属性

默认解析函数实现下列功能:

自定义配置解析函数
解析多json文件
解析命令行长短参数
解析Env环境变量
切换工作目录
根据结构体生成帮助信息

func NewConfigMap

func NewConfigMap(arg interface{}) Config

NewConfigMap creates a ConfigMap, if the input parameter is map[string]interface{}, it will be used as the initialization data.

ConfigMap will use the passed map as configuration storage to Get/Set a key value.

ConfigMap has implemented json.Marshaler and json.Unmarshaler interfaces.

NewConfigMap 创建一个ConfigMap,如果传入参数为map[string]interface{},则作为初始化数据。

ConfigMap将使用传入的map作为配置存储去Get/Set一个键值。

ConfigMap已实现json.Marshaler和json.Unmarshaler接口.

func NewConfigStd

func NewConfigStd(i interface{}) Config

NewConfigStd creates a ConfigStd. If the input parameter is empty, use an empty map[string]interface{} as the initialization data.

ConfigEduoew allows to pass in a map or struct as configuration storage, and use eudore.Set and eudore.Get methods to read and write data.

If the incoming configuration object implements the same read-write lock method as sync.RLock, the configured read-write lock is used, otherwise a sync.RWMutex lock will be created.

ConfigEduoe has implemented the json.Marshaler and json.Unmarshaler interfaces.

NewConfigStd 创建一个ConfigStd,如果传入参数为空,使用空map[string]interface{}作为初始化数据。

ConfigEduoew允许传入一个map或struct作为配置存储,使用eudore.Set和eudore.Get方法去读写数据。

如果传入的配置对象实现sync.RLock一样的读写锁方法,则使用配置的读写锁,否则会创建一个sync.RWMutex锁。

ConfigEduoe已实现json.Marshaler和json.Unmarshaler接口.

type ConfigParseFunc

type ConfigParseFunc func(Config) error

ConfigParseFunc 定义配置解析函数。

Config 默认解析函数为eudore.ConfigAllParseFunc

func NewConfigParseArgs

func NewConfigParseArgs(shortsmap map[string][]string) ConfigParseFunc

NewConfigParseArgs function uses the eudore.Set method to set the command line parameter data, and the command line parameter uses the format of'--{key}.{sub}={value}'.

Shortsmap is mapped as a short parameter. If the structure has a'flag' tag, it will be used as the abbreviation of the path. The tag length must be less than 5, the command line format is'-{short}={value}, and the short parameter will automatically be long parameter.

NewConfigParseArgs 函数使用eudore.Set方法设置命令行参数数据,命令行参数使用'--{key}.{sub}={value}'格式。

shortsmap作为短参数映射,如果结构体存在'flag' tag将作为该路径的缩写,tag长度需要小于5,命令行格式为'-{short}={value},短参数将会自动为长参数。

func NewConfigParseEnvs

func NewConfigParseEnvs(key string) ConfigParseFunc

NewConfigParseEnvs function uses the eudore.Set method to set the environment variable data, usually the environment variable prefix uses'ENV_'.

Environment variables will be converted to lowercase paths, and the underscore of'_' is equivalent to the function of'.'.

NewConfigParseEnvs 函数使用eudore.Set方法设置环境变量数据,通常环境变量前缀使用'ENV_'。

环境变量将转换成小写路径,'_'下划线相当于'.'的作用

exmapel: 'ENV_EUDORE_NAME=eudore' => 'eudore.name=eudore'。

func NewConfigParseHelp

func NewConfigParseHelp(key string) ConfigParseFunc

NewConfigParseHelp function if uses the structure configuration to output the'flag' and'description' tags to produce the default parameter description.

By default, only the parameter description is output. For other descriptions, please wrap the NewConfigParseHelp method.

Note that the properties of the configuration structure need to be non-empty, otherwise it will not enter the traversal.

NewConfigParseHelp 函数如果使用结构体配置输出'flag'和'description' tag生产默认参数描述。

默认仅输出参数描述,其他描述内容请包装NewConfigParseHelp方法。

注意配置结构体的属性需要是非空,否则不会进入遍历。

func NewConfigParseJSON

func NewConfigParseJSON(key string) ConfigParseFunc

NewConfigParseJSON method parses the json file configuration, usually the key is "config".

The configuration item value is string(';' divided into multiple paths) or []string, if the loaded file does not exist, the file will be ignored.

NewConfigParseJSON 方法解析json文件配置,通常使用key为"config"。

配置项值为string(';'分割为多路径)或[]string,如果加载文件不存在将忽略文件。

func NewConfigParseWorkdir

func NewConfigParseWorkdir(key string) ConfigParseFunc

NewConfigParseWorkdir function initializes the workspace, usually using the key as string("workdir") to obtain the workspace directory and switch.

NewConfigParseWorkdir 函数初始化工作空间,通常使用key为string("workdir"),获取工作空间目录并切换。

type Context

type Context interface {
	// context
	Reset(http.ResponseWriter, *http.Request)
	GetContext() context.Context
	Request() *http.Request
	Response() ResponseWriter
	Value(interface{}) interface{}
	SetContext(context.Context)
	SetRequest(*http.Request)
	SetResponse(ResponseWriter)
	SetValue(interface{}, interface{})
	// handles
	SetHandler(int, HandlerFuncs)
	GetHandler() (int, HandlerFuncs)
	Next()
	End()
	Err() error

	// request info
	Read([]byte) (int, error)
	Host() string
	Method() string
	Path() string
	RealIP() string
	RequestID() string
	ContentType() string
	Istls() bool
	Body() []byte
	Bind(interface{}) error

	// param query header cookie form
	Params() *Params
	GetParam(string) string
	SetParam(string, string)
	Querys() url.Values
	GetQuery(string) string
	GetHeader(string) string
	SetHeader(string, string)
	Cookies() []Cookie
	GetCookie(string) string
	SetCookie(*SetCookie)
	SetCookieValue(string, string, int)
	FormValue(string) string
	FormValues() map[string][]string
	FormFile(string) *multipart.FileHeader
	FormFiles() map[string][]*multipart.FileHeader

	// response
	Write([]byte) (int, error)
	WriteHeader(int)
	Redirect(int, string)
	Push(string, *http.PushOptions) error
	Render(interface{}) error
	WriteString(string) error
	WriteJSON(interface{}) error
	WriteFile(string) error
	WriteError(error)

	// log Logger interface
	Debug(...interface{})
	Info(...interface{})
	Warning(...interface{})
	Error(...interface{})
	Fatal(...interface{})
	Debugf(string, ...interface{})
	Infof(string, ...interface{})
	Warningf(string, ...interface{})
	Errorf(string, ...interface{})
	Fatalf(string, ...interface{})
	WithField(string, interface{}) Logger
	WithFields([]string, []interface{}) Logger
}

Context 定义请求上下文接口,分为请求上下文数据、请求、参数、响应、日志输出五部分。

context.Context、eudore.ResponseWriter、*http.Request、eudore.Logger对象读写
中间件机制执行
基本请求信息
数据Bind和Validate
重复读取请求body
param、query、header、cookie、form读写
状态码、header、重定向、push、body写入
数据写入Render
5级日志格带fields格式化属性

type Controller

type Controller interface {
	Inject(Controller, Router) error
}

Controller defines the controller interface.

The default AutoRoute controller implements the following functions:

The controller method maps the route method path.
Controller construction error delivery (NewControllerError)
Custom controller function mapping relationship (implement func ControllerRoute() map[string]string)
Custom controller routing group and routing parameters (implement func ControllerParam(pkg, name, method string) string)
Controller routing combination, if a controller named xxxController is combined, the routing method of the xxx controller will be combined
Controller method combination, if you combine a controller with a name other than xxxController, you can directly call the method in the controller property ctl.xxx.

Controller 定义控制器接口。

默认AutoRoute控制器实现下列功能:

控制器方法映射路由方法路径。
控制器构造错误传递(NewControllerError)
自定义控制器函数映射关系(实现func ControllerRoute() map[string]string)
自定义控制器路由组和路由参数(实现func ControllerParam(pkg, name, method string) string)
控制器路由组合,如果组合一个名称为xxxController控制器,会组合获得xxx控制器的路由方法
控制器方法组合,如果组合一个名称非xxxController控制器,可以控制器属性ctl.xxx直接调用方法。

func NewControllerError

func NewControllerError(ctl Controller, err error) Controller

NewControllerError function returns a controller error, and the corresponding error is returned when the controller Inject.

NewControllerError 函数返回一个控制器错误,在控制器Inject时返回对应的错误。

type ControllerAutoRoute

type ControllerAutoRoute struct{}

The ControllerAutoRoute implements the routing mapping controller to register the corresponding router method according to the method.

ControllerAutoRoute 实现路由映射控制器根据方法注册对应的路由器方法。

func (*ControllerAutoRoute) Inject

func (ctl *ControllerAutoRoute) Inject(controller Controller, router Router) error

Inject method implements the method of injecting the controller into the router, and the ControllerAutoRoute controller calls the ControllerInjectAutoRoute method to inject.

Inject 方法实现控制器注入到路由器的方法,ControllerAutoRoute控制器调用ControllerInjectAutoRoute方法注入。

type Cookie struct {
	Name  string
	Value string
}

Cookie 定义请求读取的cookie header的键值对数据存储

type Database

type Database interface {
	WithContext(context.Context) Database
	AddHook(interface{})
	AutoMigrate(interface{}) error
	Query(interface{}, Stmt) error
	Exec(Stmt) error
}

Database 定义数据库操作方法

func NewDatabaseStd

func NewDatabaseStd(config interface{}) Database

NewDatabaseStd 方法创建一个空Database。

type DatabaseContext

type DatabaseContext interface {
	Context() context.Context
	WriteString(string)
	WriteValue(interface{})
	WriteStmt(Stmt)
}

DatabaseContext 定义数据上下文

type FuncCreator

type FuncCreator interface {
	Register(string, ...interface{}) error
	Create(reflect.Type, string) (interface{}, error)
}

FuncCreator 定义校验函数构造器,默认由RouterStd和validateField使用。

func NewFuncCreator

func NewFuncCreator() FuncCreator

NewFuncCreator 函数创建默认校验函数构造器。

type GetWarp

type GetWarp func(string) interface{}

GetWarp 对象封装Get函数提供类型转换功能。

func NewGetWarp

func NewGetWarp(fn func(string) interface{}) GetWarp

NewGetWarp 函数创建一个getwarp处理类型转换。

func NewGetWarpWithApp

func NewGetWarpWithApp(app *App) GetWarp

NewGetWarpWithApp 函数使用App创建getwarp。

func NewGetWarpWithConfig

func NewGetWarpWithConfig(c Config) GetWarp

NewGetWarpWithConfig 函数使用Config.Get创建getwarp。

func NewGetWarpWithMapString

func NewGetWarpWithMapString(data map[string]interface{}) GetWarp

NewGetWarpWithMapString 函数使用map[string]interface{}创建getwarp。

func NewGetWarpWithObject

func NewGetWarpWithObject(obj interface{}) GetWarp

NewGetWarpWithObject 函数使用map或创建getwarp。

func (GetWarp) GetBool

func (fn GetWarp) GetBool(key string) bool

GetBool 方法获取bool类型的配置值。

func (GetWarp) GetBytes

func (fn GetWarp) GetBytes(key string) []byte

GetBytes 方法获取[]byte类型的配置值,如果是字符串类型会转换成[]byte。

func (GetWarp) GetFloat32

func (fn GetWarp) GetFloat32(key string, vals ...float32) float32

GetFloat32 方法取获取float32类型的配置值。

func (GetWarp) GetFloat64

func (fn GetWarp) GetFloat64(key string, vals ...float64) float64

GetFloat64 方法取获取float64类型的配置值。

func (GetWarp) GetInt

func (fn GetWarp) GetInt(key string, vals ...int) int

GetInt 方法获取int类型的配置值。

func (GetWarp) GetInt64

func (fn GetWarp) GetInt64(key string, vals ...int64) int64

GetInt64 方法int64类型的配置值。

func (GetWarp) GetInterface

func (fn GetWarp) GetInterface(key string) interface{}

GetInterface 方法获取interface类型的配置值。

func (GetWarp) GetString

func (fn GetWarp) GetString(key string, vals ...string) string

GetString 方法获取一个字符串,如果字符串为空返回其他默认非空字符串,

func (GetWarp) GetStrings

func (fn GetWarp) GetStrings(key string) []string

GetStrings 方法获取[]string值

func (GetWarp) GetUint

func (fn GetWarp) GetUint(key string, vals ...uint) uint

GetUint 方法取获取uint类型的配置值。

func (GetWarp) GetUint64

func (fn GetWarp) GetUint64(key string, vals ...uint64) uint64

GetUint64 方法取获取uint64类型的配置值。

type HandlerDataFunc

type HandlerDataFunc = func(Context, interface{}) error

HandlerDataFunc 定义请求上下文数据出来函数。

默认定义Bind Validate Filte Render四种行为。

Binder对象用于请求数据反序列化,默认根据http请求的Content-Type header指定的请求数据格式来解析数据。

Renderer对象更加Accept Header选择数据对象序列化的方法。

func NewBindWithHeader

func NewBindWithHeader(fn HandlerDataFunc) HandlerDataFunc

NewBindWithHeader 实现Binder额外封装bind header。

func NewBindWithURL

func NewBindWithURL(fn HandlerDataFunc) HandlerDataFunc

NewBindWithURL 实现Binder在非get和head方法下实现BindURL。

func NewBinds

func NewBinds(binds map[string]HandlerDataFunc) HandlerDataFunc

NewBinds 方法定义ContentType Header映射Bind函数。

func NewRenders

func NewRenders(fn HandlerDataFunc, renders map[string]HandlerDataFunc) HandlerDataFunc

NewRenders 方法定义默认和Accepte Header映射Render函数。

func NewValidateField

func NewValidateField(ctx context.Context) HandlerDataFunc

NewValidateField 方法创建结构体属性校验器。

使用结构体tag validate从FuncCreator获取校验函数。 获取ContextKeyFuncCreator.(FuncCreator)用于创建校验函数。

type HandlerExtender

type HandlerExtender interface {
	RegisterHandlerExtend(string, interface{}) error
	NewHandlerFuncs(string, interface{}) HandlerFuncs
	ListExtendHandlerNames() []string
}

HandlerExtender 定义函数扩展处理者的方法。

HandlerExtender默认拥有Base、Warp、Tree三种实现,具体参数三种对象的文档。

func NewHandlerExtendBase

func NewHandlerExtendBase() HandlerExtender

NewHandlerExtendBase method returns a basic function extension processing object.

The NewHandlerExtendBase().RegisterHandlerExtend method registers a conversion function and ignores the path.

The NewHandlerExtendBase().NewHandlerFuncs method implementation creates multiple request handler functions, ignoring paths.

NewHandlerExtendBase 方法返回一个基本的函数扩展处理对象。

NewHandlerExtendBase().RegisterHandlerExtend 方法实现注册一个转换函数,忽略路径。

NewHandlerExtendBase().NewHandlerFuncs 方法实现创建多个请求处理函数,忽略路径。

func NewHandlerExtendTree

func NewHandlerExtendTree() HandlerExtender

NewHandlerExtendTree function creates a path-based function extender.

Mainly implement path matching. All actions are processed by the node's HandlerExtender, and the NewHandlerExtendBase () object is used.

All registration and creation actions will be performed by matching the lowest node of the tree. If it cannot be created, the tree nodes will be processed upwards in order.

The NewHandlerExtendTree().RegisterHandlerExtend method registers a handler function based on the path, and initializes to NewHandlerExtendBase () if the HandlerExtender is empty.

The NewHandlerExtendTree().NewHandlerFuncs method matches the child nodes of the tree based on the path, and then executes the NewHandlerFuncs method from the most child node up. If it returns non-null, it returns directly.

NewHandlerExtendTree 函数创建一个基于路径的函数扩展者。

主要实现路径匹配,所有行为使用节点的HandlerExtender处理,使用NewHandlerExtendBase()对象。

所有注册和创建行为都会匹配树最下级节点执行,如果无法创建则在树节点依次向上处理。

NewHandlerExtendTree().RegisterHandlerExtend 方法基于路径注册一个处理函数,如果HandlerExtender为空则初始化为NewHandlerExtendBase()。

NewHandlerExtendTree().NewHandlerFuncs 方法基于路径向树子节点匹配,后从最子节点依次向上执行NewHandlerFuncs方法,如果返回非空直接返回,否在会依次执行注册行为。

func NewHandlerExtendWarp

func NewHandlerExtendWarp(base, last HandlerExtender) HandlerExtender

NewHandlerExtendWarp function creates a chained HandlerExtender object.

All objects are registered and created using base. If base cannot create a function handler, use last to create a function handler.

NewHandlerExtendWarp 函数创建一个链式HandlerExtender对象。

The NewHandlerExtendWarp(base, last).RegisterHandlerExtend method uses the base object to register extension functions.

The NewHandlerExtendWarp(base, last).NewHandlerFuncs method first uses the base object to create multiple request processing functions. If it returns nil, it uses the last object to create multiple request processing functions.

所有对象注册和创建均使用base,如果base无法创建函数处理者则使用last创建函数处理者。

NewHandlerExtendWarp(base, last).RegisterHandlerExtend 方法使用base对象注册扩展函数。

NewHandlerExtendWarp(base, last).NewHandlerFuncs 方法先使用base对象创建多个请求处理函数,如果返回nil,则使用last对象创建多个请求处理函数。

type HandlerFunc

type HandlerFunc func(Context)

HandlerFunc 是处理一个Context的函数

func NewExtendFunc

func NewExtendFunc(fn func()) HandlerFunc

NewExtendFunc 函数处理func()。

func NewExtendFuncContextError

func NewExtendFuncContextError(fn func(Context) error) HandlerFunc

NewExtendFuncContextError 函数处理func(Context) error返回的error处理。

func NewExtendFuncContextInterfaceError

func NewExtendFuncContextInterfaceError(fn interface{}) HandlerFunc

NewExtendFuncContextInterfaceError 函数处理func(Context) (T, error)返回数据渲染和error处理。

func NewExtendFuncContextRender

func NewExtendFuncContextRender(fn func(Context) interface{}) HandlerFunc

NewExtendFuncContextRender 函数处理func(Context) interface{}返回数据渲染。

func NewExtendFuncContextRenderError

func NewExtendFuncContextRenderError(fn func(Context) (interface{}, error)) HandlerFunc

NewExtendFuncContextRenderError 函数处理func(Context) (interface{}, error)返回数据渲染和error处理。

func NewExtendFuncEmbed

func NewExtendFuncEmbed(path string, f embed.FS) HandlerFunc

func NewExtendFuncError

func NewExtendFuncError(fn func() error) HandlerFunc

NewExtendFuncError 函数处理func() error返回的error处理。

func NewExtendFuncNetHTTP1

func NewExtendFuncNetHTTP1(fn func(http.ResponseWriter, *http.Request)) HandlerFunc

NewExtendFuncNetHTTP1 函数转换处理func(http.ResponseWriter, *http.Request)类型。

func NewExtendFuncNetHTTP2

func NewExtendFuncNetHTTP2(fn http.HandlerFunc) HandlerFunc

NewExtendFuncNetHTTP2 函数转换处理http.HandlerFunc类型。

func NewExtendFuncRPCMap

func NewExtendFuncRPCMap(fn func(Context, map[string]interface{}) (interface{}, error)) HandlerFunc

NewExtendFuncRPCMap defines a fixed request and response to function processing of type map [string] interface {}.

is a subset of NewRPCHandlerFunc and has type restrictions, but using map [string] interface {} to save requests does not use reflection.

NewExtendFuncRPCMap 定义了固定请求和响应为map[string]interface{}类型的函数处理。

是NewRPCHandlerFunc的一种子集,拥有类型限制,但是使用map[string]interface{}保存请求没用使用反射。

func NewExtendFuncRender

func NewExtendFuncRender(fn func() interface{}) HandlerFunc

NewExtendFuncRender 函数处理func() interface{}。

func NewExtendFuncRenderError

func NewExtendFuncRenderError(fn func() (interface{}, error)) HandlerFunc

NewExtendFuncRenderError 函数处理func() (interface{}, error)返回数据渲染和error处理。

func NewExtendFuncString

func NewExtendFuncString(fn func() string) HandlerFunc

NewExtendFuncString 函数处理func() string,然后指定函数生成的字符串。

func NewExtendHandlerHTTP

func NewExtendHandlerHTTP(h handlerHTTP) HandlerFunc

NewExtendHandlerHTTP 函数handlerHTTP接口转换成HandlerFunc。

func NewExtendHandlerNetHTTP

func NewExtendHandlerNetHTTP(h http.Handler) HandlerFunc

NewExtendHandlerNetHTTP 函数转换处理http.Handler对象。

func NewExtendHandlerRPC

func NewExtendHandlerRPC(fn interface{}) HandlerFunc

NewExtendHandlerRPC function needs to pass in a function that returns a request for processing and is dynamically called by reflection.

Function form: func (Context, Request) (Response, error)

The types of Request and Response can be map or struct or pointer to struct. All 4 parameters need to exist, and the order cannot be changed.

NewExtendHandlerRPC 函数需要传入一个函数,返回一个请求处理,通过反射来动态调用。

函数形式: func(Context, Request) (Response, error)

Request和Response的类型可以为map或结构体或者结构体的指针,4个参数需要全部存在,且不可调换顺序。

func NewExtendHandlerStringer

func NewExtendHandlerStringer(fn fmt.Stringer) HandlerFunc

NewExtendHandlerStringer 函数处理fmt.Stringer接口类型转换成HandlerFunc。

func NewHandlerEmbedFunc

func NewHandlerEmbedFunc(f embed.FS, dirs ...string) HandlerFunc

NewHandlerEmbedFunc 函数使用embed.FS和指定目录文件处理响应,依次寻找dirs多个目录是否存在文件,否则使用embed.FS作为默认FS返回响应。

func NewStaticHandler

func NewStaticHandler(name, dir string) HandlerFunc

NewStaticHandler 函数更加目标创建一个静态文件处理函数。

参数dir指导打开文件的根目录,默认未"."

路由规则可以指导path参数为请求文件路径,例如/static/*path,将会去打开path参数路径的文件,否在使用ctx.Path().

func (HandlerFunc) String

func (h HandlerFunc) String() string

String method implements the fmt.Stringer interface and implements the output function name.

String 方法实现fmt.Stringer接口,实现输出函数名称。

type HandlerFuncs

type HandlerFuncs []HandlerFunc

HandlerFuncs 是HandlerFunc的集合,表示多个请求处理函数。

func NewHandlerFuncsCombine

func NewHandlerFuncsCombine(hs1, hs2 HandlerFuncs) HandlerFuncs

NewHandlerFuncsCombine function merges two HandlerFuncs into one. The default maximum length is now 63, which exceeds panic.

Used to reconstruct the slice and prevent the appended data from being confused.

HandlerFuncsCombine 函数将两个HandlerFuncs合并成一个,默认现在最大长度63,超过过panic。

用于重构切片,防止切片append数据混乱。

func NewHandlerFuncsFilter

func NewHandlerFuncsFilter(hs HandlerFuncs) HandlerFuncs

NewHandlerFuncsFilter 函数过滤掉多个请求上下文处理函数中的空对象。

type Logger

type Logger interface {
	Debug(...interface{})
	Info(...interface{})
	Warning(...interface{})
	Error(...interface{})
	Fatal(...interface{})
	Debugf(string, ...interface{})
	Infof(string, ...interface{})
	Warningf(string, ...interface{})
	Errorf(string, ...interface{})
	Fatalf(string, ...interface{})
	WithField(string, interface{}) Logger
	WithFields([]string, []interface{}) Logger
	SetLevel(LoggerLevel)
	Sync() error
}

Logger 定义日志输出接口实现下列功能:

五级日志格式化输出
日志条目带Fields属性
json有序格式化输出
日志器初始化前日志处理
文件行信息输出
默认输入文件切割并软连接。

func NewLoggerInit

func NewLoggerInit() Logger

NewLoggerInit the initial log processor only records the log. After setting the log processor, it will forward the log of the current record to the new log processor for processing the log generated before the program is initialized.

loggerInit 初始日志处理器仅记录日志,再设置日志处理器后, 会将当前记录的日志交给新日志处理器处理,用于处理程序初始化之前产生的日志。

LoggerInit实现了NextHandler(Logger)方法,断言调用该方法设置next logger就会将LoggerInit的日子输出给next logger。

func NewLoggerNull

func NewLoggerNull() Logger

NewLoggerNull 定义空日志输出,丢弃所有日志。

func NewLoggerStd

func NewLoggerStd(arg interface{}) Logger

NewLoggerStd 创建一个标准日志处理器。

参数为一个eudore.LoggerStdConfig或map保存的创建配置,配置选项含义参考eudore.LoggerStdConfig说明。

type LoggerLevel

type LoggerLevel int32

LoggerLevel 定义日志级别

const (
	LogDebug LoggerLevel = iota
	LogInfo
	LogWarning
	LogError
	LogFatal
)

定义日志级别

func (LoggerLevel) MarshalText

func (l LoggerLevel) MarshalText() ([]byte, error)

MarshalText 方法实现encoding.TextMarshaler接口,用于编码日志级别。

func (LoggerLevel) String

func (l LoggerLevel) String() string

String 方法实现ftm.Stringer接口,格式化输出日志级别。

func (*LoggerLevel) UnmarshalText

func (l *LoggerLevel) UnmarshalText(text []byte) error

UnmarshalText 方法实现encoding.TextUnmarshaler接口,用于解码日志级别。

type LoggerStd

type LoggerStd struct {
	LoggerStdData
	// 日志标识 true是Logger false是Entry
	Logger bool
	// enrty data
	Level      LoggerLevel
	Time       time.Time
	Message    string
	Keys       []string
	Vals       []interface{}
	Buffer     []byte
	Timeformat string
	Depth      int
}

LoggerStd 定义日志默认实现条目信息。

func (*LoggerStd) Debug

func (entry *LoggerStd) Debug(args ...interface{})

Debug 方法条目输出Debug级别日志。

func (*LoggerStd) Debugf

func (entry *LoggerStd) Debugf(format string, args ...interface{})

Debugf 方法格式化写入流Debug级别日志

func (*LoggerStd) Error

func (entry *LoggerStd) Error(args ...interface{})

Error 方法条目输出Error级别日志。

func (*LoggerStd) Errorf

func (entry *LoggerStd) Errorf(format string, args ...interface{})

Errorf 方法格式化写入流Error级别日志

func (*LoggerStd) Fatal

func (entry *LoggerStd) Fatal(args ...interface{})

Fatal 方法条目输出Fatal级别日志。

func (*LoggerStd) Fatalf

func (entry *LoggerStd) Fatalf(format string, args ...interface{})

Fatalf 方法格式化写入流Fatal级别日志

func (*LoggerStd) Info

func (entry *LoggerStd) Info(args ...interface{})

Info 方法条目输出Info级别日志。

func (*LoggerStd) Infof

func (entry *LoggerStd) Infof(format string, args ...interface{})

Infof 方法格式写入流出Info级别日志

func (*LoggerStd) Metadata

func (entry *LoggerStd) Metadata() interface{}

Metadata 方法从LoggerStdData获取元数据返回。

func (*LoggerStd) Mount

func (entry *LoggerStd) Mount(ctx context.Context)

Mount 方法使LoggerStd挂载上下文,上下文传递给LoggerStdData。

func (*LoggerStd) SetLevel

func (entry *LoggerStd) SetLevel(level LoggerLevel)

SetLevel 方法设置日志输出级别。

func (*LoggerStd) Sync

func (entry *LoggerStd) Sync() error

Sync 方法将缓冲写入到输出流。

func (*LoggerStd) Unmount

func (entry *LoggerStd) Unmount(ctx context.Context)

Unmount 方法使LoggerStd卸载上下文,上下文传递给LoggerStdData。

func (*LoggerStd) Warning

func (entry *LoggerStd) Warning(args ...interface{})

Warning 方法条目输出Warning级别日志。

func (*LoggerStd) Warningf

func (entry *LoggerStd) Warningf(format string, args ...interface{})

Warningf 方法格式化输出写入流Warning级别日志

func (*LoggerStd) WithField

func (entry *LoggerStd) WithField(key string, value interface{}) Logger

WithField 方法设置一个日志属性。

如果key为"context"值类型为context.Context,设置该值用于传递自定义信息。

如果key为"depth"值类型为int,设置日志调用堆栈增删层数。

如果key为"depth"值类型为string值"enable"或"disable",启用或关闭日志调用位置输出。

如果key为"time"值类型为time.time,设置日志输出的时间属性。

func (*LoggerStd) WithFields

func (entry *LoggerStd) WithFields(key []string, value []interface{}) Logger

WithFields 方法一次设置多个条目属性。

如果key和val同时为nil会返回Logger的深拷贝对象。

WithFields不会设置Field属性。

type LoggerStdConfig

type LoggerStdConfig struct {
	Writer     LoggerWriter `json:"-" alias:"writer" description:"Logger output writer."`
	Std        bool         `json:"std" alias:"std" description:"Is output to os.Stdout."`
	Path       string       `json:"path" alias:"path" description:"Output logger file path."`
	MaxSize    uint64       `json:"maxsize" alias:"maxsize" description:"Output file max size, 'Path' must contain 'index'."`
	Link       string       `json:"link" alias:"link" description:"Output file link to path."`
	Level      LoggerLevel  `json:"level" alias:"level" description:"Logger Output level."`
	TimeFormat string       `json:"timeformat" alias:"timeformat" description:"Logger output timeFormat, default '2006-01-02 15:04:05'"`
	FileLine   bool         `json:"fileline" alias:"fileline" description:"Is output file and line."`
}

LoggerStdConfig 定义loggerStd配置信息。

Writer 设置日志输出流,如果为空会使用Std和Path创建一个LoggerWriter。

Std 是否输出日志到os.Stdout标准输出流。

Path 指定文件输出路径,如果为空强制指定Std为true。

MaxSize 指定文件切割大小,需要Path中存在index字符串,用于替换成切割文件索引。

Link 如果非空会作为软连接的目标路径。

Level 日志输出级别。

TimeFormat 日志输出时间格式化格式。

FileLine 是否输出调用日志输出的函数和文件位置

type LoggerStdData

type LoggerStdData interface {
	GetLogger() *LoggerStd
	PutLogger(*LoggerStd)
	Sync() error
}

LoggerStdData 定义loggerStd的数据存储

func NewLoggerStdDataJSON

func NewLoggerStdDataJSON(arg interface{}) LoggerStdData

NewLoggerStdDataJSON 函数创建一个LoggerStd的JSON数据处理器。

type LoggerWriter

type LoggerWriter interface {
	Sync() error
	io.Writer
}

LoggerWriter 定义日志写入流,用于写入日志数据。

func NewLoggerWriterFile

func NewLoggerWriterFile(name string, std bool) (LoggerWriter, error)

NewLoggerWriterFile 函数创建一个文件输出的日志写入流。

func NewLoggerWriterRotate

func NewLoggerWriterRotate(name string, std bool, maxsize uint64, fn ...func(string)) (LoggerWriter, error)

NewLoggerWriterRotate 函数创建一个支持文件切割的的日志写入流。

func NewLoggerWriterStd

func NewLoggerWriterStd() LoggerWriter

NewLoggerWriterStd 函数返回一个标准输出流的日志写入流。

type Params

type Params []string

Params 定义用于保存一些键值数据。

func NewParamsRoute

func NewParamsRoute(path string) Params

NewParamsRoute 方法根据一个路由路径创建Params,支持路由路径块模式。

func (Params) Add

func (p Params) Add(vals ...string) Params

Add 方法添加一个参数。

func (Params) Clone

func (p Params) Clone() Params

Clone 方法深复制一个ParamArray对象。

func (Params) CombineWithRoute

func (p Params) CombineWithRoute(params Params) Params

CombineWithRoute 方法将params数据合并到p,用于路由路径合并。

func (Params) Del

func (p Params) Del(key string)

Del 方法删除一个参数值

func (Params) Get

func (p Params) Get(key string) string

Get 方法返回一个参数的值。

func (Params) MarshalJSON

func (p Params) MarshalJSON() ([]byte, error)

MarshalJSON 方法设置Params json序列化显示的数据。

func (Params) Set

func (p Params) Set(key, val string) Params

Set 方法设置一个参数的值。

func (Params) String

func (p Params) String() string

String 方法输出Params成字符串。

type RequestWriterWarp

type RequestWriterWarp struct {
	*http.Request
	Client *ClientWarp
}

RequestWriterWarp 定义http请求对象。

func (*RequestWriterWarp) AddHeader

func (req *RequestWriterWarp) AddHeader(key, val string) *RequestWriterWarp

AddHeader 方法给请求添加header。

func (*RequestWriterWarp) AddHeaders

func (req *RequestWriterWarp) AddHeaders(headers http.Header) *RequestWriterWarp

AddHeaders 方法给请求添加headers。

func (*RequestWriterWarp) AddQuery

func (req *RequestWriterWarp) AddQuery(key, val string) *RequestWriterWarp

AddQuery 方法给请求添加url参数。

func (*RequestWriterWarp) Body

func (req *RequestWriterWarp) Body(i interface{}) *RequestWriterWarp

Body 方法格局对象类型创建http请求body。

func (*RequestWriterWarp) BodyBytes

func (req *RequestWriterWarp) BodyBytes(b []byte) *RequestWriterWarp

BodyBytes 方法使用[]byte创建body。

func (*RequestWriterWarp) BodyFormFile

func (req *RequestWriterWarp) BodyFormFile(key, name string, val interface{}) *RequestWriterWarp

BodyFormFile 方法给form添加文件内容。

func (*RequestWriterWarp) BodyFormLocalFile

func (req *RequestWriterWarp) BodyFormLocalFile(key, name, path string) *RequestWriterWarp

BodyFormLocalFile 方法给form添加本地文件内容。

func (*RequestWriterWarp) BodyFormValue

func (req *RequestWriterWarp) BodyFormValue(key, val string) *RequestWriterWarp

BodyFormValue 方法给form添加键值数据。

func (*RequestWriterWarp) BodyFormValues

func (req *RequestWriterWarp) BodyFormValues(data map[string][]string) *RequestWriterWarp

BodyFormValues 方法给form添加键值数据。

func (*RequestWriterWarp) BodyJSON

func (req *RequestWriterWarp) BodyJSON(data interface{}) *RequestWriterWarp

BodyJSON 方法使用任意类型创建json请求body。

func (*RequestWriterWarp) BodyJSONValue

func (req *RequestWriterWarp) BodyJSONValue(key string, val interface{}) *RequestWriterWarp

BodyJSONValue 方法使用json键值创建json请求body。

func (*RequestWriterWarp) BodyString

func (req *RequestWriterWarp) BodyString(s string) *RequestWriterWarp

BodyString 方法使用string创建body。

func (*RequestWriterWarp) Do

Do 方法发生请求。

type ResponseReader

type ResponseReader interface {
	Proto() string
	Status() int
	Reason() string
	Header() http.Header
	Cookies() []*http.Cookie
	Read([]byte) (int, error)
	Body() []byte
	Err() error
	Callback(...ResponseReaderCheck)
}

ResponseReader 定义响应读取方法。

type ResponseReaderCheck

type ResponseReaderCheck = func(ResponseReader, *http.Request, Logger) error

ResponseReaderCheck 定义响应检查方法。

func NewResponseReaderCheckBody

func NewResponseReaderCheckBody(str string) ResponseReaderCheck

NewResponseReaderCheckBody 函数检查响应body是否包含状态码。

func NewResponseReaderCheckStatus

func NewResponseReaderCheckStatus(status int) ResponseReaderCheck

NewResponseReaderCheckStatus 函数检查响应状态码

func NewResponseReaderOutBody

func NewResponseReaderOutBody() ResponseReaderCheck

NewResponseReaderOutBody 函数输出响应body内容。

func NewResponseReaderOutHead

func NewResponseReaderOutHead() ResponseReaderCheck

NewResponseReaderOutHead 函数输出响应状态行。

type ResponseWriter

type ResponseWriter interface {
	// http.ResponseWriter
	Header() http.Header
	Write([]byte) (int, error)
	WriteHeader(int)
	// http.Flusher
	Flush()
	// http.Hijacker
	Hijack() (net.Conn, *bufio.ReadWriter, error)
	// http.Pusher
	Push(string, *http.PushOptions) error
	Size() int
	Status() int
}

ResponseWriter 接口用于写入http请求响应体status、header、body。

net/http.response实现了flusher、hijacker、pusher接口。

type Router

type Router interface {
	RouterCore
	// RouterMethod method
	Group(string) Router
	Params() *Params
	AddHandler(string, string, ...interface{}) error
	AddController(...Controller) error
	AddMiddleware(...interface{}) error
	AddHandlerExtend(...interface{}) error
	AnyFunc(string, ...interface{})
	GetFunc(string, ...interface{})
	PostFunc(string, ...interface{})
	PutFunc(string, ...interface{})
	DeleteFunc(string, ...interface{})
	HeadFunc(string, ...interface{})
	PatchFunc(string, ...interface{})
}

Router interface is divided into RouterCore and RouterMethod. RouterCore implements router matching algorithm and logic, and RouterMethod implements the encapsulation of routing rule registration.

RouterCore implements route matching details. RouterMethod calls RouterCore to provide methods for external use.

RouterMethod The default directly registered interface of the route. Set the routing parameters, group routing, middleware, function extensions, controllers and other behaviors.

Do not use the RouterCore method to register routes directly at any time. You should use the Add ... method of RouterMethod.

RouterMethod implements the following functions:

Group routing
The middleware or function extension is registered in the local scope/global scope
Add controller
Display routing registration debug information

RouterCore has four router cores to implement the following functions:

High performance (70%-90% of httprouter performance, using less memory)
Low code complexity (RouterCoreStd supports 5 levels of priority, a code complexity of 19 is not satisfied)
Request for additional default parameters (including current routing matching rules)
Extend custom routing methods
Variable and wildcard matching
Matching priority Constant > Variable verification > Variable > Wildcard verification > Wildcard (RouterCoreStd five-level priority)
Method priority Specify method > Any method (The specified method will override the Any method, and vice versa)
Variables and wildcards support regular and custom functions to verify data
Variables and wildcards support constant prefix
Get all registered routing rule information (RouterCoreBebug implementation)
Routing rule matching based on Host (implemented by RouterCoreHost)
Allows dynamic addition and deletion of router rules at runtime (RouterCoreStd implementation, the outer layer requires RouterCoreLock packaging layer)

Router 接口分为RouterCore和RouterMethod,RouterCore实现路由器匹配算法和逻辑,RouterMethod实现路由规则注册的封装。

RouterCore实现路由匹配细节,RouterMethod调用RouterCore提供对外使用的方法。

RouterMethod 路由默认直接注册的接口,设置路由参数、组路由、中间件、函数扩展、控制器等行为。

任何时候请不要使用RouterCore的方法直接注册路由,应该使用RouterMethod的Add...方法。

RouterMethod实现下列功能:

组路由
中间件或函数扩展注册在局部作用域/全局作用域
添加控制器
显示路由注册debug信息

RouterCore拥有四种路由器核心实现下列功能:

高性能(httprouter性能的70%-90%,使用更少的内存)
低代码复杂度(RouterCoreStd支持5级优先级 一处代码复杂度19不满足)
请求获取额外的默认参数(包含当前路由匹配规则)
扩展自定义路由方法
变量和通配符匹配
匹配优先级 常量 > 变量校验 > 变量 > 通配符校验 > 通配符(RouterCoreStd五级优先级)
方法优先级 指定方法 > Any方法(指定方法会覆盖Any方法,反之不行)
变量和通配符支持正则和自定义函数进行校验数据
变量和通配符支持常量前缀
获取注册的全部路由规则信息(RouterCoreBebug实现)
基于Host进行路由规则匹配(RouterCoreHost实现)
允许运行时进行动态增删路由器规则(RouterCoreStd实现,外层需要RouterCoreLock包装一层)

func NewRouterStd

func NewRouterStd(core RouterCore) Router

NewRouterStd method uses a RouterCore to create a Router object.

RouterStd implements RouterMethod interface registration related details, and routing matching is implemented by RouterCore.

NewRouterStd 方法使用一个RouterCore创建Router对象。

RouterStd实现RouterMethod接口注册相关细节,路由匹配由RouterCore实现。

type RouterCore

type RouterCore interface {
	HandleFunc(string, string, HandlerFuncs)
	Match(string, string, *Params) HandlerFuncs
}

The RouterCore interface performs registration of the route and matches a request and returns the handler.

RouterCore mainly implements routing matching related details.

RouterCore接口,执行路由的注册和匹配一个请求并返回处理者。

RouterCore主要实现路由匹配相关细节。

func NewRouterCoreDebug

func NewRouterCoreDebug(core RouterCore) RouterCore

NewRouterCoreDebug function specifies the routing core to create a debug core, using eudore.RouterCoreStd as the core by default.

Visit GET /eudore/debug/router/data to get router registration information.

NewRouterCoreDebug 函数指定路由核心创建一个debug核心,默认使用eudore.RouterCoreStd为核心。

访问 GET /eudore/debug/router/data 可以获取路由器注册信息。

func NewRouterCoreHost

func NewRouterCoreHost(fn func(string) RouterCore) RouterCore

NewRouterCoreHost function creates a Host routing core, and a function that creates a routing core based on the host value needs to be given.

If the parameter is empty, each route Host will create NewRouterCoreStd by default.

NewRouterCoreHost 函数创建一个Host路由核心,需要给定一个根据host值创建路由核心的函数。

如果参数为空默认每个路由Host都创建NewRouterCoreStd。

func NewRouterCoreLock

func NewRouterCoreLock(core RouterCore) RouterCore

NewRouterCoreLock function creates a router core with a read-write lock, and other router cores use the Lock core package when they need to dynamically modify the rules.

NewRouterCoreLock 函数创建一个带读写锁的路由器核心,其他路由器核心在需要动态修改规则时使用Lock核心包装。

func NewRouterCoreStd

func NewRouterCoreStd() RouterCore

NewRouterCoreStd function creates a Std router core and uses radix to match. For the function description, please refer to the Router document.

NewRouterCoreStd 函数创建一个Std路由器核心,使用radix匹配,功能说明见Router文档。

type RouterStd

type RouterStd struct {
	RouterCore      `alias:"routercore"`
	HandlerExtender `alias:"handlerextender"`
	Middlewares     *middlewareTree      `alias:"middlewares"`
	Print           func(...interface{}) `alias:"print"`
	// contains filtered or unexported fields
}

RouterStd default router registration implementation.

Need to specify a routing core, the default handler function extension is DefaultHandlerExtend. As a public attribute, it is only used by godoc to display the documentation of the relevant method.

RouterStd 默认路由器注册实现。

需要指定一个路由核心,处理函数扩展者默认为DefaultHandlerExtend。 作为公开属性仅用于godoc展示相关方法文档说明。

func (*RouterStd) AddController

func (r *RouterStd) AddController(controllers ...Controller) error

AddController method uses the built-in controller parsing function to resolve the controller to obtain the routing configuration.

If the controller implements the RoutesInjecter interface, call the controller to inject the route itself.

AddController 方式使用内置的控制器解析函数解析控制器获得路由配置。

如果控制器实现了RoutesInjecter接口,调用控制器自身注入路由。

func (*RouterStd) AddHandler

func (r *RouterStd) AddHandler(method, path string, hs ...interface{}) error

AddHandler method adds a new route, allowing multiple request methods to be added separately using','.

You can register 9 methods defined by http (three of the Router interfaces do not provide direct registration), or you can register the method as: ANY TEST 404 405 NotFound MethodNotAllowed, register Any, TEST, 404, 405 routing rules. the registration method is ANY to register all methods, the ANY method route will be covered by the same path non-ANY method, and vice versa; the registration method is TEST will output the debug information related to the route registration, but the registration behavior will not be performed;

The handler parameter is processed using the HandlerExtender.NewHandlerFuncs() method of the current RouterStd to generate the corresponding HandlerFuncs.

If the current Router cannot be processed, call the HandlerExtender or defaultHandlerExtend of the upper-level group for processing, and output the error log if all of them cannot be processed.

The middleware data will be matched from the data according to the current routing path, and then the request processing function will be appended before the processing function.

AddHandler 方法添加一条新路由, 允许添加多个请求方法使用','分开。

可以注册http定义的9种方法(其中三种Router接口未提供直接注册),也可以注册方法为:ANY TEST 404 405 NotFound MethodNotAllowed,注册Any、TEST、404、405路由规则。注册方法为ANY注册全部方法,ANY方法路由会被同路径非ANY方法覆盖,反之不行;注册方法为TEST会输出路由注册相关debug信息,但不执行注册行为;

handler参数使用当前RouterStd的HandlerExtender.NewHandlerFuncs()方法处理,生成对应的HandlerFuncs。

如果当前Router无法处理,则调用上一级group的HandlerExtender或defaultHandlerExtend处理,全部无法处理则输出error日志。

中间件数据会根据当前路由路径从数据中匹配,然后将请求处理函数附加到处理函数之前。

func (*RouterStd) AddHandlerExtend

func (r *RouterStd) AddHandlerExtend(handlers ...interface{}) error

AddHandlerExtend method adds an extension function to the current Router.

If the number of parameters is greater than 1 and the first parameter is a string type, the first string type parameter is used as the path to add the extension function.

AddHandlerExtend 方法给当前Router添加扩展函数。

如果参数数量大于1且第一个参数为字符串类型,会将第一个字符串类型参数作为添加扩展函数的路径。

func (*RouterStd) AddMiddleware

func (r *RouterStd) AddMiddleware(hs ...interface{}) error

AddMiddleware adds multiple middleware functions to the router, which will use HandlerExtender to convert parameters.

If the number of parameters is greater than 1 and the first parameter is a string type, the first string type parameter is used as the path to add the middleware.

AddMiddleware 给路由器添加多个中间件函数,会使用HandlerExtender转换参数。

如果参数数量大于1且第一个参数为字符串类型,会将第一个字符串类型参数作为添加中间件的路径。

func (*RouterStd) AnyFunc

func (r *RouterStd) AnyFunc(path string, h ...interface{})

AnyFunc method realizes the http request processing function that registers an Any method.

The routing rules registered by the Any method will be overwritten by the specified method registration, and vice versa. Any default registration method includes six types of Get Post Put Delete Head Patch, which are defined in the global variable RouterAnyMethod.

AnyFunc 方法实现注册一个Any方法的http请求处理函数。

Any方法注册的路由规则会被指定方法注册覆盖,反之不行。 Any默认注册方法包含Get Post Put Delete Head Patch六种,定义在全局变量RouterAnyMethod。

func (*RouterStd) DeleteFunc

func (r *RouterStd) DeleteFunc(path string, h ...interface{})

DeleteFunc 方法实现注册一个Delete方法的http请求处理函数。

func (*RouterStd) GetFunc

func (r *RouterStd) GetFunc(path string, h ...interface{})

GetFunc 方法实现注册一个Get方法的http请求处理函数。

func (*RouterStd) Group

func (r *RouterStd) Group(path string) Router

Group method returns a new group router.

The parameters, middleware, and function extensions of each Group group route registration will not affect the superior, but the subordinate will inherit the superior data.

The new Router will use the old RouterCore and Print objects; the middleware information and routing parameters are deep copied from the superior, while processing the Group parameters.

And create a new HandlerExtender in chain, if the type that HandlerExtender cannot register will call the previous Router.HandlerExtender to process.

The top-level HandlerExtender object is defaultHandlerExtend. You can use the RegisterHandlerExtend function and the NewHandlerFuncs function to call the defaultHandlerExtend object.

Group 方法返回一个新的组路由器。

每个Group组路由注册的参数、中间件、函数扩展都不会影响上级,但是下级会继承上级数据。

新的Router将使用旧的RouterCore和Print对象;中间件信息和路由参数从上级深拷贝一份,同时处理Group参数。

以及链式创建一个新的HandlerExtender,若HandlerExtender无法注册的类型将调用上一个Router.HandlerExtender处理。

最顶级HandlerExtender对象为defaultHandlerExtend,可以使用RegisterHandlerExtend函数和NewHandlerFuncs函数调用defaultHandlerExtend对象。

func (*RouterStd) HeadFunc

func (r *RouterStd) HeadFunc(path string, h ...interface{})

HeadFunc 方法实现注册一个Head方法的http请求处理函数。

func (*RouterStd) Metadata

func (r *RouterStd) Metadata() interface{}

Metadata 方法返回RouterCore的Metadata。

func (*RouterStd) Mount

func (r *RouterStd) Mount(ctx context.Context)

Mount 方法使RouterStd挂载上下文,上下文传递给RouterCore。

并从ctx.Value(ContextKeyApp)获取Logger,初始化RouterStd日志输出函数。

func (*RouterStd) Params

func (r *RouterStd) Params() *Params

Params method returns the current route parameters, and the route parameter value is an empty string will not be used.

Params 方法返回当前路由参数,路由参数值为空字符串不会被使用。

func (*RouterStd) PatchFunc

func (r *RouterStd) PatchFunc(path string, h ...interface{})

PatchFunc 方法实现注册一个Patch方法的http请求处理函数。

func (*RouterStd) PostFunc

func (r *RouterStd) PostFunc(path string, h ...interface{})

PostFunc 方法实现注册一个Post方法的http请求处理函数。

func (*RouterStd) PutFunc

func (r *RouterStd) PutFunc(path string, h ...interface{})

PutFunc 方法实现注册一个Put方法的http请求处理函数。

func (*RouterStd) Unmount

func (r *RouterStd) Unmount(ctx context.Context)

Unmount 方法使RouterStd卸载上下文,上下文传递给RouterCore。

type Server

type Server interface {
	SetHandler(http.Handler)
	Serve(net.Listener) error
	Shutdown(context.Context) error
}

Server 定义启动http服务的对象。

func NewServerFcgi

func NewServerFcgi() Server

NewServerFcgi 函数创建一个fcgi server。

func NewServerStd

func NewServerStd(arg interface{}) Server

NewServerStd 创建一个标准server。

type ServerListenConfig

type ServerListenConfig struct {
	NewListen   func(string, string) (net.Listener, error) `alias:"newlisten" json:"-" description:"create listener func, default: net.Listen"`
	Addr        string                                     `alias:"addr" json:"addr" description:"Listen addr."`
	HTTPS       bool                                       `alias:"https" json:"https" description:"Is https."`
	HTTP2       bool                                       `alias:"http2" json:"http2" description:"Is http2."`
	Mutual      bool                                       `alias:"mutual" json:"mutual" description:"Is mutual tls."`
	Certfile    string                                     `alias:"certfile" json:"certfile" description:"Http server cert file."`
	Keyfile     string                                     `alias:"keyfile" json:"keyfile" description:"Http server key file."`
	Trustfile   string                                     `alias:"trustfile" json:"trustfile" description:"Http client ca file."`
	Certificate *x509.Certificate                          `alias:"certificate" json:"certificate" description:"https use tls certificate."`
}

ServerListenConfig 定义一个通用的端口监听配置,监听https仅支持单证书。

func (*ServerListenConfig) Listen

func (slc *ServerListenConfig) Listen() (net.Listener, error)

Listen 方法使ServerListenConfig实现serverListener接口,用于使用对象创建监听。

type ServerStdConfig

type ServerStdConfig struct {
	// set default ServerHandler
	Handler http.Handler

	// ReadTimeout is the maximum duration for reading the entire request, including the body.
	//
	// Because ReadTimeout does not let Handlers make per-request decisions on each request body's acceptable deadline or upload rate,
	// most users will prefer to use ReadHeaderTimeout. It is valid to use them both.
	ReadTimeout TimeDuration `alias:"readtimeout" json:"readtimeout" description:"Http server read timeout."`

	// ReadHeaderTimeout is the amount of time allowed to read request headers.
	// The connection's read deadline is reset after reading the headers and the Handler can decide what is considered too slow for the body.
	ReadHeaderTimeout TimeDuration `alias:"readheadertimeout" json:"readheadertimeout"  description:"Http server read header timeout."` // Go 1.8

	// WriteTimeout is the maximum duration before timing out writes of the response.
	// It is reset whenever a new request's header is read.
	// Like ReadTimeout, it does not let Handlers make decisions on a per-request basis.
	WriteTimeout TimeDuration `alias:"writetimeout" json:"writetimeout" description:"Http server write timeout."`

	// IdleTimeout is the maximum amount of time to wait for the next request when keep-alives are enabled.
	// If IdleTimeout is zero, the value of ReadTimeout is used. If both are zero, ReadHeaderTimeout is used.
	IdleTimeout TimeDuration `alias:"idletimeout" json:"idletimeout"  description:"Http server idle timeout."` // Go 1.8

	// MaxHeaderBytes controls the maximum number of bytes the server will read parsing the request header's keys and values, including the request line.
	// It does not limit the size of the request body. If zero, DefaultMaxHeaderBytes is used.
	MaxHeaderBytes int `alias:"maxheaderbytes" json:"maxheaderbytes"  description:"Http server max header size."`

	// ErrorLog specifies an optional logger for errors accepting
	// connections, unexpected behavior from handlers, and
	// underlying FileSystem errors.
	// If nil, logging is done via the log package's standard logger.
	ErrorLog *log.Logger // Go 1.3

	// BaseContext optionally specifies a function that returns the base context for incoming requests on this server.
	// The provided Listener is the specific Listener that's about to start accepting requests.
	// If BaseContext is nil, the default is context.Background(). If non-nil, it must return a non-nil context.
	BaseContext func(net.Listener) context.Context `alias:"basecontext" json:"-"` // Go 1.13

	// ConnContext optionally specifies a function that modifies the context used for a new connection c.
	// The provided ctx is derived from the base context and has a ServerContextKey value.
	ConnContext func(context.Context, net.Conn) context.Context `alias:"conncontext" json:"-"` // Go 1.13
}

ServerStdConfig 定义serverStd使用的配置

type SetCookie

type SetCookie = http.Cookie

SetCookie 定义响应返回的set-cookie header的数据生成

type Stmt

type Stmt interface {
	Init(DatabaseContext) error
	Build(DatabaseContext)
}

Stmt 定义sql statement接口

type TimeDuration

type TimeDuration time.Duration

TimeDuration 定义time.Duration类型处理json

func (TimeDuration) MarshalJSON

func (d TimeDuration) MarshalJSON() ([]byte, error)

MarshalJSON 方法实现json序列化输出。

func (TimeDuration) String

func (d TimeDuration) String() string

String 方法格式化输出时间。

func (*TimeDuration) UnmarshalJSON

func (d *TimeDuration) UnmarshalJSON(b []byte) error

UnmarshalJSON 方法实现解析json格式时间。

Directories

Path Synopsis
component
server/simple
Package simple implementation of the http protocol as a learning sample.
Package simple implementation of the http protocol as a learning sample.
Package middleware 实现eudore基础请求中间件和处理函数。
Package middleware 实现eudore基础请求中间件和处理函数。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL