Documentation

Overview

    Package ghttp provides powerful http server and simple client implements.

    Index

    Examples

    Constants

    View Source
    const (
    	HOOK_BEFORE_SERVE   = "HOOK_BEFORE_SERVE"  // Deprecated, use HookBeforeServe instead.
    	HOOK_AFTER_SERVE    = "HOOK_AFTER_SERVE"   // Deprecated, use HookAfterServe instead.
    	HOOK_BEFORE_OUTPUT  = "HOOK_BEFORE_OUTPUT" // Deprecated, use HookBeforeOutput instead.
    	HOOK_AFTER_OUTPUT   = "HOOK_AFTER_OUTPUT"  // Deprecated, use HookAfterOutput instead.
    	HookBeforeServe     = "HOOK_BEFORE_SERVE"
    	HookAfterServe      = "HOOK_AFTER_SERVE"
    	HookBeforeOutput    = "HOOK_BEFORE_OUTPUT"
    	HookAfterOutput     = "HOOK_AFTER_OUTPUT"
    	ServerStatusStopped = 0
    	ServerStatusRunning = 1
    )
    View Source
    const (
    	URI_TYPE_DEFAULT  = 0 // Method name to URI converting type, which converts name to its lower case and joins the words using char '-'.
    	URI_TYPE_FULLNAME = 1 // Method name to URI converting type, which does no converting to the method name.
    	URI_TYPE_ALLLOWER = 2 // Method name to URI converting type, which converts name to its lower case.
    	URI_TYPE_CAMEL    = 3 // Method name to URI converting type, which converts name to its camel case.
    )
    View Source
    const (
    	// TextMessage denotes a text data message. The text message payload is
    	// interpreted as UTF-8 encoded text data.
    	WS_MSG_TEXT = websocket.TextMessage
    
    	// BinaryMessage denotes a binary data message.
    	WS_MSG_BINARY = websocket.BinaryMessage
    
    	// CloseMessage denotes a close control message. The optional message
    	// payload contains a numeric code and text. Use the FormatCloseMessage
    	// function to format a close message payload.
    	WS_MSG_CLOSE = websocket.CloseMessage
    
    	// PingMessage denotes a ping control message. The optional message payload
    	// is UTF-8 encoded text.
    	WS_MSG_PING = websocket.PingMessage
    
    	// PongMessage denotes a pong control message. The optional message payload
    	// is UTF-8 encoded text.
    	WS_MSG_PONG = websocket.PongMessage
    )

    Variables

    This section is empty.

    Functions

    func BuildParams

    func BuildParams(params interface{}, noUrlEncode ...bool) (encodedParamStr string)

      BuildParams builds the request string for the http client. The <params> can be type of: string/[]byte/map/struct/*struct.

      The optional parameter <noUrlEncode> specifies whether ignore the url encoding for the data.

      func ConnectBytes

      func ConnectBytes(url string, data ...interface{}) []byte

        ConnectBytes is a convenience method for sending CONNECT request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().ConnectBytes or NewClient().ConnectBytes instead.

        func ConnectContent

        func ConnectContent(url string, data ...interface{}) string

          ConnectContent is a convenience method for sending CONNECT request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().ConnectContent or NewClient().ConnectContent instead.

          func ConnectVar

          func ConnectVar(url string, data ...interface{}) *gvar.Var

            ConnectVar sends a CONNECT request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().ConnectVar or NewClient().ConnectVar instead.

            func DeleteBytes

            func DeleteBytes(url string, data ...interface{}) []byte

              DeleteBytes is a convenience method for sending DELETE request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().DeleteBytes or NewClient().DeleteBytes instead.

              func DeleteContent

              func DeleteContent(url string, data ...interface{}) string

                DeleteContent is a convenience method for sending DELETE request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().DeleteContent or NewClient().DeleteContent instead.

                func DeleteVar

                func DeleteVar(url string, data ...interface{}) *gvar.Var

                  DeleteVar sends a DELETE request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().DeleteVar or NewClient().DeleteVar instead.

                  func GetBytes

                  func GetBytes(url string, data ...interface{}) []byte

                    GetBytes is a convenience method for sending GET request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().GetBytes or NewClient().GetBytes instead.

                    func GetContent

                    func GetContent(url string, data ...interface{}) string

                      GetContent is a convenience method for sending GET request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().GetContent or NewClient().GetContent instead.

                      func GetVar

                      func GetVar(url string, data ...interface{}) *gvar.Var

                        GetVar sends a GET request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().GetVar or NewClient().GetVar instead.

                        func HeadBytes

                        func HeadBytes(url string, data ...interface{}) []byte

                          HeadBytes is a convenience method for sending HEAD request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().HeadBytes or NewClient().HeadBytes instead.

                          func HeadContent

                          func HeadContent(url string, data ...interface{}) string

                            HeadContent is a convenience method for sending HEAD request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().HeadContent or NewClient().HeadContent instead.

                            func HeadVar

                            func HeadVar(url string, data ...interface{}) *gvar.Var

                              HeadVar sends a HEAD request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().HeadVar or NewClient().HeadVar instead.

                              func IsExitError

                              func IsExitError(err interface{}) bool

                                IsExitError checks if given error is an exit error of server. This is used in old version of server for custom error handler. Deprecated.

                                func MiddlewareServerTracing

                                func MiddlewareServerTracing(r *Request)

                                  MiddlewareServerTracing is a serer middleware that enables tracing feature using standards of OpenTelemetry.

                                  func OptionsBytes

                                  func OptionsBytes(url string, data ...interface{}) []byte

                                    OptionsBytes is a convenience method for sending OPTIONS request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().OptionsBytes or NewClient().OptionsBytes instead.

                                    func OptionsContent

                                    func OptionsContent(url string, data ...interface{}) string

                                      OptionsContent is a convenience method for sending OPTIONS request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().OptionsContent or NewClient().OptionsContent instead.

                                      func OptionsVar

                                      func OptionsVar(url string, data ...interface{}) *gvar.Var

                                        OptionsVar sends a OPTIONS request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().OptionsVar or NewClient().OptionsVar instead.

                                        func PatchBytes

                                        func PatchBytes(url string, data ...interface{}) []byte

                                          PatchBytes is a convenience method for sending PATCH request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().PatchBytes or NewClient().PatchBytes instead.

                                          func PatchContent

                                          func PatchContent(url string, data ...interface{}) string

                                            PatchContent is a convenience method for sending PATCH request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().PatchContent or NewClient().PatchContent instead.

                                            func PatchVar

                                            func PatchVar(url string, data ...interface{}) *gvar.Var

                                              PatchVar sends a PATCH request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().PatchVar or NewClient().PatchVar instead.

                                              func PostBytes

                                              func PostBytes(url string, data ...interface{}) []byte

                                                PostBytes is a convenience method for sending POST request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().PostBytes or NewClient().PostBytes instead.

                                                func PostContent

                                                func PostContent(url string, data ...interface{}) string

                                                  PostContent is a convenience method for sending POST request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().PostContent or NewClient().PostContent instead.

                                                  func PostVar

                                                  func PostVar(url string, data ...interface{}) *gvar.Var

                                                    PostVar sends a POST request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().PostVar or NewClient().PostVar instead.

                                                    func PutBytes

                                                    func PutBytes(url string, data ...interface{}) []byte

                                                      PutBytes is a convenience method for sending PUT request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().PutBytes or NewClient().PutBytes instead.

                                                      func PutContent

                                                      func PutContent(url string, data ...interface{}) string

                                                        PutContent is a convenience method for sending PUT request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().PutContent or NewClient().PutContent instead.

                                                        func PutVar

                                                        func PutVar(url string, data ...interface{}) *gvar.Var

                                                          PutVar sends a PUT request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().PutVar or NewClient().PutVar instead.

                                                          func RequestBytes

                                                          func RequestBytes(method string, url string, data ...interface{}) []byte

                                                            RequestBytes is a convenience method for sending custom http method request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().RequestBytes or NewClient().RequestBytes instead.

                                                            func RequestContent

                                                            func RequestContent(method string, url string, data ...interface{}) string

                                                              RequestContent is a convenience method for sending custom http method request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().RequestContent or NewClient().RequestContent instead.

                                                              func RequestVar

                                                              func RequestVar(method string, url string, data ...interface{}) *gvar.Var

                                                                RequestVar sends request using given HTTP method and data, retrieves converts the result to specified pointer. It reads and closes the response object internally automatically. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().RequestVar or NewClient().RequestVar instead.

                                                                func RestartAllServer

                                                                func RestartAllServer(newExeFilePath ...string) error

                                                                  RestartAllServer restarts all the servers of the process. The optional parameter <newExeFilePath> specifies the new binary file for creating process.

                                                                  func SetGraceful

                                                                  func SetGraceful(enabled bool)

                                                                    SetGraceful enables/disables the graceful reload feature for server, which is false in default.

                                                                    Note that this feature switch is not for single server instance but for whole process. Deprecated, use configuration of ghttp.Server for controlling this feature.

                                                                    func ShutdownAllServer

                                                                    func ShutdownAllServer() error

                                                                      ShutdownAllServer shuts down all servers of current process.

                                                                      func StartPProfServer

                                                                      func StartPProfServer(port int, pattern ...string)

                                                                        StartPProfServer starts and runs a new server for pprof.

                                                                        func TraceBytes

                                                                        func TraceBytes(url string, data ...interface{}) []byte

                                                                          TraceBytes is a convenience method for sending TRACE request, which retrieves and returns the result content as bytes and automatically closes response object. Deprecated, please use g.Client().TraceBytes or NewClient().TraceBytes instead.

                                                                          func TraceContent

                                                                          func TraceContent(url string, data ...interface{}) string

                                                                            TraceContent is a convenience method for sending TRACE request, which retrieves and returns the result content and automatically closes response object. Deprecated, please use g.Client().TraceContent or NewClient().TraceContent instead.

                                                                            func TraceVar

                                                                            func TraceVar(url string, data ...interface{}) *gvar.Var

                                                                              TraceVar sends a TRACE request, retrieves and converts the result content to specified pointer. The parameter <pointer> can be type of: struct/*struct/**struct/[]struct/[]*struct/*[]struct, et Deprecated, please use g.Client().TraceVar or NewClient().TraceVar instead.

                                                                              func Wait

                                                                              func Wait()

                                                                                Wait blocks to wait for all servers done. It's commonly used in multiple servers situation.

                                                                                Types

                                                                                type CORSOptions

                                                                                type CORSOptions struct {
                                                                                	AllowDomain      []string // Used for allowing requests from custom domains
                                                                                	AllowOrigin      string   // Access-Control-Allow-Origin
                                                                                	AllowCredentials string   // Access-Control-Allow-Credentials
                                                                                	ExposeHeaders    string   // Access-Control-Expose-Headers
                                                                                	MaxAge           int      // Access-Control-Max-Age
                                                                                	AllowMethods     string   // Access-Control-Allow-Methods
                                                                                	AllowHeaders     string   // Access-Control-Allow-Headers
                                                                                }

                                                                                  CORSOptions is the options for CORS feature. See https://www.w3.org/TR/cors/ .

                                                                                  type Client

                                                                                  type Client = client.Client

                                                                                  func NewClient

                                                                                  func NewClient() *Client

                                                                                    New creates and returns a new HTTP client object.

                                                                                    type ClientHandlerFunc

                                                                                    type ClientHandlerFunc = client.HandlerFunc

                                                                                    type ClientResponse

                                                                                    type ClientResponse = client.Response

                                                                                    func Connect

                                                                                    func Connect(url string, data ...interface{}) (*ClientResponse, error)

                                                                                      Connect is a convenience method for sending CONNECT request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Connect or NewClient().Connect instead.

                                                                                      func Delete

                                                                                      func Delete(url string, data ...interface{}) (*ClientResponse, error)

                                                                                        Delete is a convenience method for sending DELETE request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Delete or NewClient().Delete instead.

                                                                                        func DoRequest

                                                                                        func DoRequest(method, url string, data ...interface{}) (*ClientResponse, error)

                                                                                          DoRequest is a convenience method for sending custom http method request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().DoRequest or NewClient().DoRequest instead.

                                                                                          func Get

                                                                                          func Get(url string, data ...interface{}) (*ClientResponse, error)

                                                                                            Get is a convenience method for sending GET request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Get or NewClient().Get instead.

                                                                                            func Head(url string, data ...interface{}) (*ClientResponse, error)

                                                                                              Head is a convenience method for sending HEAD request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Head or NewClient().Head instead.

                                                                                              func MiddlewareClientTracing

                                                                                              func MiddlewareClientTracing(c *Client, r *http.Request) (*ClientResponse, error)

                                                                                                MiddlewareClientTracing is a client middleware that enables tracing feature using standards of OpenTelemetry.

                                                                                                func Options

                                                                                                func Options(url string, data ...interface{}) (*ClientResponse, error)

                                                                                                  Options is a convenience method for sending OPTIONS request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Options or NewClient().Options instead.

                                                                                                  func Patch

                                                                                                  func Patch(url string, data ...interface{}) (*ClientResponse, error)

                                                                                                    Patch is a convenience method for sending PATCH request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Patch or NewClient().Patch instead.

                                                                                                    func Post

                                                                                                    func Post(url string, data ...interface{}) (*ClientResponse, error)

                                                                                                      Post is a convenience method for sending POST request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Post or NewClient().Post instead.

                                                                                                      func Put

                                                                                                      func Put(url string, data ...interface{}) (*ClientResponse, error)

                                                                                                        Put is a convenience method for sending PUT request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Put or NewClient().Put instead.

                                                                                                        func Trace

                                                                                                        func Trace(url string, data ...interface{}) (*ClientResponse, error)

                                                                                                          Trace is a convenience method for sending TRACE request. NOTE that remembers CLOSING the response object when it'll never be used. Deprecated, please use g.Client().Trace or NewClient().Trace instead.

                                                                                                          type Controller

                                                                                                          type Controller interface {
                                                                                                          	Init(*Request)
                                                                                                          	Shut()
                                                                                                          }

                                                                                                            Controller is the base struct for controller.

                                                                                                            type Cookie struct {
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                              Cookie for HTTP COOKIE management.

                                                                                                              func GetCookie

                                                                                                              func GetCookie(r *Request) *Cookie

                                                                                                                GetCookie creates or retrieves a cookie object with given request. It retrieves and returns an existing cookie object if it already exists with given request. It creates and returns a new cookie object if it does not exist with given request.

                                                                                                                func (*Cookie) Contains

                                                                                                                func (c *Cookie) Contains(key string) bool

                                                                                                                  Contains checks if given key exists and not expired in cookie.

                                                                                                                  func (*Cookie) Flush

                                                                                                                  func (c *Cookie) Flush()

                                                                                                                    Flush outputs the cookie items to client.

                                                                                                                    func (*Cookie) Get

                                                                                                                    func (c *Cookie) Get(key string, def ...string) string

                                                                                                                      Get retrieves and returns the value with specified key. It returns <def> if specified key does not exist and <def> is given.

                                                                                                                      func (*Cookie) GetSessionId

                                                                                                                      func (c *Cookie) GetSessionId() string

                                                                                                                        GetSessionId retrieves and returns the session id from cookie.

                                                                                                                        func (*Cookie) Map

                                                                                                                        func (c *Cookie) Map() map[string]string

                                                                                                                          Map returns the cookie items as map[string]string.

                                                                                                                          func (*Cookie) Remove

                                                                                                                          func (c *Cookie) Remove(key string)

                                                                                                                            Remove deletes specified key and its value from cookie using default domain and path. It actually tells the http client that the cookie is expired, do not send it to server next time.

                                                                                                                            func (*Cookie) RemoveCookie

                                                                                                                            func (c *Cookie) RemoveCookie(key, domain, path string)

                                                                                                                              RemoveCookie deletes specified key and its value from cookie using given domain and path. It actually tells the http client that the cookie is expired, do not send it to server next time.

                                                                                                                              func (*Cookie) Set

                                                                                                                              func (c *Cookie) Set(key, value string)

                                                                                                                                Set sets cookie item with default domain, path and expiration age.

                                                                                                                                func (*Cookie) SetCookie

                                                                                                                                func (c *Cookie) SetCookie(key, value, domain, path string, maxAge time.Duration, httpOnly ...bool)

                                                                                                                                  SetCookie sets cookie item given given domain, path and expiration age. The optional parameter <httpOnly> specifies if the cookie item is only available in HTTP, which is usually empty.

                                                                                                                                  func (*Cookie) SetHttpCookie

                                                                                                                                  func (c *Cookie) SetHttpCookie(httpCookie *http.Cookie)

                                                                                                                                    SetHttpCookie sets cookie with *http.Cookie.

                                                                                                                                    func (*Cookie) SetSessionId

                                                                                                                                    func (c *Cookie) SetSessionId(id string)

                                                                                                                                      SetSessionId sets session id in the cookie.

                                                                                                                                      type Domain

                                                                                                                                      type Domain struct {
                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                      }

                                                                                                                                        Domain is used for route register for domains.

                                                                                                                                        func (*Domain) BindController

                                                                                                                                        func (d *Domain) BindController(pattern string, c Controller, methods ...string)

                                                                                                                                        func (*Domain) BindControllerMethod

                                                                                                                                        func (d *Domain) BindControllerMethod(pattern string, c Controller, method string)

                                                                                                                                        func (*Domain) BindControllerRest

                                                                                                                                        func (d *Domain) BindControllerRest(pattern string, c Controller)

                                                                                                                                        func (*Domain) BindHandler

                                                                                                                                        func (d *Domain) BindHandler(pattern string, handler HandlerFunc)

                                                                                                                                        func (*Domain) BindHookHandler

                                                                                                                                        func (d *Domain) BindHookHandler(pattern string, hook string, handler HandlerFunc)

                                                                                                                                        func (*Domain) BindHookHandlerByMap

                                                                                                                                        func (d *Domain) BindHookHandlerByMap(pattern string, hookmap map[string]HandlerFunc)

                                                                                                                                        func (*Domain) BindMiddleware

                                                                                                                                        func (d *Domain) BindMiddleware(pattern string, handlers ...HandlerFunc)

                                                                                                                                        func (*Domain) BindMiddlewareDefault

                                                                                                                                        func (d *Domain) BindMiddlewareDefault(handlers ...HandlerFunc)

                                                                                                                                        func (*Domain) BindObject

                                                                                                                                        func (d *Domain) BindObject(pattern string, obj interface{}, methods ...string)

                                                                                                                                        func (*Domain) BindObjectMethod

                                                                                                                                        func (d *Domain) BindObjectMethod(pattern string, obj interface{}, method string)

                                                                                                                                        func (*Domain) BindObjectRest

                                                                                                                                        func (d *Domain) BindObjectRest(pattern string, obj interface{})

                                                                                                                                        func (*Domain) BindStatusHandler

                                                                                                                                        func (d *Domain) BindStatusHandler(status int, handler HandlerFunc)

                                                                                                                                        func (*Domain) BindStatusHandlerByMap

                                                                                                                                        func (d *Domain) BindStatusHandlerByMap(handlerMap map[int]HandlerFunc)

                                                                                                                                        func (*Domain) EnablePProf

                                                                                                                                        func (d *Domain) EnablePProf(pattern ...string)

                                                                                                                                          EnablePProf enables PProf feature for server of specified domain.

                                                                                                                                          func (*Domain) Group

                                                                                                                                          func (d *Domain) Group(prefix string, groups ...func(group *RouterGroup)) *RouterGroup

                                                                                                                                            Group creates and returns a RouterGroup object, which is bound to a specified domain.

                                                                                                                                            func (*Domain) Use

                                                                                                                                            func (d *Domain) Use(handlers ...HandlerFunc)

                                                                                                                                            type GroupItem

                                                                                                                                            type GroupItem = []interface{}

                                                                                                                                              GroupItem is item for router group.

                                                                                                                                              type HandlerFunc

                                                                                                                                              type HandlerFunc = func(r *Request)

                                                                                                                                                Request handler function.

                                                                                                                                                func WrapF

                                                                                                                                                func WrapF(f http.HandlerFunc) HandlerFunc

                                                                                                                                                  WrapF is a helper function for wrapping http.HandlerFunc and returns a ghttp.HandlerFunc.

                                                                                                                                                  func WrapH

                                                                                                                                                  func WrapH(h http.Handler) HandlerFunc

                                                                                                                                                    WrapH is a helper function for wrapping http.Handler and returns a ghttp.HandlerFunc.

                                                                                                                                                    type Plugin

                                                                                                                                                    type Plugin interface {
                                                                                                                                                    	Name() string            // Name returns the name of the plugin.
                                                                                                                                                    	Author() string          // Author returns the author of the plugin.
                                                                                                                                                    	Version() string         // Version returns the version of the plugin, like "v1.0.0".
                                                                                                                                                    	Description() string     // Description returns the description of the plugin.
                                                                                                                                                    	Install(s *Server) error // Install installs the plugin before server starts.
                                                                                                                                                    	Remove() error           // Remove removes the plugin.
                                                                                                                                                    }

                                                                                                                                                      Plugin is the interface for server plugin.

                                                                                                                                                      type Request

                                                                                                                                                      type Request struct {
                                                                                                                                                      	*http.Request
                                                                                                                                                      	Server     *Server           // Server.
                                                                                                                                                      	Cookie     *Cookie           // Cookie.
                                                                                                                                                      	Session    *gsession.Session // Session.
                                                                                                                                                      	Response   *Response         // Corresponding Response of this request.
                                                                                                                                                      	Router     *Router           // Matched Router for this request. Note that it's not available in HOOK handler.
                                                                                                                                                      	EnterTime  int64             // Request starting time in microseconds.
                                                                                                                                                      	LeaveTime  int64             // Request ending time in microseconds.
                                                                                                                                                      	Middleware *middleware       // Middleware manager.
                                                                                                                                                      	StaticFile *staticFile       // Static file object for static file serving.
                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                      }

                                                                                                                                                        Request is the context object for a request.

                                                                                                                                                        func (*Request) Assign

                                                                                                                                                        func (r *Request) Assign(key string, value interface{})

                                                                                                                                                          Assign binds a template variable to current request.

                                                                                                                                                          func (*Request) Assigns

                                                                                                                                                          func (r *Request) Assigns(data gview.Params)

                                                                                                                                                            Assigns binds multiple template variables to current request.

                                                                                                                                                            func (*Request) BasicAuth

                                                                                                                                                            func (r *Request) BasicAuth(user, pass string, tips ...string) bool

                                                                                                                                                              BasicAuth enables the http basic authentication feature with given passport and password and asks client for authentication. It returns true if authentication success, else returns false if failure.

                                                                                                                                                              func (*Request) Context

                                                                                                                                                              func (r *Request) Context() context.Context

                                                                                                                                                                Context is alias for function GetCtx. This function overwrites the http.Request.Context function. See GetCtx.

                                                                                                                                                                func (*Request) Exit

                                                                                                                                                                func (r *Request) Exit()

                                                                                                                                                                  Exit exits executing of current HTTP handler.

                                                                                                                                                                  func (*Request) ExitAll

                                                                                                                                                                  func (r *Request) ExitAll()

                                                                                                                                                                    ExitAll exits executing of current and following HTTP handlers.

                                                                                                                                                                    func (*Request) ExitHook

                                                                                                                                                                    func (r *Request) ExitHook()

                                                                                                                                                                      ExitHook exits executing of current and following HTTP HOOK handlers.

                                                                                                                                                                      func (*Request) Get

                                                                                                                                                                      func (r *Request) Get(key string, def ...interface{}) interface{}

                                                                                                                                                                        Get is alias of GetRequest, which is one of the most commonly used functions for retrieving parameter. See r.GetRequest.

                                                                                                                                                                        func (*Request) GetArray

                                                                                                                                                                        func (r *Request) GetArray(key string, def ...interface{}) []string

                                                                                                                                                                          GetArray is an alias and convenient function for GetRequestArray. See GetRequestArray.

                                                                                                                                                                          func (*Request) GetBody

                                                                                                                                                                          func (r *Request) GetBody() []byte

                                                                                                                                                                            GetBody retrieves and returns request body content as bytes. It can be called multiple times retrieving the same body content.

                                                                                                                                                                            func (*Request) GetBodyString

                                                                                                                                                                            func (r *Request) GetBodyString() string

                                                                                                                                                                              GetBodyString retrieves and returns request body content as string. It can be called multiple times retrieving the same body content.

                                                                                                                                                                              func (*Request) GetBool

                                                                                                                                                                              func (r *Request) GetBool(key string, def ...interface{}) bool

                                                                                                                                                                                GetBool is an alias and convenient function for GetRequestBool. See GetRequestBool.

                                                                                                                                                                                func (*Request) GetClientIp

                                                                                                                                                                                func (r *Request) GetClientIp() string

                                                                                                                                                                                  GetClientIp returns the client ip of this request without port. Note that this ip address might be modified by client header.

                                                                                                                                                                                  func (*Request) GetCtx

                                                                                                                                                                                  func (r *Request) GetCtx() context.Context

                                                                                                                                                                                    GetCtx retrieves and returns the request's context.

                                                                                                                                                                                    func (*Request) GetCtxVar

                                                                                                                                                                                    func (r *Request) GetCtxVar(key interface{}, def ...interface{}) *gvar.Var

                                                                                                                                                                                      GetCtxVar retrieves and returns a Var with given key name. The optional parameter <def> specifies the default value of the Var if given <key> does not exist in the context.

                                                                                                                                                                                      func (*Request) GetError

                                                                                                                                                                                      func (r *Request) GetError() error

                                                                                                                                                                                        GetError returns the error occurs in the procedure of the request. It returns nil if there's no error.

                                                                                                                                                                                        func (*Request) GetFloat32

                                                                                                                                                                                        func (r *Request) GetFloat32(key string, def ...interface{}) float32

                                                                                                                                                                                          GetFloat32 is an alias and convenient function for GetRequestFloat32. See GetRequestFloat32.

                                                                                                                                                                                          func (*Request) GetFloat64

                                                                                                                                                                                          func (r *Request) GetFloat64(key string, def ...interface{}) float64

                                                                                                                                                                                            GetFloat64 is an alias and convenient function for GetRequestFloat64. See GetRequestFloat64.

                                                                                                                                                                                            func (*Request) GetFloats

                                                                                                                                                                                            func (r *Request) GetFloats(key string, def ...interface{}) []float64

                                                                                                                                                                                              GetFloats is an alias and convenient function for GetRequestFloats. See GetRequestFloats.

                                                                                                                                                                                              func (*Request) GetForm

                                                                                                                                                                                              func (r *Request) GetForm(key string, def ...interface{}) interface{}

                                                                                                                                                                                                GetForm retrieves and returns parameter <key> from form. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                func (*Request) GetFormArray

                                                                                                                                                                                                func (r *Request) GetFormArray(key string, def ...interface{}) []string

                                                                                                                                                                                                  GetFormArray retrieves and returns parameter <key> from form as []string. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                  func (*Request) GetFormBool

                                                                                                                                                                                                  func (r *Request) GetFormBool(key string, def ...interface{}) bool

                                                                                                                                                                                                    GetFormBool retrieves and returns parameter <key> from form as bool. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                    func (*Request) GetFormFloat32

                                                                                                                                                                                                    func (r *Request) GetFormFloat32(key string, def ...interface{}) float32

                                                                                                                                                                                                      GetFormFloat32 retrieves and returns parameter <key> from form as float32. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                      func (*Request) GetFormFloat64

                                                                                                                                                                                                      func (r *Request) GetFormFloat64(key string, def ...interface{}) float64

                                                                                                                                                                                                        GetFormFloat64 retrieves and returns parameter <key> from form as float64. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                        func (*Request) GetFormFloats

                                                                                                                                                                                                        func (r *Request) GetFormFloats(key string, def ...interface{}) []float64

                                                                                                                                                                                                          GetFormFloats retrieves and returns parameter <key> from form as []float64. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                          func (*Request) GetFormInt

                                                                                                                                                                                                          func (r *Request) GetFormInt(key string, def ...interface{}) int

                                                                                                                                                                                                            GetFormInt retrieves and returns parameter <key> from form as int. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                            func (*Request) GetFormInt32

                                                                                                                                                                                                            func (r *Request) GetFormInt32(key string, def ...interface{}) int32

                                                                                                                                                                                                              GetFormInt32 retrieves and returns parameter <key> from form as int32. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                              func (*Request) GetFormInt64

                                                                                                                                                                                                              func (r *Request) GetFormInt64(key string, def ...interface{}) int64

                                                                                                                                                                                                                GetFormInt64 retrieves and returns parameter <key> from form as int64. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                func (*Request) GetFormInterfaces

                                                                                                                                                                                                                func (r *Request) GetFormInterfaces(key string, def ...interface{}) []interface{}

                                                                                                                                                                                                                  GetFormInterfaces retrieves and returns parameter <key> from form as []interface{}. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                  func (*Request) GetFormInts

                                                                                                                                                                                                                  func (r *Request) GetFormInts(key string, def ...interface{}) []int

                                                                                                                                                                                                                    GetFormInts retrieves and returns parameter <key> from form as []int. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                    func (*Request) GetFormMap

                                                                                                                                                                                                                    func (r *Request) GetFormMap(kvMap ...map[string]interface{}) map[string]interface{}

                                                                                                                                                                                                                      GetFormMap retrieves and returns all form parameters passed from client as map. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                      func (*Request) GetFormMapStrStr

                                                                                                                                                                                                                      func (r *Request) GetFormMapStrStr(kvMap ...map[string]interface{}) map[string]string

                                                                                                                                                                                                                        GetFormMapStrStr retrieves and returns all form parameters passed from client as map[string]string. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                        func (*Request) GetFormMapStrVar

                                                                                                                                                                                                                        func (r *Request) GetFormMapStrVar(kvMap ...map[string]interface{}) map[string]*gvar.Var

                                                                                                                                                                                                                          GetFormMapStrVar retrieves and returns all form parameters passed from client as map[string]*gvar.Var. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                          func (*Request) GetFormString

                                                                                                                                                                                                                          func (r *Request) GetFormString(key string, def ...interface{}) string

                                                                                                                                                                                                                            GetFormString retrieves and returns parameter <key> from form as string. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                            func (*Request) GetFormStrings

                                                                                                                                                                                                                            func (r *Request) GetFormStrings(key string, def ...interface{}) []string

                                                                                                                                                                                                                              GetFormStrings retrieves and returns parameter <key> from form as []string. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                              func (*Request) GetFormStruct

                                                                                                                                                                                                                              func (r *Request) GetFormStruct(pointer interface{}, mapping ...map[string]string) error

                                                                                                                                                                                                                                GetFormStruct retrieves all form parameters passed from client and converts them to given struct object. Note that the parameter <pointer> is a pointer to the struct object. The optional parameter <mapping> is used to specify the key to attribute mapping.

                                                                                                                                                                                                                                func (*Request) GetFormUint

                                                                                                                                                                                                                                func (r *Request) GetFormUint(key string, def ...interface{}) uint

                                                                                                                                                                                                                                  GetFormUint retrieves and returns parameter <key> from form as uint. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                                  func (*Request) GetFormUint32

                                                                                                                                                                                                                                  func (r *Request) GetFormUint32(key string, def ...interface{}) uint32

                                                                                                                                                                                                                                    GetFormUint32 retrieves and returns parameter <key> from form as uint32. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                                    func (*Request) GetFormUint64

                                                                                                                                                                                                                                    func (r *Request) GetFormUint64(key string, def ...interface{}) uint64

                                                                                                                                                                                                                                      GetFormUint64 retrieves and returns parameter <key> from form as uint64. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                                      func (*Request) GetFormVar

                                                                                                                                                                                                                                      func (r *Request) GetFormVar(key string, def ...interface{}) *gvar.Var

                                                                                                                                                                                                                                        GetFormVar retrieves and returns parameter <key> from form as Var. It returns <def> if <key> does not exist in the form and <def> is given, or else it returns nil.

                                                                                                                                                                                                                                        func (*Request) GetHeader

                                                                                                                                                                                                                                        func (r *Request) GetHeader(key string) string

                                                                                                                                                                                                                                          GetHeader retrieves and returns the header value with given <key>.

                                                                                                                                                                                                                                          func (*Request) GetHost

                                                                                                                                                                                                                                          func (r *Request) GetHost() string

                                                                                                                                                                                                                                            GetHost returns current request host name, which might be a domain or an IP without port.

                                                                                                                                                                                                                                            func (*Request) GetInt

                                                                                                                                                                                                                                            func (r *Request) GetInt(key string, def ...interface{}) int

                                                                                                                                                                                                                                              GetInt is an alias and convenient function for GetRequestInt. See GetRequestInt.

                                                                                                                                                                                                                                              func (*Request) GetInt32

                                                                                                                                                                                                                                              func (r *Request) GetInt32(key string, def ...interface{}) int32

                                                                                                                                                                                                                                                GetInt32 is an alias and convenient function for GetRequestInt32. See GetRequestInt32.

                                                                                                                                                                                                                                                func (*Request) GetInt64

                                                                                                                                                                                                                                                func (r *Request) GetInt64(key string, def ...interface{}) int64

                                                                                                                                                                                                                                                  GetInt64 is an alias and convenient function for GetRequestInt64. See GetRequestInt64.

                                                                                                                                                                                                                                                  func (*Request) GetInterfaces

                                                                                                                                                                                                                                                  func (r *Request) GetInterfaces(key string, def ...interface{}) []interface{}

                                                                                                                                                                                                                                                    GetInterfaces is an alias and convenient function for GetRequestInterfaces. See GetRequestInterfaces.

                                                                                                                                                                                                                                                    func (*Request) GetInts

                                                                                                                                                                                                                                                    func (r *Request) GetInts(key string, def ...interface{}) []int

                                                                                                                                                                                                                                                      GetInts is an alias and convenient function for GetRequestInts. See GetRequestInts.

                                                                                                                                                                                                                                                      func (*Request) GetJson

                                                                                                                                                                                                                                                      func (r *Request) GetJson() (*gjson.Json, error)

                                                                                                                                                                                                                                                        GetJson parses current request content as JSON format, and returns the JSON object. Note that the request content is read from request BODY, not from any field of FORM.

                                                                                                                                                                                                                                                        func (*Request) GetMap

                                                                                                                                                                                                                                                        func (r *Request) GetMap(def ...map[string]interface{}) map[string]interface{}

                                                                                                                                                                                                                                                          GetMap is an alias and convenient function for GetRequestMap. See GetRequestMap.

                                                                                                                                                                                                                                                          func (*Request) GetMapStrStr

                                                                                                                                                                                                                                                          func (r *Request) GetMapStrStr(def ...map[string]interface{}) map[string]string

                                                                                                                                                                                                                                                            GetMapStrStr is an alias and convenient function for GetRequestMapStrStr. See GetRequestMapStrStr.

                                                                                                                                                                                                                                                            func (*Request) GetMultipartFiles

                                                                                                                                                                                                                                                            func (r *Request) GetMultipartFiles(name string) []*multipart.FileHeader

                                                                                                                                                                                                                                                              GetMultipartFiles parses and returns the post files array. Note that the request form should be type of multipart.

                                                                                                                                                                                                                                                              func (*Request) GetMultipartForm

                                                                                                                                                                                                                                                              func (r *Request) GetMultipartForm() *multipart.Form

                                                                                                                                                                                                                                                                GetMultipartForm parses and returns the form as multipart form.

                                                                                                                                                                                                                                                                func (*Request) GetPage

                                                                                                                                                                                                                                                                func (r *Request) GetPage(totalSize, pageSize int) *gpage.Page

                                                                                                                                                                                                                                                                  GetPage creates and returns the pagination object for given <totalSize> and <pageSize>. NOTE THAT the page parameter name from client is constantly defined as gpage.PAGE_NAME for simplification and convenience.

                                                                                                                                                                                                                                                                  func (*Request) GetParam

                                                                                                                                                                                                                                                                  func (r *Request) GetParam(key string, def ...interface{}) interface{}

                                                                                                                                                                                                                                                                    GetParam returns custom parameter with given name <key>. It returns <def> if <key> does not exist. It returns nil if <def> is not passed.

                                                                                                                                                                                                                                                                    func (*Request) GetParamVar

                                                                                                                                                                                                                                                                    func (r *Request) GetParamVar(key string, def ...interface{}) *gvar.Var

                                                                                                                                                                                                                                                                      GetParamVar returns custom parameter with given name <key> as gvar.Var. It returns <def> if <key> does not exist. It returns nil if <def> is not passed.

                                                                                                                                                                                                                                                                      func (*Request) GetPost

                                                                                                                                                                                                                                                                      func (r *Request) GetPost(key string, def ...interface{}) interface{}

                                                                                                                                                                                                                                                                        GetPost retrieves and returns parameter <key> from form and body. It returns <def> if <key> does not exist in neither form nor body. It returns nil if <def> is not passed.

                                                                                                                                                                                                                                                                        Note that if there're multiple parameters with the same name, the parameters are retrieved and overwrote in order of priority: form > body.

                                                                                                                                                                                                                                                                        Deprecated, use GetForm instead.

                                                                                                                                                                                                                                                                        func (*Request) GetPostArray

                                                                                                                                                                                                                                                                        func (r *Request) GetPostArray(key string, def ...interface{}) []string

                                                                                                                                                                                                                                                                          Deprecated, use GetFormArray instead.

                                                                                                                                                                                                                                                                          func (*Request) GetPostBool

                                                                                                                                                                                                                                                                          func (r *Request) GetPostBool(key string, def ...interface{}) bool

                                                                                                                                                                                                                                                                            Deprecated, use GetFormBool instead.

                                                                                                                                                                                                                                                                            func (*Request) GetPostFloat32

                                                                                                                                                                                                                                                                            func (r *Request) GetPostFloat32(key string, def ...interface{}) float32

                                                                                                                                                                                                                                                                              Deprecated, use GetFormFloat32 instead.

                                                                                                                                                                                                                                                                              func (*Request) GetPostFloat64

                                                                                                                                                                                                                                                                              func (r *Request) GetPostFloat64(key string, def ...interface{}) float64

                                                                                                                                                                                                                                                                                Deprecated, use GetFormFloat64 instead.

                                                                                                                                                                                                                                                                                func (*Request) GetPostFloats

                                                                                                                                                                                                                                                                                func (r *Request) GetPostFloats(key string, def ...interface{}) []float64

                                                                                                                                                                                                                                                                                  Deprecated, use GetFormFloats instead.

                                                                                                                                                                                                                                                                                  func (*Request) GetPostInt

                                                                                                                                                                                                                                                                                  func (r *Request) GetPostInt(key string, def ...interface{}) int

                                                                                                                                                                                                                                                                                    Deprecated, use GetFormInt instead.

                                                                                                                                                                                                                                                                                    func (*Request) GetPostInt32

                                                                                                                                                                                                                                                                                    func (r *Request) GetPostInt32(key string, def ...interface{}) int32

                                                                                                                                                                                                                                                                                      Deprecated, use GetFormInt32 instead.

                                                                                                                                                                                                                                                                                      func (*Request) GetPostInt64

                                                                                                                                                                                                                                                                                      func (r *Request) GetPostInt64(key string, def ...interface{}) int64

                                                                                                                                                                                                                                                                                        Deprecated, use GetFormInt64 instead.

                                                                                                                                                                                                                                                                                        func (*Request) GetPostInterfaces

                                                                                                                                                                                                                                                                                        func (r *Request) GetPostInterfaces(key string, def ...interface{}) []interface{}

                                                                                                                                                                                                                                                                                          Deprecated, use GetFormInterfaces instead.

                                                                                                                                                                                                                                                                                          func (*Request) GetPostInts

                                                                                                                                                                                                                                                                                          func (r *Request) GetPostInts(key string, def ...interface{}) []int

                                                                                                                                                                                                                                                                                            Deprecated, use GetFormInts instead.

                                                                                                                                                                                                                                                                                            func (*Request) GetPostMap

                                                                                                                                                                                                                                                                                            func (r *Request) GetPostMap(kvMap ...map[string]interface{}) map[string]interface{}

                                                                                                                                                                                                                                                                                              GetPostMap retrieves and returns all parameters in the form and body passed from client as map. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                              Note that if there're multiple parameters with the same name, the parameters are retrieved and overwrote in order of priority: form > body.

                                                                                                                                                                                                                                                                                              Deprecated.

                                                                                                                                                                                                                                                                                              func (*Request) GetPostMapStrStr

                                                                                                                                                                                                                                                                                              func (r *Request) GetPostMapStrStr(kvMap ...map[string]interface{}) map[string]string

                                                                                                                                                                                                                                                                                                GetPostMapStrStr retrieves and returns all parameters in the form and body passed from client as map[string]string. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                                Deprecated.

                                                                                                                                                                                                                                                                                                func (*Request) GetPostMapStrVar

                                                                                                                                                                                                                                                                                                func (r *Request) GetPostMapStrVar(kvMap ...map[string]interface{}) map[string]*gvar.Var

                                                                                                                                                                                                                                                                                                  GetPostMapStrVar retrieves and returns all parameters in the form and body passed from client as map[string]*gvar.Var. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                                  Deprecated.

                                                                                                                                                                                                                                                                                                  func (*Request) GetPostString

                                                                                                                                                                                                                                                                                                  func (r *Request) GetPostString(key string, def ...interface{}) string

                                                                                                                                                                                                                                                                                                    Deprecated, use GetFormString instead.

                                                                                                                                                                                                                                                                                                    func (*Request) GetPostStrings

                                                                                                                                                                                                                                                                                                    func (r *Request) GetPostStrings(key string, def ...interface{}) []string

                                                                                                                                                                                                                                                                                                      Deprecated, use GetFormStrings instead.

                                                                                                                                                                                                                                                                                                      func (*Request) GetPostStruct

                                                                                                                                                                                                                                                                                                      func (r *Request) GetPostStruct(pointer interface{}, mapping ...map[string]string) error

                                                                                                                                                                                                                                                                                                        GetPostStruct retrieves all parameters in the form and body passed from client and converts them to given struct object. Note that the parameter <pointer> is a pointer to the struct object. The optional parameter <mapping> is used to specify the key to attribute mapping.

                                                                                                                                                                                                                                                                                                        Deprecated.

                                                                                                                                                                                                                                                                                                        func (*Request) GetPostToStruct

                                                                                                                                                                                                                                                                                                        func (r *Request) GetPostToStruct(pointer interface{}, mapping ...map[string]string) error

                                                                                                                                                                                                                                                                                                          GetPostToStruct is alias of GetQueryStruct. See GetPostStruct.

                                                                                                                                                                                                                                                                                                          Deprecated.

                                                                                                                                                                                                                                                                                                          func (*Request) GetPostUint

                                                                                                                                                                                                                                                                                                          func (r *Request) GetPostUint(key string, def ...interface{}) uint

                                                                                                                                                                                                                                                                                                            Deprecated, use GetFormUint instead.

                                                                                                                                                                                                                                                                                                            func (*Request) GetPostUint32

                                                                                                                                                                                                                                                                                                            func (r *Request) GetPostUint32(key string, def ...interface{}) uint32

                                                                                                                                                                                                                                                                                                              Deprecated, use GetFormUint32 instead.

                                                                                                                                                                                                                                                                                                              func (*Request) GetPostUint64

                                                                                                                                                                                                                                                                                                              func (r *Request) GetPostUint64(key string, def ...interface{}) uint64

                                                                                                                                                                                                                                                                                                                Deprecated, use GetFormUint64 instead.

                                                                                                                                                                                                                                                                                                                func (*Request) GetPostVar

                                                                                                                                                                                                                                                                                                                func (r *Request) GetPostVar(key string, def ...interface{}) *gvar.Var

                                                                                                                                                                                                                                                                                                                  Deprecated, use GetFormVar instead.

                                                                                                                                                                                                                                                                                                                  func (*Request) GetQuery

                                                                                                                                                                                                                                                                                                                  func (r *Request) GetQuery(key string, def ...interface{}) interface{}

                                                                                                                                                                                                                                                                                                                    GetQuery retrieves and returns parameter with given name <key> from query string and request body. It returns <def> if <key> does not exist in the query and <def> is given, or else it returns nil.

                                                                                                                                                                                                                                                                                                                    Note that if there're multiple parameters with the same name, the parameters are retrieved and overwrote in order of priority: query > body.

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryArray

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryArray(key string, def ...interface{}) []string

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryBool

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryBool(key string, def ...interface{}) bool

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryFloat32

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryFloat32(key string, def ...interface{}) float32

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryFloat64

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryFloat64(key string, def ...interface{}) float64

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryFloats

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryFloats(key string, def ...interface{}) []float64

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryInt

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryInt(key string, def ...interface{}) int

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryInt32

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryInt32(key string, def ...interface{}) int32

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryInt64

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryInt64(key string, def ...interface{}) int64

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryInterfaces

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryInterfaces(key string, def ...interface{}) []interface{}

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryInts

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryInts(key string, def ...interface{}) []int

                                                                                                                                                                                                                                                                                                                    func (*Request) GetQueryMap

                                                                                                                                                                                                                                                                                                                    func (r *Request) GetQueryMap(kvMap ...map[string]interface{}) map[string]interface{}

                                                                                                                                                                                                                                                                                                                      GetQueryMap retrieves and returns all parameters passed from client using HTTP GET method as map. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                                                      Note that if there're multiple parameters with the same name, the parameters are retrieved and overwrote in order of priority: query > body.

                                                                                                                                                                                                                                                                                                                      func (*Request) GetQueryMapStrStr

                                                                                                                                                                                                                                                                                                                      func (r *Request) GetQueryMapStrStr(kvMap ...map[string]interface{}) map[string]string

                                                                                                                                                                                                                                                                                                                        GetQueryMapStrStr retrieves and returns all parameters passed from client using HTTP GET method as map[string]string. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                                                        func (*Request) GetQueryMapStrVar

                                                                                                                                                                                                                                                                                                                        func (r *Request) GetQueryMapStrVar(kvMap ...map[string]interface{}) map[string]*gvar.Var

                                                                                                                                                                                                                                                                                                                          GetQueryMapStrVar retrieves and returns all parameters passed from client using HTTP GET method as map[string]*gvar.Var. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                                                          func (*Request) GetQueryString

                                                                                                                                                                                                                                                                                                                          func (r *Request) GetQueryString(key string, def ...interface{}) string

                                                                                                                                                                                                                                                                                                                          func (*Request) GetQueryStrings

                                                                                                                                                                                                                                                                                                                          func (r *Request) GetQueryStrings(key string, def ...interface{}) []string

                                                                                                                                                                                                                                                                                                                          func (*Request) GetQueryStruct

                                                                                                                                                                                                                                                                                                                          func (r *Request) GetQueryStruct(pointer interface{}, mapping ...map[string]string) error

                                                                                                                                                                                                                                                                                                                            GetQueryStruct retrieves all parameters passed from client using HTTP GET method and converts them to given struct object. Note that the parameter <pointer> is a pointer to the struct object. The optional parameter <mapping> is used to specify the key to attribute mapping.

                                                                                                                                                                                                                                                                                                                            func (*Request) GetQueryUint

                                                                                                                                                                                                                                                                                                                            func (r *Request) GetQueryUint(key string, def ...interface{}) uint

                                                                                                                                                                                                                                                                                                                            func (*Request) GetQueryUint32

                                                                                                                                                                                                                                                                                                                            func (r *Request) GetQueryUint32(key string, def ...interface{}) uint32

                                                                                                                                                                                                                                                                                                                            func (*Request) GetQueryUint64

                                                                                                                                                                                                                                                                                                                            func (r *Request) GetQueryUint64(key string, def ...interface{}) uint64

                                                                                                                                                                                                                                                                                                                            func (*Request) GetQueryVar

                                                                                                                                                                                                                                                                                                                            func (r *Request) GetQueryVar(key string, def ...interface{}) *gvar.Var

                                                                                                                                                                                                                                                                                                                            func (*Request) GetRaw

                                                                                                                                                                                                                                                                                                                            func (r *Request) GetRaw() []byte

                                                                                                                                                                                                                                                                                                                              GetRaw is alias of GetBody. See GetBody. Deprecated, use GetBody instead.

                                                                                                                                                                                                                                                                                                                              func (*Request) GetRawString

                                                                                                                                                                                                                                                                                                                              func (r *Request) GetRawString() string

                                                                                                                                                                                                                                                                                                                                GetRawString is alias of GetBodyString. See GetBodyString. Deprecated, use GetBodyString instead.

                                                                                                                                                                                                                                                                                                                                func (*Request) GetReferer

                                                                                                                                                                                                                                                                                                                                func (r *Request) GetReferer() string

                                                                                                                                                                                                                                                                                                                                  GetReferer returns referer of this request.

                                                                                                                                                                                                                                                                                                                                  func (*Request) GetRemoteIp

                                                                                                                                                                                                                                                                                                                                  func (r *Request) GetRemoteIp() string

                                                                                                                                                                                                                                                                                                                                    GetRemoteIp returns the ip from RemoteAddr.

                                                                                                                                                                                                                                                                                                                                    func (*Request) GetRequest

                                                                                                                                                                                                                                                                                                                                    func (r *Request) GetRequest(key string, def ...interface{}) interface{}

                                                                                                                                                                                                                                                                                                                                      GetRequest retrieves and returns the parameter named <key> passed from client and custom params as interface{}, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                      GetRequest is one of the most commonly used functions for retrieving parameters.

                                                                                                                                                                                                                                                                                                                                      Note that if there're multiple parameters with the same name, the parameters are retrieved and overwrote in order of priority: router < query < body < form < custom.

                                                                                                                                                                                                                                                                                                                                      func (*Request) GetRequestArray

                                                                                                                                                                                                                                                                                                                                      func (r *Request) GetRequestArray(key string, def ...interface{}) []string

                                                                                                                                                                                                                                                                                                                                        GetRequestArray retrieves and returns the parameter named <key> passed from client and custom params as []string, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                        func (*Request) GetRequestBool

                                                                                                                                                                                                                                                                                                                                        func (r *Request) GetRequestBool(key string, def ...interface{}) bool

                                                                                                                                                                                                                                                                                                                                          GetRequestBool retrieves and returns the parameter named <key> passed from client and custom params as bool, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                          func (*Request) GetRequestFloat32

                                                                                                                                                                                                                                                                                                                                          func (r *Request) GetRequestFloat32(key string, def ...interface{}) float32

                                                                                                                                                                                                                                                                                                                                            GetRequestFloat32 retrieves and returns the parameter named <key> passed from client and custom params as float32, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                            func (*Request) GetRequestFloat64

                                                                                                                                                                                                                                                                                                                                            func (r *Request) GetRequestFloat64(key string, def ...interface{}) float64

                                                                                                                                                                                                                                                                                                                                              GetRequestFloat64 retrieves and returns the parameter named <key> passed from client and custom params as float64, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                              func (*Request) GetRequestFloats

                                                                                                                                                                                                                                                                                                                                              func (r *Request) GetRequestFloats(key string, def ...interface{}) []float64

                                                                                                                                                                                                                                                                                                                                                GetRequestFloats retrieves and returns the parameter named <key> passed from client and custom params as []float64, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                func (*Request) GetRequestInt

                                                                                                                                                                                                                                                                                                                                                func (r *Request) GetRequestInt(key string, def ...interface{}) int

                                                                                                                                                                                                                                                                                                                                                  GetRequestInt retrieves and returns the parameter named <key> passed from client and custom params as int, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                  func (*Request) GetRequestInt32

                                                                                                                                                                                                                                                                                                                                                  func (r *Request) GetRequestInt32(key string, def ...interface{}) int32

                                                                                                                                                                                                                                                                                                                                                    GetRequestInt32 retrieves and returns the parameter named <key> passed from client and custom params as int32, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                    func (*Request) GetRequestInt64

                                                                                                                                                                                                                                                                                                                                                    func (r *Request) GetRequestInt64(key string, def ...interface{}) int64

                                                                                                                                                                                                                                                                                                                                                      GetRequestInt64 retrieves and returns the parameter named <key> passed from client and custom params as int64, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                      func (*Request) GetRequestInterfaces

                                                                                                                                                                                                                                                                                                                                                      func (r *Request) GetRequestInterfaces(key string, def ...interface{}) []interface{}

                                                                                                                                                                                                                                                                                                                                                        GetRequestInterfaces retrieves and returns the parameter named <key> passed from client and custom params as []interface{}, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                        func (*Request) GetRequestInts

                                                                                                                                                                                                                                                                                                                                                        func (r *Request) GetRequestInts(key string, def ...interface{}) []int

                                                                                                                                                                                                                                                                                                                                                          GetRequestInts retrieves and returns the parameter named <key> passed from client and custom params as []int, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                          func (*Request) GetRequestMap

                                                                                                                                                                                                                                                                                                                                                          func (r *Request) GetRequestMap(kvMap ...map[string]interface{}) map[string]interface{}

                                                                                                                                                                                                                                                                                                                                                            GetRequestMap retrieves and returns all parameters passed from client and custom params as map, no matter what HTTP method the client is using. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass the according keys.

                                                                                                                                                                                                                                                                                                                                                            GetRequestMap is one of the most commonly used functions for retrieving parameters.

                                                                                                                                                                                                                                                                                                                                                            Note that if there're multiple parameters with the same name, the parameters are retrieved and overwrote in order of priority: router < query < body < form < custom.

                                                                                                                                                                                                                                                                                                                                                            func (*Request) GetRequestMapStrStr

                                                                                                                                                                                                                                                                                                                                                            func (r *Request) GetRequestMapStrStr(kvMap ...map[string]interface{}) map[string]string

                                                                                                                                                                                                                                                                                                                                                              GetRequestMapStrStr retrieves and returns all parameters passed from client and custom params as map[string]string, no matter what HTTP method the client is using. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                                                                                              func (*Request) GetRequestMapStrVar

                                                                                                                                                                                                                                                                                                                                                              func (r *Request) GetRequestMapStrVar(kvMap ...map[string]interface{}) map[string]*gvar.Var

                                                                                                                                                                                                                                                                                                                                                                GetRequestMapStrVar retrieves and returns all parameters passed from client and custom params as map[string]*gvar.Var, no matter what HTTP method the client is using. The parameter <kvMap> specifies the keys retrieving from client parameters, the associated values are the default values if the client does not pass.

                                                                                                                                                                                                                                                                                                                                                                func (*Request) GetRequestString

                                                                                                                                                                                                                                                                                                                                                                func (r *Request) GetRequestString(key string, def ...interface{}) string

                                                                                                                                                                                                                                                                                                                                                                  GetRequestString retrieves and returns the parameter named <key> passed from client and custom params as string, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                  func (*Request) GetRequestStrings

                                                                                                                                                                                                                                                                                                                                                                  func (r *Request) GetRequestStrings(key string, def ...interface{}) []string

                                                                                                                                                                                                                                                                                                                                                                    GetRequestStrings retrieves and returns the parameter named <key> passed from client and custom params as []string, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                    func (*Request) GetRequestStruct

                                                                                                                                                                                                                                                                                                                                                                    func (r *Request) GetRequestStruct(pointer interface{}, mapping ...map[string]string) error

                                                                                                                                                                                                                                                                                                                                                                      GetRequestStruct retrieves all parameters passed from client and custom params no matter what HTTP method the client is using, and converts them to given struct object. Note that the parameter <pointer> is a pointer to the struct object. The optional parameter <mapping> is used to specify the key to attribute mapping.

                                                                                                                                                                                                                                                                                                                                                                      func (*Request) GetRequestUint

                                                                                                                                                                                                                                                                                                                                                                      func (r *Request) GetRequestUint(key string, def ...interface{}) uint

                                                                                                                                                                                                                                                                                                                                                                        GetRequestUint retrieves and returns the parameter named <key> passed from client and custom params as uint, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                        func (*Request) GetRequestUint32

                                                                                                                                                                                                                                                                                                                                                                        func (r *Request) GetRequestUint32(key string, def ...interface{}) uint32

                                                                                                                                                                                                                                                                                                                                                                          GetRequestUint32 retrieves and returns the parameter named <key> passed from client and custom params as uint32, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                          func (*Request) GetRequestUint64

                                                                                                                                                                                                                                                                                                                                                                          func (r *Request) GetRequestUint64(key string, def ...interface{}) uint64

                                                                                                                                                                                                                                                                                                                                                                            GetRequestUint64 retrieves and returns the parameter named <key> passed from client and custom params as uint64, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                            func (*Request) GetRequestVar

                                                                                                                                                                                                                                                                                                                                                                            func (r *Request) GetRequestVar(key string, def ...interface{}) *gvar.Var

                                                                                                                                                                                                                                                                                                                                                                              GetRequestVar retrieves and returns the parameter named <key> passed from client and custom params as gvar.Var, no matter what HTTP method the client is using. The parameter <def> specifies the default value if the <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                              func (*Request) GetRouterMap

                                                                                                                                                                                                                                                                                                                                                                              func (r *Request) GetRouterMap() map[string]string

                                                                                                                                                                                                                                                                                                                                                                                GetRouterMap retrieves and returns a copy of router map.

                                                                                                                                                                                                                                                                                                                                                                                func (*Request) GetRouterString

                                                                                                                                                                                                                                                                                                                                                                                func (r *Request) GetRouterString(key string, def ...interface{}) string

                                                                                                                                                                                                                                                                                                                                                                                  GetRouterString retrieves and returns the router value as string with given key name <key>. It returns <def> if <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                                  func (*Request) GetRouterValue

                                                                                                                                                                                                                                                                                                                                                                                  func (r *Request) GetRouterValue(key string, def ...interface{}) interface{}

                                                                                                                                                                                                                                                                                                                                                                                    GetRouterValue retrieves and returns the router value with given key name <key>. It returns <def> if <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                                    func (*Request) GetRouterVar

                                                                                                                                                                                                                                                                                                                                                                                    func (r *Request) GetRouterVar(key string, def ...interface{}) *gvar.Var

                                                                                                                                                                                                                                                                                                                                                                                      GetRouterVar retrieves and returns the router value as gvar.Var with given key name <key>. It returns <def> if <key> does not exist.

                                                                                                                                                                                                                                                                                                                                                                                      func (*Request) GetSessionId

                                                                                                                                                                                                                                                                                                                                                                                      func (r *Request) GetSessionId() string

                                                                                                                                                                                                                                                                                                                                                                                        GetSessionId retrieves and returns session id from cookie or header.

                                                                                                                                                                                                                                                                                                                                                                                        func (*Request) GetString

                                                                                                                                                                                                                                                                                                                                                                                        func (r *Request) GetString(key string, def ...interface{}) string

                                                                                                                                                                                                                                                                                                                                                                                          GetString is an alias and convenient function for GetRequestString. See GetRequestString.

                                                                                                                                                                                                                                                                                                                                                                                          func (*Request) GetStrings

                                                                                                                                                                                                                                                                                                                                                                                          func (r *Request) GetStrings(key string, def ...interface{}) []string

                                                                                                                                                                                                                                                                                                                                                                                            GetStrings is an alias and convenient function for GetRequestStrings. See GetRequestStrings.

                                                                                                                                                                                                                                                                                                                                                                                            func (*Request) GetStruct

                                                                                                                                                                                                                                                                                                                                                                                            func (r *Request) GetStruct(pointer interface{}, mapping ...map[string]string) error

                                                                                                                                                                                                                                                                                                                                                                                              GetStruct is an alias and convenient function for GetRequestStruct. See GetRequestStruct.

                                                                                                                                                                                                                                                                                                                                                                                              func (*Request) GetUint

                                                                                                                                                                                                                                                                                                                                                                                              func (r *Request) GetUint(key string, def ...interface{}) uint

                                                                                                                                                                                                                                                                                                                                                                                                GetUint is an alias and convenient function for GetRequestUint. See GetRequestUint.

                                                                                                                                                                                                                                                                                                                                                                                                func (*Request) GetUint32

                                                                                                                                                                                                                                                                                                                                                                                                func (r *Request) GetUint32(key string, def ...interface{}) uint32

                                                                                                                                                                                                                                                                                                                                                                                                  GetUint32 is an alias and convenient function for GetRequestUint32. See GetRequestUint32.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*Request) GetUint64

                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Request) GetUint64(key string, def ...interface{}) uint64

                                                                                                                                                                                                                                                                                                                                                                                                    GetUint64 is an alias and convenient function for GetRequestUint64. See GetRequestUint64.

                                                                                                                                                                                                                                                                                                                                                                                                    func (*Request) GetUploadFile

                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Request) GetUploadFile(name string) *UploadFile

                                                                                                                                                                                                                                                                                                                                                                                                      GetUploadFile retrieves and returns the uploading file with specified form name. This function is used for retrieving single uploading file object, which is uploaded using multipart form content type.

                                                                                                                                                                                                                                                                                                                                                                                                      It returns nil if retrieving failed or no form file with given name posted.

                                                                                                                                                                                                                                                                                                                                                                                                      Note that the <name> is the file field name of the multipart form from client.

                                                                                                                                                                                                                                                                                                                                                                                                      func (*Request) GetUploadFiles

                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Request) GetUploadFiles(name string) UploadFiles

                                                                                                                                                                                                                                                                                                                                                                                                        GetUploadFiles retrieves and returns multiple uploading files with specified form name. This function is used for retrieving multiple uploading file objects, which are uploaded using multipart form content type.

                                                                                                                                                                                                                                                                                                                                                                                                        It returns nil if retrieving failed or no form file with given name posted.

                                                                                                                                                                                                                                                                                                                                                                                                        Note that the <name> is the file field name of the multipart form from client.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*Request) GetUrl

                                                                                                                                                                                                                                                                                                                                                                                                        func (r *Request) GetUrl() string

                                                                                                                                                                                                                                                                                                                                                                                                          GetUrl returns current URL of this request.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*Request) GetVar

                                                                                                                                                                                                                                                                                                                                                                                                          func (r *Request) GetVar(key string, def ...interface{}) *gvar.Var

                                                                                                                                                                                                                                                                                                                                                                                                            GetVar is alis of GetRequestVar. See GetRequestVar.

                                                                                                                                                                                                                                                                                                                                                                                                            func (*Request) GetView

                                                                                                                                                                                                                                                                                                                                                                                                            func (r *Request) GetView() *gview.View

                                                                                                                                                                                                                                                                                                                                                                                                              GetView returns the template view engine object for this request.

                                                                                                                                                                                                                                                                                                                                                                                                              func (*Request) IsAjaxRequest

                                                                                                                                                                                                                                                                                                                                                                                                              func (r *Request) IsAjaxRequest() bool

                                                                                                                                                                                                                                                                                                                                                                                                                IsAjaxRequest checks and returns whether current request is an AJAX request.

                                                                                                                                                                                                                                                                                                                                                                                                                func (*Request) IsExited

                                                                                                                                                                                                                                                                                                                                                                                                                func (r *Request) IsExited() bool

                                                                                                                                                                                                                                                                                                                                                                                                                  IsExited checks and returns whether current request is exited.

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Request) IsFileRequest

                                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Request) IsFileRequest() bool

                                                                                                                                                                                                                                                                                                                                                                                                                    IsFileRequest checks and returns whether current request is serving file.

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Request) Parse

                                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Request) Parse(pointer interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                      Parse is the most commonly used function, which converts request parameters to struct or struct slice. It also automatically validates the struct or every element of the struct slice according to the validation tag of the struct.

                                                                                                                                                                                                                                                                                                                                                                                                                      The parameter <pointer> can be type of: *struct/**struct/*[]struct/*[]*struct.

                                                                                                                                                                                                                                                                                                                                                                                                                      It supports single and multiple struct convertion: 1. Single struct, post content like: {"id":1, "name":"john"} or ?id=1&name=john 2. Multiple struct, post content like: [{"id":1, "name":"john"}, {"id":, "name":"smith"}]

                                                                                                                                                                                                                                                                                                                                                                                                                      TODO: Improve the performance by reducing duplicated reflect usage on the same variable across packages.

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Request) ParseForm

                                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Request) ParseForm(pointer interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                        ParseForm performs like function Parse, but only parses the form parameters or the body content.

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Request) ParseQuery

                                                                                                                                                                                                                                                                                                                                                                                                                        func (r *Request) ParseQuery(pointer interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                          ParseQuery performs like function Parse, but only parses the query parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Request) ReloadParam

                                                                                                                                                                                                                                                                                                                                                                                                                          func (r *Request) ReloadParam()

                                                                                                                                                                                                                                                                                                                                                                                                                            ReloadParam is used for modifying request parameter. Sometimes, we want to modify request parameters through middleware, but directly modifying Request.Body is invalid, so it clears the parsed* marks to make the parameters re-parsed.

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Request) SetCtx

                                                                                                                                                                                                                                                                                                                                                                                                                            func (r *Request) SetCtx(ctx context.Context)

                                                                                                                                                                                                                                                                                                                                                                                                                              SetCtx custom context for current request.

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Request) SetCtxVar

                                                                                                                                                                                                                                                                                                                                                                                                                              func (r *Request) SetCtxVar(key interface{}, value interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                SetCtxVar sets custom parameter to context with key-value pair.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Request) SetForm

                                                                                                                                                                                                                                                                                                                                                                                                                                func (r *Request) SetForm(key string, value interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                  SetForm sets custom form value with key-value pair.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Request) SetParam

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Request) SetParam(key string, value interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                    SetParam sets custom parameter with key-value pair.

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Request) SetQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Request) SetQuery(key string, value interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                      SetQuery sets custom query value with key-value pair.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Request) SetView

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Request) SetView(view *gview.View)

                                                                                                                                                                                                                                                                                                                                                                                                                                        SetView sets template view engine object for this request.

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Request) WebSocket

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (r *Request) WebSocket() (*WebSocket, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                          WebSocket upgrades current request as a websocket request. It returns a new WebSocket object if success, or the error if failure. Note that the request should be a websocket request, or it will surely fail upgrading.

                                                                                                                                                                                                                                                                                                                                                                                                                                          type Response

                                                                                                                                                                                                                                                                                                                                                                                                                                          type Response struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                          	*ResponseWriter                 // Underlying ResponseWriter.
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Server          *Server         // Parent server.
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Writer          *ResponseWriter // Alias of ResponseWriter.
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Request         *Request        // According request.
                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                            Response is the http response manager. Note that it implements the http.ResponseWriter interface with buffering feature.

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Response) Buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (r *Response) Buffer() []byte

                                                                                                                                                                                                                                                                                                                                                                                                                                              BufferString returns the buffered content as []byte.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Response) BufferLength

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (r *Response) BufferLength() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                BufferLength returns the length of the buffered content.

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Response) BufferString

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (r *Response) BufferString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                  BufferString returns the buffered content as string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Response) CORS

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Response) CORS(options CORSOptions)

                                                                                                                                                                                                                                                                                                                                                                                                                                                    CORS sets custom CORS options. See https://www.w3.org/TR/cors/ .

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Response) CORSAllowedOrigin

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Response) CORSAllowedOrigin(options CORSOptions) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                      CORSAllowed checks whether the current request origin is allowed cross-domain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Response) CORSDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Response) CORSDefault()

                                                                                                                                                                                                                                                                                                                                                                                                                                                        CORSDefault sets CORS with default CORS options, which allows any cross-domain request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Response) ClearBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (r *Response) ClearBuffer()

                                                                                                                                                                                                                                                                                                                                                                                                                                                          ClearBuffer clears the response buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Response) DefaultCORSOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (r *Response) DefaultCORSOptions() CORSOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                            DefaultCORSOptions returns the default CORS options, which allows any cross-domain request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Response) Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (r *Response) Flush()

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output outputs the buffer content to the client and clears the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Response) ParseTpl

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (r *Response) ParseTpl(tpl string, params ...gview.Params) (string, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                ParseTpl parses given template file <tpl> with given template variables <params> and returns the parsed template content.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Response) ParseTplContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (r *Response) ParseTplContent(content string, params ...gview.Params) (string, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ParseTplContent parses given template file <file> with given template parameters <params> and returns the parsed template content.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Response) ParseTplDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Response) ParseTplDefault(params ...gview.Params) (string, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ParseDefault parses the default template file with params.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Response) RedirectBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Response) RedirectBack(code ...int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RedirectBack redirects client back to referer. The optional parameter <code> specifies the http status code for redirecting, which commonly can be 301 or 302. It's 302 in default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Response) RedirectTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Response) RedirectTo(location string, code ...int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RedirectTo redirects client to another location. The optional parameter <code> specifies the http status code for redirecting, which commonly can be 301 or 302. It's 302 in default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Response) ServeFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (r *Response) ServeFile(path string, allowIndex ...bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ServeFile serves the file to the response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Response) ServeFileDownload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (r *Response) ServeFileDownload(path string, name ...string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ServeFileDownload serves file downloading to the response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Response) SetBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (r *Response) SetBuffer(data []byte)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetBuffer overwrites the buffer with <data>.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Response) Write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (r *Response) Write(content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Write writes <content> to the response buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Response) WriteExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (r *Response) WriteExit(content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WriteExit writes <content> to the response buffer and exits executing of current handler. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Response) WriteJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Response) WriteJson(content interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WriteJson writes <content> to the response with JSON format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Response) WriteJsonExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Response) WriteJsonExit(content interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WriteJsonExit writes <content> to the response with JSON format and exits executing of current handler if success. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Response) WriteJsonP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Response) WriteJsonP(content interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WriteJson writes <content> to the response with JSONP format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Note that there should be a "callback" parameter in the request for JSONP format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Response) WriteJsonPExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (r *Response) WriteJsonPExit(content interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WriteJsonPExit writes <content> to the response with JSONP format and exits executing of current handler if success. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Note that there should be a "callback" parameter in the request for JSONP format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Response) WriteOver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (r *Response) WriteOver(content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WriteOver overwrites the response buffer with <content>.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Response) WriteOverExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (r *Response) WriteOverExit(content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WriteOverExit overwrites the response buffer with <content> and exits executing of current handler. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Response) WriteStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (r *Response) WriteStatus(status int, content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WriteStatus writes HTTP <status> and <content> to the response. Note that do not set Content-Type header here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Response) WriteStatusExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (r *Response) WriteStatusExit(status int, content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WriteStatusExit writes HTTP <status> and <content> to the response and exits executing of current handler if success. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Response) WriteTpl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Response) WriteTpl(tpl string, params ...gview.Params) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WriteTpl parses and responses given template file. The parameter <params> specifies the template variables for parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Response) WriteTplContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Response) WriteTplContent(content string, params ...gview.Params) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WriteTplContent parses and responses the template content. The parameter <params> specifies the template variables for parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Response) WriteTplDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Response) WriteTplDefault(params ...gview.Params) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WriteTplDefault parses and responses the default template file. The parameter <params> specifies the template variables for parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Response) WriteXml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (r *Response) WriteXml(content interface{}, rootTag ...string) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WriteXml writes <content> to the response with XML format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Response) WriteXmlExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (r *Response) WriteXmlExit(content interface{}, rootTag ...string) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WriteXmlExit writes <content> to the response with XML format and exits executing of current handler if success. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Response) Writef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (r *Response) Writef(format string, params ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Writef writes the response with fmt.Sprintf.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Response) WritefExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (r *Response) WritefExit(format string, params ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WritefExit writes the response with fmt.Sprintf and exits executing of current handler. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Response) Writefln

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (r *Response) Writefln(format string, params ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Writefln writes the response with fmt.Sprintf and new line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Response) WriteflnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (r *Response) WriteflnExit(format string, params ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WriteflnExit writes the response with fmt.Sprintf and new line and exits executing of current handler. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Response) Writeln

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (r *Response) Writeln(content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writef writes the response with <content> and new line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Response) WritelnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (r *Response) WritelnExit(content ...interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WritelnExit writes the response with <content> and new line and exits executing of current handler. The "Exit" feature is commonly used to replace usage of return statement in the handler, for convenience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ResponseWriter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ResponseWriter struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Status int // HTTP status.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ResponseWriter is the custom writer for http response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ResponseWriter) Flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (w *ResponseWriter) Flush()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OutputBuffer outputs the buffer to client and clears the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ResponseWriter) Header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (w *ResponseWriter) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Header implements the interface function of http.ResponseWriter.Header.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ResponseWriter) Hijack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (w *ResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Hijack implements the interface function of http.Hijacker.Hijack.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ResponseWriter) RawWriter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (w *ResponseWriter) RawWriter() http.ResponseWriter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RawWriter returns the underlying ResponseWriter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ResponseWriter) Write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (w *ResponseWriter) Write(data []byte) (int, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Write implements the interface function of http.ResponseWriter.Write.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ResponseWriter) WriteHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (w *ResponseWriter) WriteHeader(status int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WriteHeader implements the interface of http.ResponseWriter.WriteHeader.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Router

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Router struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Uri      string   // URI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Method   string   // HTTP method
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Domain   string   // Bound domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	RegRule  string   // Parsed regular expression for route matching.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	RegNames []string // Parsed router parameter names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Priority int      // Just for reference.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Router object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RouterGroup struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          RouterGroup is a group wrapping multiple routes and middleware.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*RouterGroup) ALL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (g *RouterGroup) ALL(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ALL registers a http handler to given route pattern and all http methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*RouterGroup) ALLMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (g *RouterGroup) ALLMap(m map[string]interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ALLMap registers http handlers for http methods using map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*RouterGroup) Bind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (g *RouterGroup) Bind(items []GroupItem) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Bind does batch route registering feature for router group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*RouterGroup) CONNECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (g *RouterGroup) CONNECT(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CONNECT registers a http handler to given route pattern and http method: CONNECT.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*RouterGroup) Clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (g *RouterGroup) Clone() *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Clone returns a new router group which is a clone of current group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*RouterGroup) DELETE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (g *RouterGroup) DELETE(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DELETE registers a http handler to given route pattern and http method: DELETE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*RouterGroup) GET

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (g *RouterGroup) GET(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GET registers a http handler to given route pattern and http method: GET.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*RouterGroup) Group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (g *RouterGroup) Group(prefix string, groups ...func(group *RouterGroup)) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Group creates and returns a sub-group of current router group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*RouterGroup) HEAD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (g *RouterGroup) HEAD(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HEAD registers a http handler to given route pattern and http method: HEAD.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*RouterGroup) Hook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (g *RouterGroup) Hook(pattern string, hook string, handler HandlerFunc) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Hook registers a hook to given route pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*RouterGroup) Middleware

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (g *RouterGroup) Middleware(handlers ...HandlerFunc) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Middleware binds one or more middleware to the router group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*RouterGroup) OPTIONS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (g *RouterGroup) OPTIONS(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OPTIONS registers a http handler to given route pattern and http method: OPTIONS.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*RouterGroup) PATCH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (g *RouterGroup) PATCH(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PATCH registers a http handler to given route pattern and http method: PATCH.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*RouterGroup) POST

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (g *RouterGroup) POST(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      POST registers a http handler to given route pattern and http method: POST.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*RouterGroup) PUT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (g *RouterGroup) PUT(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PUT registers a http handler to given route pattern and http method: PUT.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*RouterGroup) REST

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (g *RouterGroup) REST(pattern string, object interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          REST registers a http handler to given route pattern according to REST rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*RouterGroup) TRACE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (g *RouterGroup) TRACE(pattern string, object interface{}, params ...interface{}) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TRACE registers a http handler to given route pattern and http method: TRACE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RouterItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RouterItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Server           string // Server name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Address          string // Listening address.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Domain           string // Bound domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Type             int    // Router type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Middleware       string // Bound middleware.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Method           string // Handler method name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Route            string // Route URI.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Priority         int    // Just for reference.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IsServiceHandler bool   // Is service handler.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Router item just for route dumps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Server struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Server wraps the http.Server and provides more feature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetServer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetServer(name ...interface{}) *Server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetServer creates and returns a server instance using given name and default configurations. Note that the parameter <name> should be unique for different servers. It returns an existing server instance if given <name> is already existing in the server mapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) AddSearchPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) AddSearchPath(path string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AddSearchPath add searching directory path for static file service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) AddStaticPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) AddStaticPath(prefix string, path string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AddStaticPath sets the uri to static directory path mapping for static file service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) BindController

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) BindController(pattern string, controller Controller, method ...string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BindController registers controller to server routes with specified pattern. The controller needs to implement the gmvc.Controller interface. Each request of the controller bound in this way will initialize a new controller object for processing, corresponding to different request sessions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The optional parameter <method> is used to specify the method to be registered, which supports multiple method names, multiple methods are separated by char ',', case sensitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) BindControllerMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) BindControllerMethod(pattern string, controller Controller, method string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BindControllerMethod registers specified method to server routes with specified pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The optional parameter <method> is used to specify the method to be registered, which does not supports multiple method names but only one, case sensitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) BindControllerRest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) BindControllerRest(pattern string, controller Controller)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BindControllerRest registers controller in REST API style to server with specified pattern. The controller needs to implement the gmvc.Controller interface. Each request of the controller bound in this way will initialize a new controller object for processing, corresponding to different request sessions. The method will recognize the HTTP method and do REST binding, for example: The method "Post" of controller will be bound to the HTTP POST method request processing, and the method "Delete" will be bound to the HTTP DELETE method request processing. Therefore, only the method corresponding to the HTTP Method will be bound, other methods will not automatically register the binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) BindHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) BindHandler(pattern string, handler HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BindHandler registers a handler function to server with given pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) BindHookHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) BindHookHandler(pattern string, hook string, handler HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BindHookHandler registers handler for specified hook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) BindHookHandlerByMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) BindHookHandlerByMap(pattern string, hookMap map[string]HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) BindMiddleware

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) BindMiddleware(pattern string, handlers ...HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BindMiddleware registers one or more global middleware to the server. Global middleware can be used standalone without service handler, which intercepts all dynamic requests before or after service handler. The parameter <pattern> specifies what route pattern the middleware intercepts, which is usually a "fuzzy" pattern like "/:name", "/*any" or "/{field}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) BindMiddlewareDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) BindMiddlewareDefault(handlers ...HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BindMiddlewareDefault registers one or more global middleware to the server using default pattern "/*". Global middleware can be used standalone without service handler, which intercepts all dynamic requests before or after service handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) BindObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) BindObject(pattern string, object interface{}, method ...string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BindObject registers object to server routes with given pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The optional parameter <method> is used to specify the method to be registered, which supports multiple method names, multiple methods are separated by char ',', case sensitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Note that the route method should be defined as ghttp.HandlerFunc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) BindObjectMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) BindObjectMethod(pattern string, object interface{}, method string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BindObjectMethod registers specified method of object to server routes with given pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The optional parameter <method> is used to specify the method to be registered, which does not supports multiple method names but only one, case sensitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Note that the route method should be defined as ghttp.HandlerFunc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) BindObjectRest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) BindObjectRest(pattern string, object interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BindObjectRest registers object in REST API style to server with specified pattern. Note that the route method should be defined as ghttp.HandlerFunc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) BindStatusHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) BindStatusHandler(status int, handler HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BindStatusHandler registers handler for given status code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) BindStatusHandlerByMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) BindStatusHandlerByMap(handlerMap map[int]HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BindStatusHandlerByMap registers handler for given status code using map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) Domain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) Domain(domains string) *Domain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Domain creates and returns a domain object for management for one or more domains.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) EnableAdmin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) EnableAdmin(pattern ...string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  EnableAdmin enables the administration feature for the process. The optional parameter <pattern> specifies the URI for the administration page.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) EnableHTTPS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) EnableHTTPS(certFile, keyFile string, tlsConfig ...*tls.Config)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnableHTTPS enables HTTPS with given certification and key files for the server. The optional parameter <tlsConfig> specifies custom TLS configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) EnablePProf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) EnablePProf(pattern ...string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EnablePProf enables PProf feature for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) GetCookieDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) GetCookieDomain() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetCookieDomain returns CookieDomain of server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) GetCookieMaxAge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) GetCookieMaxAge() time.Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetCookieMaxAge returns the CookieMaxAge of server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) GetCookiePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) GetCookiePath() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetCookiePath returns the CookiePath of server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) GetIndexFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) GetIndexFiles() []string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetIndexFiles retrieves and returns the index files from server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) GetLogPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) GetLogPath() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetLogPath returns the log path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) GetName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) GetName() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetName returns the name of the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) GetRouterArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) GetRouterArray() []RouterItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetRouterArray retrieves and returns the router array. The key of the returned map is the domain of the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) GetSessionCookieMaxAge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) GetSessionCookieMaxAge() time.Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetSessionCookieMaxAge returns the SessionCookieMaxAge of server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) GetSessionIdName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) GetSessionIdName() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetSessionIdName returns the SessionIdName of server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) GetSessionMaxAge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) GetSessionMaxAge() time.Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetSessionMaxAge returns the SessionMaxAge of server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) Group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) Group(prefix string, groups ...func(group *RouterGroup)) *RouterGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Group creates and returns a RouterGroup object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) Handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) Handler() http.Handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Handler returns the request handler of the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) IsAccessLogEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) IsAccessLogEnabled() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                IsAccessLogEnabled checks whether the access log enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) IsErrorLogEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) IsErrorLogEnabled() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IsErrorLogEnabled checks whether the error log enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) Logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) Logger() *glog.Logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Logger returns the logger of the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) Plugin(plugin ...Plugin)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plugin adds plugin to server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) Run()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Run starts server listening in blocking way. It's commonly used for single server situation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) ServeHTTP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ServeHTTP is the default handler for http request. It should not create new goroutine handling the request as it's called by am already created new goroutine from http.Server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This function also make serve implementing the interface of http.Handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) SetAccessLogEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) SetAccessLogEnabled(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetAccessLogEnabled enables/disables the access log.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) SetAddr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) SetAddr(address string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetAddr sets the listening address for the server. The address is like ':80', '0.0.0.0:80', '127.0.0.1:80', '180.18.99.10:80', etc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) SetClientMaxBodySize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) SetClientMaxBodySize(maxSize int64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetClientMaxBodySize sets the ClientMaxBodySize for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) SetConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) SetConfig(c ServerConfig) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetConfig sets the configuration for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) SetConfigWithMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) SetConfigWithMap(m map[string]interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetConfigWithMap sets the configuration for the server using map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) SetCookieDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) SetCookieDomain(domain string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetCookieDomain sets the CookieDomain for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) SetCookieMaxAge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) SetCookieMaxAge(ttl time.Duration)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetCookieMaxAge sets the CookieMaxAge for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) SetCookiePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) SetCookiePath(path string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetCookiePath sets the CookiePath for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) SetDumpRouterMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) SetDumpRouterMap(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetDumpRouterMap sets the DumpRouterMap for server. If DumpRouterMap is enabled, it automatically dumps the route map when server starts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) SetErrorLogEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) SetErrorLogEnabled(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetErrorLogEnabled enables/disables the error log.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) SetErrorStack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) SetErrorStack(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetErrorStack enables/disables the error stack feature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) SetFileServerEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) SetFileServerEnabled(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetFileServerEnabled enables/disables the static file service. It's the main switch for the static file service. When static file service configuration functions like SetServerRoot, AddSearchPath and AddStaticPath are called, this configuration is automatically enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) SetFormParsingMemory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) SetFormParsingMemory(maxMemory int64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetFormParsingMemory sets the FormParsingMemory for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) SetHTTPSAddr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) SetHTTPSAddr(address string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetHTTPSAddr sets the HTTPS listening ports for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) SetHTTPSPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) SetHTTPSPort(port ...int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetHTTPSPort sets the HTTPS listening ports for the server. The listening ports can be multiple like: SetHTTPSPort(443, 500).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) SetIdleTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) SetIdleTimeout(t time.Duration)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetIdleTimeout sets the IdleTimeout for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) SetIndexFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) SetIndexFiles(indexFiles []string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetIndexFiles sets the index files for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) SetIndexFolder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) SetIndexFolder(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetIndexFolder enables/disables listing the sub-files if requesting a directory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) SetKeepAlive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) SetKeepAlive(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetKeepAlive sets the KeepAlive for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) SetLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) SetLogLevel(level string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetLogLevel sets logging level by level string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) SetLogPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) SetLogPath(path string) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetLogPath sets the log path for server. It logs content to file only if the log path is set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) SetLogStdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) SetLogStdout(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetLogStdout sets whether output the logging content to stdout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) SetMaxHeaderBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) SetMaxHeaderBytes(b int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetMaxHeaderBytes sets the MaxHeaderBytes for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) SetNameToUriType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) SetNameToUriType(t int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetNameToUriType sets the NameToUriType for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) SetPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) SetPort(port ...int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetPort sets the listening ports for the server. The listening ports can be multiple like: SetPort(80, 8080).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) SetReadTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) SetReadTimeout(t time.Duration)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetReadTimeout sets the ReadTimeout for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) SetRewrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) SetRewrite(uri string, rewrite string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetRewrite sets rewrites for static URI for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) SetRewriteMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) SetRewriteMap(rewrites map[string]string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetRewriteMap sets the rewrite map for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) SetRouteOverWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) SetRouteOverWrite(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetRouteOverWrite sets the RouteOverWrite for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) SetServerAgent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) SetServerAgent(agent string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetServerAgent sets the ServerAgent for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) SetServerRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) SetServerRoot(root string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetServerRoot sets the document root for static service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) SetSessionCookieMaxAge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) SetSessionCookieMaxAge(maxAge time.Duration)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetSessionCookieMaxAge sets the SessionCookieMaxAge for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) SetSessionCookieOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) SetSessionCookieOutput(enabled bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetSessionCookieOutput sets the SetSessionCookieOutput for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) SetSessionIdName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) SetSessionIdName(name string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetSessionIdName sets the SessionIdName for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) SetSessionMaxAge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) SetSessionMaxAge(ttl time.Duration)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetSessionMaxAge sets the SessionMaxAge for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Server) SetSessionStorage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Server) SetSessionStorage(storage gsession.Storage)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetSessionStorage sets the SessionStorage for server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Server) SetTLSConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Server) SetTLSConfig(tlsConfig *tls.Config)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetTLSConfig sets custom TLS configuration and enables HTTPS feature for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Server) SetView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Server) SetView(view *gview.View)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetView sets the View for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Server) SetWriteTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Server) SetWriteTimeout(t time.Duration)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetWriteTimeout sets the WriteTimeout for the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Server) Shutdown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Server) Shutdown() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Shutdown shuts down current server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Server) Start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Server) Start() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Start starts listening on configured port. This function does not block the process, you can use function Wait blocking the process.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Server) Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Server) Status() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Status retrieves and returns the server status.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Server) Use

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Server) Use(handlers ...HandlerFunc)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use is alias of BindMiddlewareDefault. See BindMiddlewareDefault.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ServerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ServerConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Address specifies the server listening address like "port" or ":port",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// multiple addresses joined using ','.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Address string `json:"address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// HTTPSAddr specifies the HTTPS addresses, multiple addresses joined using char ','.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HTTPSAddr string `json:"httpsAddr"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// HTTPSCertPath specifies certification file path for HTTPS service.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HTTPSCertPath string `json:"httpsCertPath"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// HTTPSKeyPath specifies the key file path for HTTPS service.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HTTPSKeyPath string `json:"httpsKeyPath"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// TLSConfig optionally provides a TLS configuration for use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// by ServeTLS and ListenAndServeTLS. Note that this value is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// cloned by ServeTLS and ListenAndServeTLS, so it's not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// possible to modify the configuration with methods like
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// tls.Config.SetSessionTicketKeys. To use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SetSessionTicketKeys, use Server.Serve with a TLS Listener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TLSConfig *tls.Config `json:"tlsConfig"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Handler the handler for HTTP request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Handler http.Handler `json:"-"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// 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 time.Duration `json:"readTimeout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// 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 time.Duration `json:"writeTimeout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// 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, there is no timeout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IdleTimeout time.Duration `json:"idleTimeout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// 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.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It can be configured in configuration file using string like: 1m, 10m, 500kb etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It's 10240 bytes in default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	MaxHeaderBytes int `json:"maxHeaderBytes"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// KeepAlive enables HTTP keep-alive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	KeepAlive bool `json:"keepAlive"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ServerAgent specifies the server agent information, which is wrote to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// HTTP response header as "Server".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ServerAgent string `json:"serverAgent"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// View specifies the default template view object for the server.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	View *gview.View `json:"view"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Rewrites specifies the URI rewrite rules map.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Rewrites map[string]string `json:"rewrites"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// IndexFiles specifies the index files for static folder.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IndexFiles []string `json:"indexFiles"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// IndexFolder specifies if listing sub-files when requesting folder.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The server responses HTTP status code 403 if it is false.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IndexFolder bool `json:"indexFolder"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ServerRoot specifies the root directory for static service.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ServerRoot string `json:"serverRoot"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SearchPaths specifies additional searching directories for static service.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SearchPaths []string `json:"searchPaths"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// StaticPaths specifies URI to directory mapping array.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	StaticPaths []staticPathItem `json:"staticPaths"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// FileServerEnabled is the global switch for static service.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It is automatically set enabled if any static path is set.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	FileServerEnabled bool `json:"fileServerEnabled"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CookieMaxAge specifies the max TTL for cookie items.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CookieMaxAge time.Duration `json:"cookieMaxAge"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CookiePath specifies cookie path.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It also affects the default storage for session id.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CookiePath string `json:"cookiePath"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CookieDomain specifies cookie domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It also affects the default storage for session id.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CookieDomain string `json:"cookieDomain"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SessionIdName specifies the session id name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SessionIdName string `json:"sessionIdName"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SessionMaxAge specifies max TTL for session items.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SessionMaxAge time.Duration `json:"sessionMaxAge"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SessionPath specifies the session storage directory path for storing session files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It only makes sense if the session storage is type of file storage.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SessionPath string `json:"sessionPath"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SessionStorage specifies the session storage.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SessionStorage gsession.Storage `json:"sessionStorage"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SessionCookieMaxAge specifies the cookie ttl for session id.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It it is set 0, it means it expires along with browser session.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SessionCookieMaxAge time.Duration `json:"sessionCookieMaxAge"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SessionCookieOutput specifies whether automatic outputting session id to cookie.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SessionCookieOutput bool `json:"sessionCookieOutput"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ==================================
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Logging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ==================================
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Logger           *glog.Logger `json:"logger"`           // Logger specifies the logger for server.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LogPath          string       `json:"logPath"`          // LogPath specifies the directory for storing logging files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LogLevel         string       `json:"logLevel"`         // LogLevel specifies the logging level for logger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LogStdout        bool         `json:"logStdout"`        // LogStdout specifies whether printing logging content to stdout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ErrorStack       bool         `json:"errorStack"`       // ErrorStack specifies whether logging stack information when error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ErrorLogEnabled  bool         `json:"errorLogEnabled"`  // ErrorLogEnabled enables error logging content to files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ErrorLogPattern  string       `json:"errorLogPattern"`  // ErrorLogPattern specifies the error log file pattern like: error-{Ymd}.log
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AccessLogEnabled bool         `json:"accessLogEnabled"` // AccessLogEnabled enables access logging content to files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AccessLogPattern string       `json:"accessLogPattern"` // AccessLogPattern specifies the error log file pattern like: access-{Ymd}.log
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ==================================
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// PProf.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ==================================
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PProfEnabled bool   `json:"pprofEnabled"` // PProfEnabled enables PProf feature.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PProfPattern string `json:"pprofPattern"` // PProfPattern specifies the PProf service pattern for router.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ClientMaxBodySize specifies the max body size limit in bytes for client request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It can be configured in configuration file using string like: 1m, 10m, 500kb etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It's 8MB in default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ClientMaxBodySize int64 `json:"clientMaxBodySize"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// FormParsingMemory specifies max memory buffer size in bytes which can be used for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// parsing multimedia form.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It can be configured in configuration file using string like: 1m, 10m, 500kb etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It's 1MB in default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	FormParsingMemory int64 `json:"formParsingMemory"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NameToUriType specifies the type for converting struct method name to URI when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// registering routes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NameToUriType int `json:"nameToUriType"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// RouteOverWrite allows overwrite the route if duplicated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	RouteOverWrite bool `json:"routeOverWrite"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DumpRouterMap specifies whether automatically dumps router map when server starts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DumpRouterMap bool `json:"dumpRouterMap"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Graceful enables graceful reload feature for all servers of the process.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Graceful bool `json:"graceful"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ServerConfig is the HTTP Server configuration manager.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func Config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func Config() ServerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated. Use NewConfig instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func ConfigFromMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func ConfigFromMap(m map[string]interface{}) (ServerConfig, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ConfigFromMap creates and returns a ServerConfig object with given map and default configuration object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewConfig() ServerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewConfig creates and returns a ServerConfig object with default configurations. Note that, do not define this default configuration to local package variable, as there're some pointer attributes that may be shared in different servers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Session = gsession.Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Session is actually a alias of gsession.Session, which is bound to a single request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UploadFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UploadFile struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	*multipart.FileHeader
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UploadFile wraps the multipart uploading file with more and convenient features.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*UploadFile) Save

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (f *UploadFile) Save(dirPath string, randomlyRename ...bool) (filename string, err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Save saves the single uploading file to directory path and returns the saved file name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The parameter <dirPath> should be a directory path or it returns error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Note that it will OVERWRITE the target file if there's already a same name file exist.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Example

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Custom saving file name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UploadFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UploadFiles []*UploadFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UploadFiles is array type for *UploadFile.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (UploadFiles) Save

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (fs UploadFiles) Save(dirPath string, randomlyRename ...bool) (filenames []string, err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Save saves all uploading files to specified directory path and returns the saved file names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parameter <dirPath> should be a directory path or it returns error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parameter <randomlyRename> specifies whether randomly renames all the file names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WebSocket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WebSocket struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	*websocket.Conn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WebSocket wraps the underlying websocket connection and provides convenient functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      internal