golang net/http Server主要流程源码分析
net/http
golang net/http Server主要流程源码分析。golang
时间：2019年3月14日app
处理一个http请求大体思路以下：tcp
- 建立一个net.Listener对象
- net.Listener对象Accept一个tcp链接
- 从tcp链接读取一个请求并建立一个响应体
- 调用接口处理这个链接的请求并写入数据udao响应
主要堆栈:函数
http.ListenAndServe(addr string, handler Handler) error源码分析
http.*Server.ListenAndServe() error
net.Listen(network, address string) (net.Listener, error)
http.*Server.Serve(l net.Listener) error
http.*Server.setupHTTP2_Serve()
net.Listener.Accept() (net.Conn, error)
http.*Server.newConn(rwc net.Conn) *http.conn
http.*conn.setState(nc net.Conn, state ConnState)
http.*conn.serve(ctx context.Context)
defer http.*conn.serve.func()
http.*conn.rwc.(*tls.Conn)
tls.*Conn.Handshake()
tls.ConnectionState.NegotiatedProtocol
http.*conn.readRequest(ctx context.Context) (w *http.response, err error)
http.serverHandler{http.*conn.server}.ServeHTTP(w, w.req)
复制代码
Start
启动一个Server测试
package main
import "fmt"
import "net/http"
func main() {
http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %q", r.URL.Path)
})
http.ListenAndServe(":8080", nil)
}
复制代码
http.ListenAndServe
首先http.ListenAndServe会建立一个Server，设置地址和Handler，而后调用Server对象的ListenAndServe方法启动。ui
ListenAndServe方法先检查srv的状态是不是关闭，服务是关闭的就直接退出this
而后设置默认地址，利用地址监听tcp链接，最后调用Server对象的Serve的方法，处理这个监听。spa
// ListenAndServe listens on the TCP network address addr and then calls
// Serve with handler to handle requests on incoming connections.
// Accepted connections are configured to enable TCP keep-alives.
//
// The handler is typically nil, in which case the DefaultServeMux is used.
//
// ListenAndServe always returns a non-nil error.
func ListenAndServe(addr string, handler Handler) error {
server := &Server{Addr: addr, Handler: handler}
return server.ListenAndServe()
}
func (srv *Server) ListenAndServe() error {
if srv.shuttingDown() {
return ErrServerClosed
}
addr := srv.Addr
if addr == "" {
addr = ":http"
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return err
}
return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
复制代码
Serve
Server对象的Serve方法才是处理个监听的主要过程，启动顺序函数以下：日志
testHookServerServe执行net/http库默认的测试函数。
if fn := testHookServerServe; fn != nil {
fn(srv, l) // call hook with unwrapped listener
}
复制代码
onceCloseListener对象封装net.Listener对象的Close方法，使用sync.Once对象确保net.Listener只会关闭一次。
l = &onceCloseListener{Listener: l}
defer l.Close()
复制代码
setupHTTP2_Serve设置http2，若是启用了https默认就是http2，h2能够使用环境变量设置是否启动，具体不分析。
if err := srv.setupHTTP2_Serve(); err != nil {
return err
}
复制代码
trackListener设置track日志，忽略。
if !srv.trackListener(&l, true) {
return ErrServerClosed
}
defer srv.trackListener(&l, false)
复制代码
baseCtx是Server一个监听的根Context。
baseCtx := context.Background() // base is always background, per Issue 16220
ctx := context.WithValue(baseCtx, ServerContextKey, srv)
复制代码
for循环处理Accept到的链接。
for {
rw, e := l.Accept()
...
}
复制代码
若是Accept返回err，会srv.getDoneChan()方法检测Server是否结束，后序忽略。
if e != nil {
select {
case <-srv.getDoneChan():
return ErrServerClosed
default:
}
if ne, ok := e.(net.Error); ok && ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
time.Sleep(tempDelay)
continue
}
return e
}
复制代码
Accept得到了一个net.Conn链接对象，使用srv.newConn方法建立一个http.conn链接。
http.conn链接就是http链接，设置链接状态用于链接复用，而后c.serve处理这个http链接。
c := srv.newConn(rw)
c.setState(c.rwc, StateNew) // before Serve can return
go c.serve(ctx)
复制代码
http.Server.Serve完整源码以下：
func (srv *Server) Serve(l net.Listener) error {
if fn := testHookServerServe; fn != nil {
fn(srv, l) // call hook with unwrapped listener
}
l = &onceCloseListener{Listener: l}
defer l.Close()
if err := srv.setupHTTP2_Serve(); err != nil {
return err
}
if !srv.trackListener(&l, true) {
return ErrServerClosed
}
defer srv.trackListener(&l, false)
var tempDelay time.Duration // how long to sleep on accept failure
baseCtx := context.Background() // base is always background, per Issue 16220
ctx := context.WithValue(baseCtx, ServerContextKey, srv)
for {
rw, e := l.Accept()
if e != nil {
select {
case <-srv.getDoneChan():
return ErrServerClosed
default:
}
if ne, ok := e.(net.Error); ok && ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
time.Sleep(tempDelay)
continue
}
return e
}
tempDelay = 0
c := srv.newConn(rw)
c.setState(c.rwc, StateNew) // before Serve can return
go c.serve(ctx)
}
}
复制代码
net.conn.serve
net.conn.serve处理一个http链接。
WithValue设置Context，忽略。
c.remoteAddr = c.rwc.RemoteAddr().String()
ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())
复制代码
defer部分捕捉panic抛出的错误，而后Server对象输出，若是Server对象设置了log.Logger，就输出到log，不然输出到默认。
defer func() {
if err := recover(); err != nil && err != ErrAbortHandler {
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)]
c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)
}
...
}()
复制代码
defer后部分，检测http链接的状态，非劫持状态就关闭链接，设置http状态成关闭；劫持状态通常在Websock下，使用Hijack方法获取了tcp链接，而后自定义处理。
if !c.hijacked() {
c.close()
c.setState(c.rwc, StateClosed)
}
复制代码
c.rwc就是net.Conn的链接，net.Conn实现了Reader、Writer、Closer接口，因此缩写rwc。
rwc链接断言判断是不是tls.Conn链接，判断是不是https链接；若是是就设置rwc的超时，
if tlsConn, ok := c.rwc.(*tls.Conn); ok {
if d := c.server.ReadTimeout; d != 0 {
c.rwc.SetReadDeadline(time.Now().Add(d))
}
if d := c.server.WriteTimeout; d != 0 {
c.rwc.SetWriteDeadline(time.Now().Add(d))
}
...
}
复制代码
tlsConn.Handshake()是检测tls握手是否正常，不正常就返回http 400的响应并关闭链接；
if err := tlsConn.Handshake(); err != nil {
// If the handshake failed due to the client not speaking
// TLS, assume they're speaking plaintext HTTP and write a
// 400 response on the TLS conn's underlying net.Conn.
if re, ok := err.(tls.RecordHeaderError); ok && re.Conn != nil && tlsRecordHeaderLooksLikeHTTP(re.RecordHeader) {
io.WriteString(re.Conn, "HTTP/1.0 400 Bad Request\r\n\r\nClient sent an HTTP request to an HTTPS server.\n")
re.Conn.Close()
return
}
c.server.logf("http: TLS handshake error from %s: %v", c.rwc.RemoteAddr(), err)
return
}
复制代码
获取NegotiatedProtocol信息，就是NextProto的值，若是值是h2，就使用h2的链接处理；h2详细见h2握手分析，此tls部分可忽略,是tls的ALPN扩展的支持。
c.tlsState = new(tls.ConnectionState)
*c.tlsState = tlsConn.ConnectionState()
if proto := c.tlsState.NegotiatedProtocol; validNPN(proto) {
if fn := c.server.TLSNextProto[proto]; fn != nil {
h := initNPNRequest{tlsConn, serverHandler{c.server}}
fn(c.server, tlsConn, h)
}
return
}
复制代码
注意：tlsConn.Handshake()必定要执行，是验证tls握手，而后才会有NegotiatedProtocol等tls链接信息。
注意：NegotiatedProtocol是tls的ALPN扩展的关键，h2协议握手下的值就是h2
tls部分完整以下：
if tlsConn, ok := c.rwc.(*tls.Conn); ok {
if d := c.server.ReadTimeout; d != 0 {
c.rwc.SetReadDeadline(time.Now().Add(d))
}
if d := c.server.WriteTimeout; d != 0 {
c.rwc.SetWriteDeadline(time.Now().Add(d))
}
if err := tlsConn.Handshake(); err != nil {
// If the handshake failed due to the client not speaking
// TLS, assume they're speaking plaintext HTTP and write a
// 400 response on the TLS conn's underlying net.Conn.
if re, ok := err.(tls.RecordHeaderError); ok && re.Conn != nil && tlsRecordHeaderLooksLikeHTTP(re.RecordHeader) {
io.WriteString(re.Conn, "HTTP/1.0 400 Bad Request\r\n\r\nClient sent an HTTP request to an HTTPS server.\n")
re.Conn.Close()
return
}
c.server.logf("http: TLS handshake error from %s: %v", c.rwc.RemoteAddr(), err)
return
}
c.tlsState = new(tls.ConnectionState)
*c.tlsState = tlsConn.ConnectionState()
if proto := c.tlsState.NegotiatedProtocol; validNPN(proto) {
if fn := c.server.TLSNextProto[proto]; fn != nil {
h := initNPNRequest{tlsConn, serverHandler{c.server}}
fn(c.server, tlsConn, h)
}
return
}
}
复制代码
tls部分没将请求变成h2就继续按http/1.1处理请求。
newBufioReader部分对rwc，使用bufio变成缓冲读写。
// HTTP/1.x from here on.
ctx, cancelCtx := context.WithCancel(ctx)
c.cancelCtx = cancelCtx
defer cancelCtx()
c.r = &connReader{conn: c}
c.bufr = newBufioReader(c.r)
c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)
复制代码
而后for循环调用net.conn.readRequest读取一个请求，并建立ResponseWriter对象。
for {
w, err := c.readRequest(ctx)
...
}
复制代码
若是读取请求错误，就直接返回4xx错误响应并关闭链接。
if err != nil {
const errorHeaders = "\r\nContent-Type: text/plain; charset=utf-8\r\nConnection: close\r\n\r\n"
if err == errTooLarge {
// Their HTTP client may or may not be
// able to read this if we're
// responding to them and hanging up
// while they're still writing their
// request. Undefined behavior.
const publicErr = "431 Request Header Fields Too Large"
fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
c.closeWriteAndWait()
return
}
if isCommonNetReadError(err) {
return // don't reply
}
publicErr := "400 Bad Request"
if v, ok := err.(badRequestError); ok {
publicErr = publicErr + ": " + string(v)
}
fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
return
}
复制代码
// Expect 100 Continue support
req := w.req
if req.expectsContinue() {
if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
// Wrap the Body reader with one that replies on the connection
req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
}
} else if req.Header.get("Expect") != "" {
w.sendExpectationFailed()
return
}
c.curReq.Store(w)
if requestBodyRemains(req.Body) {
registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)
} else {
w.conn.r.startBackgroundRead()
}
复制代码
建立一个serverHandler处理当前的请求rw，serverHandler就检测Server是否设置了默认处理者，和响应Option方法，可忽略。
而后判断链接状态是否劫持，劫持直接结束。
...
注意：serverHandler{c.server}.ServeHTTP(w, w.req)，就是用链接先建立request和response对象，然使用http.Handler对象来处理这个请求。
// HTTP cannot have multiple simultaneous active requests.[*]
// Until the server replies to this request, it can't read another,
// so we might as well run the handler in this goroutine.
// [*] Not strictly true: HTTP pipelining. We could let them all process
// in parallel even if their responses need to be serialized.
// But we're not going to implement HTTP pipelining because it
// was never deployed in the wild and the answer is HTTP/2.
serverHandler{c.server}.ServeHTTP(w, w.req)
w.cancelCtx()
if c.hijacked() {
return
}
w.finishRequest()
if !w.shouldReuseConnection() {
if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
c.closeWriteAndWait()
}
return
}
c.setState(c.rwc, StateIdle)
c.curReq.Store((*response)(nil))
复制代码
http.serverHandler定义:
// serverHandler delegates to either the server's Handler or
// DefaultServeMux and also handles "OPTIONS *" requests.
type serverHandler struct {
srv *Server
}
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
handler := sh.srv.Handler
if handler == nil {
handler = DefaultServeMux
}
if req.RequestURI == "*" && req.Method == "OPTIONS" {
handler = globalOptionsHandler{}
}
handler.ServeHTTP(rw, req)
}
复制代码
...
if !w.conn.server.doKeepAlives() {
// We're in shutdown mode. We might've replied
// to the user without "Connection: close" and
// they might think they can send another
// request, but such is life with HTTP/1.1.
return
}
if d := c.server.idleTimeout(); d != 0 {
c.rwc.SetReadDeadline(time.Now().Add(d))
if _, err := c.bufr.Peek(4); err != nil {
return
}
}
c.rwc.SetReadDeadline(time.Time{})
复制代码
net.conn.serve完整定义以下：
// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
c.remoteAddr = c.rwc.RemoteAddr().String()
ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())
defer func() {
if err := recover(); err != nil && err != ErrAbortHandler {
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)]
c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)
}
if !c.hijacked() {
c.close()
c.setState(c.rwc, StateClosed)
}
}()
if tlsConn, ok := c.rwc.(*tls.Conn); ok {
if d := c.server.ReadTimeout; d != 0 {
c.rwc.SetReadDeadline(time.Now().Add(d))
}
if d := c.server.WriteTimeout; d != 0 {
c.rwc.SetWriteDeadline(time.Now().Add(d))
}
if err := tlsConn.Handshake(); err != nil {
// If the handshake failed due to the client not speaking
// TLS, assume they're speaking plaintext HTTP and write a
// 400 response on the TLS conn's underlying net.Conn.
if re, ok := err.(tls.RecordHeaderError); ok && re.Conn != nil && tlsRecordHeaderLooksLikeHTTP(re.RecordHeader) {
io.WriteString(re.Conn, "HTTP/1.0 400 Bad Request\r\n\r\nClient sent an HTTP request to an HTTPS server.\n")
re.Conn.Close()
return
}
c.server.logf("http: TLS handshake error from %s: %v", c.rwc.RemoteAddr(), err)
return
}
c.tlsState = new(tls.ConnectionState)
*c.tlsState = tlsConn.ConnectionState()
if proto := c.tlsState.NegotiatedProtocol; validNPN(proto) {
if fn := c.server.TLSNextProto[proto]; fn != nil {
h := initNPNRequest{tlsConn, serverHandler{c.server}}
fn(c.server, tlsConn, h)
}
return
}
}
// HTTP/1.x from here on.
ctx, cancelCtx := context.WithCancel(ctx)
c.cancelCtx = cancelCtx
defer cancelCtx()
c.r = &connReader{conn: c}
c.bufr = newBufioReader(c.r)
c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)
for {
w, err := c.readRequest(ctx)
if c.r.remain != c.server.initialReadLimitSize() {
// If we read any bytes off the wire, we're active.
c.setState(c.rwc, StateActive)
}
if err != nil {
const errorHeaders = "\r\nContent-Type: text/plain; charset=utf-8\r\nConnection: close\r\n\r\n"
if err == errTooLarge {
// Their HTTP client may or may not be
// able to read this if we're
// responding to them and hanging up
// while they're still writing their
// request. Undefined behavior.
const publicErr = "431 Request Header Fields Too Large"
fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
c.closeWriteAndWait()
return
}
if isCommonNetReadError(err) {
return // don't reply
}
publicErr := "400 Bad Request"
if v, ok := err.(badRequestError); ok {
publicErr = publicErr + ": " + string(v)
}
fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
return
}
// Expect 100 Continue support
req := w.req
if req.expectsContinue() {
if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
// Wrap the Body reader with one that replies on the connection
req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
}
} else if req.Header.get("Expect") != "" {
w.sendExpectationFailed()
return
}
c.curReq.Store(w)
if requestBodyRemains(req.Body) {
registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)
} else {
w.conn.r.startBackgroundRead()
}
// HTTP cannot have multiple simultaneous active requests.[*]
// Until the server replies to this request, it can't read another,
// so we might as well run the handler in this goroutine.
// [*] Not strictly true: HTTP pipelining. We could let them all process
// in parallel even if their responses need to be serialized.
// But we're not going to implement HTTP pipelining because it
// was never deployed in the wild and the answer is HTTP/2.
serverHandler{c.server}.ServeHTTP(w, w.req)
w.cancelCtx()
if c.hijacked() {
return
}
w.finishRequest()
if !w.shouldReuseConnection() {
if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
c.closeWriteAndWait()
}
return
}
c.setState(c.rwc, StateIdle)
c.curReq.Store((*response)(nil))
if !w.conn.server.doKeepAlives() {
// We're in shutdown mode. We might've replied
// to the user without "Connection: close" and
// they might think they can send another
// request, but such is life with HTTP/1.1.
return
}
if d := c.server.idleTimeout(); d != 0 {
c.rwc.SetReadDeadline(time.Now().Add(d))
if _, err := c.bufr.Peek(4); err != nil {
return
}
}
c.rwc.SetReadDeadline(time.Time{})
}
}
复制代码
net.conn.readRequest
readRequest方法就是根据链接建立http.Request和http.ResponseWriter两个对象供http.Handler接口使用，处理一个请求。
end
建立一个Server并处理http请求到此就结束。
http.HandleFunc
http.HandleFunc使用http.DefaultServeMux这个默认路由调用HandleFunc方法注册一个路由。
// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) 复制代码
http.Handler
http.Handler是net/http库处理请求的接口，http.Server直接调用Handler处理请求。
http.ServeMux是net/http库内置的路由器，执行了基本匹配，可是实现了http.Handler接口，Server就直接使用Mux。
HandlerFunc是处理函数，可是这个类型实现了http.Handler接口，就将一个函数转换成了接口。
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler that calls f.
type HandlerFunc func(ResponseWriter, *Request) // ServeHTTP calls f(w, r). func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
复制代码
一下两种方法都将func(ResponseWriter, *Request){}这样一个函数转换成了http.Handler接口
http.HandlerFunc(func(ResponseWriter, *Request){})
func Convert(h http.HandlerFunc) http.Handler {
return h
}
复制代码
Middleware
基于net/http简单实现中间件，使用http.Handler接口，使用装饰器模式嵌套一层。
Logger对象实现了http.Handler接口，会先输出请求信息，而后调用路由处理这个请求。
http.ServeMux是标准库实现的路由器，会匹配并处理请求。
package main
import "fmt"
import "net/http"
func main() {
// 建立并注册路由
mux := &http.ServeMux{}
mux.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %q", r.URL.Path)
})
// 启动服务，给予处理者是Logger
http.ListenAndServe(":8080", &Logger{mux})
}
type Logger struct {
h http.Handler
}
// 实现http.Handler接口
func (log *Logger) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// 输出日志信息
fmt.Printf("%s %s\n", r.Method, r.URL.Path)
// 使用下一个处理者处理请求
log.h.ServeHTTP(w, r)
}
复制代码
相关文章
- 1. Seata-Server 启动流程源码分析
- 2. EasyTransaction主要源码分析
- 3. Shell主要逻辑源码级分析(1)——SHELL运行流程
- 4. webpack 4 源码主流程分析（五）：reslove 流程
- 5. Nginx源码分析 - 主流程篇 - Nginx的启动流程
- 6. Activiti5工做主要流主要源码解析
- 7. nginx源码中upstream的主要流程
- 8. Dubbo源码分流程析
- 9. Mybatis源码流程分析
- 10. okhttp源码流程分析
- 更多相关文章...
- • RDF 主要 元素 - RDF 教程
- • Lua 流程控制 - Lua 教程
- • Git五分钟教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 安装cuda+cuDNN
- 2. GitHub的使用说明
- 3. phpDocumentor使用教程【安装PHPDocumentor】
- 4. yarn run build报错Component is not found in path “npm/taro-ui/dist/weapp/components/rate/index“
- 5. 精讲Haproxy搭建Web集群
- 6. 安全测试基础之MySQL
- 7. C/C++编程笔记：C语言中的复杂声明分析，用实例带你完全读懂
- 8. Python3教程(1)----搭建Python环境
- 9. 李宏毅机器学习课程笔记2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里云ECS配置速记
欢迎关注本站公众号,获取更多信息
