go-restful实战与深入分析之基础篇

如果想分析清楚go-restful的工作原理我们这篇先介绍一些go http的基本知识，我将通过多个例子把故事串起来，先看一个最基本的helloworld的例子：

func HelloServer(w http.ResponseWriter, req *http.Request) {    io.WriteString(w, "hello, world!\n")}func main() {    http.HandleFunc("/hello/", HelloServer)    err := http.ListenAndServe(":8080", nil)    if err != nil {        log.Fatal("ListenAndServe: ", err)    }}

测试：
curl 127.0.0.1:8080/hello/
hello, world!
上面这个例子里面通过HandleFunc注册方法和路由。
再看一个例子

package mainimport (    "io"    "net/http")type a struct{}func (*a) ServeHTTP(w http.ResponseWriter, r *http.Request) {    path := r.URL.String() //获得访问的路径    io.WriteString(w, path)}func main() {    http.ListenAndServe(":8080", &a{})//第2个参数需要实现Hander接口的struct，a满足}

测试
curl 127.0.0.1:8080/hello
/hello
通过上面两个例子读者可能已经知道http怎么样使用了。当然你可以通过mux统一包装一下：

package mainimport (    "net/http"    "io")func main() {    mux := http.NewServeMux()    mux.HandleFunc("/h", func(w http.ResponseWriter, r *http.Request) {        io.WriteString(w, "hello")    })    mux.HandleFunc("/bye", func(w http.ResponseWriter, r *http.Request) {        io.WriteString(w, "byebye")    })    mux.HandleFunc("/hello", sayhello)    http.ListenAndServe(":8080", mux)}func sayhello(w http.ResponseWriter, r *http.Request) {    io.WriteString(w, "hello world")}

这个和第一个用的http直接使用HandleFunc是不是很相似，其实mux只是包装了一下，本质是一回事，看看测试
curl 127.0.0.1:8080/hello
hello world
curl 127.0.0.1:8080/h
hello
三个http基本使用的例子已经讲完了。
在深入讲解代码之前先说一个golang编写一个装饰器模式：

package mainimport "fmt"type HandlerFunc func(a,b string)func (f HandlerFunc) ServeTim(a,b string) {    f(a, b)}type Handler interface {    ServeTim(x, y string)}func Create(m,n string)  {    fmt.Println(m,"Create",n)}func Delete(m,n string)  {    fmt.Println(m,"Delete",n)}func main() {    HandlerFunc(Create).ServeTim("333","444")    HandlerFunc(Delete).ServeTim("333","444")}

测试：
333 Create 444
333 Delete 444
为什么要写这个装饰器东西呢？应为这个就是http里面使用这种模式装饰各种CURD方法。如果理解了这个，我们接这说。看看第一个helloworld的底层是怎样实现的

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {    mux.Handle(pattern, HandlerFunc(handler))}

上面的HandlerFunc就是我上面说的装饰器模式，把具体一个handler方法放进去，后面只要通过

type Handler interface {    ServeHTTP(ResponseWriter, *Request)}

里面的ServeHTTP去统一调用就可以了，接着看Handle方法

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)    }    if mux.m == nil {        mux.m = make(map[string]muxEntry)    }    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}    }}

这个ServeMux实体mux里面维护了一个map，这个map就是具体的pattern（路径）和调用方法的对于关系。定义如下

type ServeMux struct {    mu    sync.RWMutex    m     map[string]muxEntry    hosts bool // whether any patterns contain hostnames}

当服务ListenAndServe启动监听后会阻塞等待：

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 := srv.newConn(rw)        c.setState(c.rwc, StateNew) // before Serve can return        go c.serve(ctx)    }

当接收到一个请求后Accept获取请求内容，go c.serve(ctx)启动协程去处理，在这个方法里面先解析参数后调用ServeHTTP处理

w, err := c.readRequest(ctx)serverHandler{c.server}.ServeHTTP(w, w.req)

ServeHTTP进入

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)}

接口定义如下：

type Handler interface {    ServeHTTP(ResponseWriter, *Request)}

实现方式如下/usr/local/go/src/net/http/server.go：

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)}

这里面通过 mux.Handler获取handler，然后通过之前说的适配器模式ServeHTTP调用具体实现方法。
细节补充一下，怎么获取handler，这个和之前怎么注册相结合：

func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {    mux.mu.RLock()    defer mux.mu.RUnlock()    // Host-specific pattern takes precedence over generic ones    if mux.hosts {        h, pattern = mux.match(host + path)    }    if h == nil {        h, pattern = mux.match(path)    }    if h == nil {        h, pattern = NotFoundHandler(), ""    }    return}

这个从之前注册的map里面获取pattern的方法，那么我们就找到了服务怎样调用的了。