Gin 学习之自定义服务器配置信息

func gin.Default() *gin.Engine

func (engine *Engine) Run(addr ...string) (err error) {  defer func() { debugPrintError(err) }()
  address := resolveAddress(addr)  debugPrint("Listening and serving HTTP on %s\n", address)  err = http.ListenAndServe(address, engine)  return}

func ListenAndServe(addr string, handler Handler) error {  server := &Server{Addr: addr, Handler: handler}  return server.ListenAndServe()}

Server struct {    // Addr optionally specifies the TCP address for the server to listen on,    // in the form "host:port". If empty, ":http" (port 80) is used.    // The service names are defined in RFC 6335 and assigned by IANA.    // See net.Dial for details of the address format.    Addr string
    Handler Handler // handler to invoke, http.DefaultServeMux if nil
    // 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
    // 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
    // ReadHeaderTimeout is the amount of time allowed to read    // request headers. The connection's read deadline is reset    // after reading the headers and the Handler can decide what    // is considered too slow for the body. If ReadHeaderTimeout    // is zero, the value of ReadTimeout is used. If both are    // zero, there is no timeout.    ReadHeaderTimeout time.Duration
    // 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
    // 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
    // MaxHeaderBytes controls the maximum number of bytes the    // server will read parsing the request header's keys and    // values, including the request line. It does not limit the    // size of the request body.    // If zero, DefaultMaxHeaderBytes is used.    MaxHeaderBytes int
    // TLSNextProto optionally specifies a function to take over    // ownership of the provided TLS connection when an ALPN    // protocol upgrade has occurred. The map key is the protocol    // name negotiated. The Handler argument should be used to    // handle HTTP requests and will initialize the Request's TLS    // and RemoteAddr if not already set. The connection is    // automatically closed when the function returns.    // If TLSNextProto is not nil, HTTP/2 support is not enabled    // automatically.    TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
    // ConnState specifies an optional callback function that is    // called when a client connection changes state. See the    // ConnState type and associated constants for details.    ConnState func(net.Conn, ConnState)
    // ErrorLog specifies an optional logger for errors accepting    // connections, unexpected behavior from handlers, and    // underlying FileSystem errors.    // If nil, logging is done via the log package's standard logger.    ErrorLog *log.Logger
    // BaseContext optionally specifies a function that returns    // the base context for incoming requests on this server.    // The provided Listener is the specific Listener that's    // about to start accepting requests.    // If BaseContext is nil, the default is context.Background().    // If non-nil, it must return a non-nil context.    BaseContext func(net.Listener) context.Context
    // ConnContext optionally specifies a function that modifies    // the context used for a new connection c. The provided ctx    // is derived from the base context and has a ServerContextKey    // value.    ConnContext func(ctx context.Context, c net.Conn) context.Context
    inShutdown atomicBool // true when when server is in shutdown
    disableKeepAlives int32     // accessed atomically.    nextProtoOnce     sync.Once // guards setupHTTP2_* init    nextProtoErr      error     // result of http2.ConfigureServer if used
    mu         sync.Mutex    listeners  map[*net.Listener]struct{}    activeConn map[*conn]struct{}    doneChan   chan struct{}    onShutdown []func()}