首先，熟悉http协议的都知道，http协议是基于TCP实现的。
http服务器的工作方式大概就是监听socket端口，接受连接，获取到请求，处理请求，返回响应。
所以，对应的会有几个部分
Request：用户请求的信息。post、get、url等这些信息
Response: 返回给客户端的信息
Conn: 用户每次的连接请求
Handler：处理请求和返回信息的逻辑处理
用golang可以很快地建立一个Web服务器
// httpWeb PRoject main.gopackage mainimport ( "fmt" "log" "net/http" "strings")func HandleRequest(w http.ResponseWriter, r *http.Request) { r.ParseForm() fmt.Println(r.Form) fmt.Println("path", r.URL.Path) fmt.Println("scheme", r.URL.Scheme) fmt.Println(r.Form["bookId"]) for k, v := range r.Form { fmt.Printf("key: %s, value: %s /n", k, strings.Join(v, " ")) } fmt.Fprintf(w, "Respone message: Server get bookId successed....")}func main() { http.HandleFunc("/", HandleRequest) err := http.ListenAndServe(":6666", nil) if err != nil { log.Fatal("ListenError:", err) }}当输入 localhost:6060/?bookId=2222&bookId=6666 ，就会连接到该服务器，效果如下：
服务接收请求。至于二次请求favicon.ico的问题暂不讨论。
这样子，简单的一个web服务器就可以运行，处理简单的用户请求。
只是这样子知道怎么搭起一个web服务器并不能满足对技术的好奇心
想要了解简单的几行代码是如何就建立起一web服务器的？
最好的方法就是直接读源代码，让代码来告诉我们实现的原理
回到一开始的web服务器，仔细想想，基本上是两个函数撑起整个Web服务器啊！
居然如此简洁！！
http.HandleFunc("/", HandleRequest)http.ListenAndServe(":6666", nil)不难理解，大概就是处理请求的函数，和监听端口。
首先，先分析一下http.HandleFunc()这个函数。
直接进入函数HandleFunc的声明，源码如下
这里DefaultServeMux调用了HandleFunc()
参数就是传进来的“/”和HandleFunc（定义一个函数类型，就可以把函数作为参数传入）
对于DefaultServeMux在源代码中的声明如下
type ServeMux struct { mu sync.RWMutex m map[string]muxEntry hosts bool // whether any patterns contain hostnames}type muxEntry struct { explicit bool h Handler pattern string}// NewServeMux allocates and returns a new ServeMux.func NewServeMux() *ServeMux { return &ServeMux{m: make(map[string]muxEntry)} }// DefaultServeMux is the default ServeMux used by Serve.var DefaultServeMux = NewServeMux()可以看到，DefaultServeMux是一个默认的ServerMux，而ServeMux的结构体中，mu sync.RWMutex是一个并发控制的锁，一个装有muxEntry结构的map，一个hosts判断是否包含主机名。
！！！仔细一看，这个muxEntry结构体，其中一个变量h Handler和另一个变量pattern string。
而这个Handler定义如下
type Handler interface { ServeHTTP(ResponseWriter, *Request)}是一个接口！！方法是ServeHTTP(ResponseWriter, *Request)。
总结一下
DefaultServeMux的代码看完，大概清楚了。DefaultServeMux是一个ServerMux结构，这个结构里面最最主要包含一个map[string]muxEntry，map里面的每个muxEntry又包含一个string类型的变量pattern和一个接口Handler，这个接口里面的方法是ServeHTTP(ResponseWriter, *Request)。
好了，了解完DefaultServeMux，继续进入它调用的函数。
// HandleFunc registers the handler function for the given pattern.func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) { mux.Handle(pattern, HandlerFunc(handler))}这里相当于调用了ServeMux的方法Handle()。（涉及到golang中的面向对象的方法）
这里先分析HandlerFunc(handler)，也就是把func(ResponseWriter, *Request)函数类型转换为HandlerFunc类型（注意！是HandlerFunc，不是HandleFunc）
先来看看HandlerFunc是什么。
// 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 object that calls f.type HandlerFunc func(ResponseWriter, *Request)// ServeHTTP calls f(w, r).func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r)}HandlerFunc这里居然定义了一个func(ResponseWriter, *Request)的函数类型，HandlerFunc(handler)实际上就是handler本身。为什么这么做？
接看下面的函数。
HandlerFunc实现了ServeHTTP(w ResponseWriter, r *Request) 这个方法！！！！里面只有一行代码f(w, r),也就是说实际上是调用handler，也就是我们一开始在http.HandleFunc("/", HandleRequest)中自己定义的函数HandleRequest。
关键来了！！！！
ServeHTTP(w ResponseWriter, r *Request)这个方法不就是上面Handler接口里面的方法吗！
HandlerFunc实现Handler接口里面的方法。跟java里面的接口一样，任何实现接口的类型，都可以向上转换为该接口类型。这就意味着HandlerFunc类型的值可以自动转换为Handler类型的值作为参数传进任何函数中。这很重要！回头看看muxEntry结构体里面的两个变量pattern string和h Handler，不正好对应刚才传入的参数pattern, HandlerFunc(handler)吗！！
总结一下
所以，HandlerFunc(handler)就是一个适配器模式！HandlerFunc实现Handler接口，ServeHTTP方法里面调用的实际上是我们一开始定义的函数HandleRequest。
这样的一个好处就是，func(ResponseWriter, *Request) -> HandlerFunc -> Handler ，那定义的函数HandleRequest可以作为Handler类型的一个参数。调用Handler的ServeHTTP方法，也就是调用定义的函数HandleRequest。
理解完HandlerFunc(handler)，再来看看整句mux.Handle(pattern, HandlerFunc(handler))
Handle函数源码如下：
// Handle registers the handler for the given pattern.// If a handler already exists for pattern, Handle panics.func (mux *ServeMux) Handle(pattern string, handler Handler) { mux.mu.Lock() defer mux.mu.Unlock() if pattern == "" { panic("http: invalid pattern " + pattern) } if handler == nil { panic("http: nil handler") } if mux.m[pattern].explicit { panic("http: multiple registrations for " + pattern) } mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern} if pattern[0] != '/' { mux.hosts = true } // Helpful behavior: // If pattern is /tree/, insert an implicit permanent redirect for /tree. // It can be overridden by an explicit registration. n := len(pattern) if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit { // If pattern contains a host name, strip it and use remaining // path for redirect. path := pattern if pattern[0] != '/' { // In pattern, at least the last character is a '/', so // strings.Index can't be -1. path = pattern[strings.Index(pattern, "/"):] } url := &url.URL{Path: path} mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern} }}这里的代码直接关注到第17行和37行
由于37行的代码是经过判断后进入if的语句，所以别扣细节，直接关注第17行。
mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}都是赋值语句，基本逻辑都是为DefaultServeMux里面的map赋值。
总结一下
这里就是把传进来的pattern和handler保存在muxEntry结构中，并且pattern作为key，把muxEntry装入到DefaultServeMux的Map里面。
至此，第一个关键的函数http.HandleFunc("/", HandleRequest)就分析完了，就是把当前的参数"/", HandleRequest保存在http包里面的默认的一个ServeMux结构中的map中,简单来说就是保存当前路由和自己定义的那个处理函数。虽然理顺思路感觉挺简单，但是不得不赞叹设计得实在太妙了
那么接下来就是http.ListenAndServe(":6666", nil)
依旧，直接进入ListenAndServe函数
func ListenAndServe(addr string, handler Handler) error { server := &Server{Addr: addr, Handler: handler} return server.ListenAndServe()}函数小而精巧，把addr放到一个Server结构中，并且调用ListenAndServer()。这里面向对象的方法，相当于Java中new一个对象的实例，并且调用该实例的方法。
继续进入函数
func (srv *Server) ListenAndServe() error { 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)})}可以看出HTTP协议也是基于TCP实现的。
监听端口，使用tcp协议,并把tcp的监听传入到Serve()函数中
Server()源码如下：
/ Serve accepts incoming connections on the Listener l, creating a// new service goroutine for each. The service goroutines read requests and// then call srv.Handler to reply to them.func (srv *Server) Serve(l net.Listener) error { defer l.Close() var tempDelay time.Duration // how long to sleep on accept failure for { rw, e := l.Accept() if e != nil { 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, err := srv.newConn(rw) if err != nil { continue } c.setState(c.rwc, StateNew) // before Serve can return go c.serve() }}这个函数就体现了golang并发性。
在for循环里面，直接看到第8行、第26行和第31行
for { rw, e := l.Accept() ... c, err := srv.newConn(rw) ... go c.serve() }简化之后，看上去逻辑就清晰多了
首先，tcp在监听，然后循环接受请求，建立连接，并且用关键字go开启一个服务并发地处理每一个连接。
关于gorutine，作为一个轻量级的线程——协程，每一个消耗资源很小，能够有效地处理并发的问题。这里对每一个服务开启一个gorutine来处理，这里就是高并发的体现！
那么继续往下，到底是怎样处理每个的连接？
这个server()代码很长,源码如下：
// Serve a new connection.func (c *conn) serve() { origConn := c.rwc // copy it before it's set nil on Close or Hijack defer func() { if err := recover(); err != nil { 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(origConn, 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 { 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 } } for { w, err := c.readRequest() if c.lr.N != c.server.initialLimitedReaderSize() { // If we read any bytes off the wire, we're active. c.setState(c.rwc, StateActive) } if err != nil { 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. io.WriteString(c.rwc, "HTTP/1.1 413 Request Entity Too Large/r/n/r/n") c.closeWriteAndWait() break } else if err == io.EOF { break // Don't reply } else if neterr, ok := err.(net.Error); ok && neterr.Timeout() { break // Don't reply } io.WriteString(c.rwc, "HTTP/1.1 400 Bad Request/r/n/r/n") break } // 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} } req.Header.Del("Expect") } else if req.Header.get("Expect") != "" { w.sendExpectationFailed() break } // 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. serverHandler{c.server}.ServeHTTP(w, w.req) if c.hijacked() { return } w.finishRequest() if !w.shouldReuseConnection() { if w.requestBodyLimitHit || w.closedRequestBodyEarly() { c.closeWriteAndWait() } break } c.setState(c.rwc, StateIdle) }}实际上，大概思路也是只要关注for循环里面的第40行、第82行和第86行
for{ w, err := c.readRequest() ... serverHandler{c.server}.ServeHTTP(w, w.req) ... w.finishRequest()}这样就清晰很多了。
循环地读取请求，并且开始处理请求的服务，最后请求完。
先直接进入ServeHTTP
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)}因为一开始http.ListenAndServe(":6666", nil)第二个参数Handler设置为nil，而sh.srv.Handler就是第二个参数的值。
所以handler := sh.srv.Handler这里获取的handler为nil，接着进入if，执行handler = DefaultServeMux。
这里居然把DefaultServeMux赋值给handler，那么DefaultServeMux也实现了Handler的接口。
在源码中找到DefaultServeMux实现的ServeHTTP函数
// ServeHTTP dispatches the request to the handler whose// pattern most closely matches the request URL.func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) { if r.RequestURI == "*" { if r.ProtoAtLeast(1, 1) { w.Header().Set("Connection", "close") } w.WriteHeader(StatusBadRequest) return } h, _ := mux.Handler(r) h.ServeHTTP(w, r)}同样，跳过这里的if判断部分，假设程序正常执行。
所以直接关注最后两句
h, _ := mux.Handler(r)h.ServeHTTP(w, r)第一句，直接找到ServeMux结构体拥有的Handler方法。
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) { if r.Method != "CONNECT" { if p := cleanPath(r.URL.Path); p != r.URL.Path { _, pattern = mux.handler(r.Host, p) url := *r.URL url.Path = p return RedirectHandler(url.String(), StatusMovedPermanently), pattern } } return mux.handler(r.Host, r.URL.Path)}继续跳过这里的if判断部分，假设程序正常执行，r.Method是”CONNECT”。
直接进入mux.handler(r.Host, r.URL.Path)
看到这里，已经很清楚了，正常执行主要就是执行mux.match()这个函数，并且返回Handler类型的值。
func (mux *ServeMux) match(path string) (h Handler, pattern string) { var n = 0 for k, v := range mux.m { if !pathMatch(k, path) { continue } if h == nil || len(k) > n { n = len(k) h = v.h pattern = v.pattern } } return}对一个map循环，匹配出key为pattern的值，值为Handler
到这里！已经完全明白了，一层一层函数看回头。
也就是在 DefaultServeMux中的map中找到个pattern相对应的Handler(其实值就是我们自定义的处理函数）。
第一句h, _ := mux.Handler(r)就是根据请求的路径来匹配一个路由，并且返回一个Handler值。
接着第二句h.ServeHTTP(w, r)
又是熟悉的ServeHTTP函数。看回第一部分析http.HandleFunc("/", HandleRequest)的时候，此时h值就是那时候保存的HandlerFunc类型，使用了适配器模式，而调用ServeHTTP就是直接调用我们定义的函数HandleRequest。
到这里是不是就恍然大悟了！原来是这样。监听，建立连接，获取请求，通过匹配路由，来返回相应的处理函数。在处理函数里面处理请求的信息，并且返回消息给客户端。
那么整for循环里面，最后执行w.finishRequest()
这里思路非常简单，直接关注其中的两句
w.w.Flush()w.conn.buf.Flush()由于，在自定义的处理函数HandleRequest中，会写出数据
fmt.Fprintf(w, "Respone message: Server get bookId successed....")
http.ResponseWriter已经写出数据
这时候http.ResponseWriter再Flush()，把缓冲里的东西也Flush()
最后就可以往客户端发回信息了。
这时候有突然又有个好奇
HandleRequest(w http.ResponseWriter, r *http.Request)这里函数的参数为什么一个是值传递，一个是引用传递？
直接看源代码就知道答案了
查看两个参数的结构
type ResponseWriter interface { Header() Header Write([]byte) (int, error) WriteHeader(int)}type Request struct { Method string URL *url.URL ... Header Header Body io.ReadCloser ContentLength int64 ... Host string Form url.Values ...}一个是接口，一个是结构体
对于接口，可以直接传进来，然后调用其方法
对于结构体，如果直接传值，把整个结构体传进来有点消耗太大了，把它的引用传进来开销就小了很多。
整个http包实现web部分的源代码已经分析完了
设计实在非常妙
新闻热点
疑难解答
