Go Web编程一: Go Web 基础

原文链接 http://ironxu.com/779

Go Web 基础概念与代码阅读

1. Go 搭建简单的web 服务

Go 语言里面提供了一个完善的 net/http 包，通过http 包可以很方便的就搭建起来一个可以运行的Web服务。同时使用这个包能很简单地对Web的路由，静态文件，模版，cookie等进行设置和操作。

$GOPATH/src/github.com/ironxu/go_note/web/basic/server.go 源码如下:

// http 包建立web 服务器package mainimport (    "fmt"    "log"    "net/http")func sayhelloName(w http.ResponseWriter, r *http.Request) {    r.ParseForm()    fmt.Println("path:", r.URL.Path)    fmt.Fprintf(w, "hello go")}func main() {    http.HandleFunc("/", sayhelloName)    err := http.ListenAndServe(":9090", nil)    if err != nil {        log.Fatal("ListenAndServer: ", err)    }}

go run server.go 即可启动http 服务，使用浏览器打开 http://localhost:9090 可以查看相应输出。

2. Go Web 服务讲解

本节介绍 Go Web 服务底层实现，包括注册路由和请求处理

2.1 HTTP 包运行机制

Go 实现Web 服务流程如下

1. 创建Listen Socket, 监听指定的端口, 等待客户端请求到来。
2. Listen Socket 接受客户端的请求, 得到Client Socket, 接下来通过Client Socket与客户端通信。
3. 处理客户端的请求, 首先从Client Socket读取HTTP请求, 然后交给相应的handler 处理请求, 最后将handler处理完毕的数据, 通过Client Socket写给客户端。

其中涉及服务器端的概念:

• Request：用户请求的信息，用来解析用户的请求信息，包括post、get、cookie、url等信息
• Conn：用户的每次请求链接
• Handler：处理请求和生成返回信息的处理逻辑
• Response：服务器需要反馈给客户端的信息

2.2 服务监听与请求处理过程

Go是通过一个ListenAndServe 监听服务，底层处理：初始化一个server对象，然后调用 net.Listen("tcp", addr)，监控我们设置的端口。

监控端口之后，调用 srv.Serve(net.Listener) 函数，处理接收客户端的请求信息。首先通过Listener 接收请求，其次创建一个Conn，最后单独开了一个goroutine，把这个请求的数据当做参数扔给这个conn去服务。go c.serve() 用户的每一次请求都是在一个新的goroutine去服务，相互不影响。

分配相应的函数处理请求: conn 首先会解析 request:c.readRequest(), 然后获取相应的handler:handler := c.server.Handler，这个是调用函数ListenAndServe 时候的第二个参数，例子传递的是nil，也就是为空，那么默认获取handler = DefaultServeMux。DefaultServeMux 是一个路由器，它用来匹配url跳转到其相应的handle函数

调用 http.HandleFunc("/", sayhelloName) 作用是注册了请求/的路由规则，将url 和handle 函数注册到DefaultServeMux 变量，最后调用DefaultServeMux 的ServeHTTP 方法，这个方法内部调用handle 函数。

流程图如下:

3. Web 服务代码实现

3.1 路由注册代码

1 调用 http.HandleFunc(“/”, sayhelloName) 注册路由

// /usr/local/go/src/net/http/server.go:2081func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {    DefaultServeMux.HandleFunc(pattern, handler) // DefaultServeMux 类型为 *ServeMux}

2 使用默认 ServeMux

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

3 注册路由策略 DefaultServeMux

func (mux *ServeMux) Handle(pattern string, handler Handler) {    mux.mu.Lock()    defer mux.mu.Unlock()    ...    mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}    if pattern[0] != '/' {        mux.hosts = true    }    ...}

涉及数据结构

// :1900 ServeMux 默认实例是 DefaultServeMuxtype ServeMux struct {    mu    sync.RWMutex // 锁，由于请求涉及到并发处理，因此这里需要一个锁机制    m     map[string]muxEntry // 路由规则，一个string对应一个mux实体，这里的string就是注册的路由表达式    hosts bool // 是否在任意的规则中带有host信息}type muxEntry struct {    explicit bool    h        Handler // 路由处理器    pattern  string  // url 匹配正则}type Handler interface {    ServeHTTP(ResponseWriter, *Request)}

3.2 服务监听代码

1 调用 err := http.ListenAndServe(“:9090”, nil) 监听端口

// /usr/local/go/src/net/http/server.go:2349func ListenAndServe(addr string, handler Handler) error {    server := &Server{Addr: addr, Handler: handler} // handler 为空    return server.ListenAndServe()}

创建一个 Server 对象，并调用 Server 的 ListenAndServe()

2 监听TCP端口

// :2210func (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)})}

3 接收请求

// :2256func (srv *Server) Serve(l net.Listener) error {    defer l.Close()    ...    baseCtx := context.Background()    ctx := context.WithValue(baseCtx, ServerContextKey, srv)    ctx = context.WithValue(ctx, LocalAddrContextKey, l.Addr())    for {        rw, e := l.Accept() // 1. Listener 接收请求        if e != nil {            ...        }        tempDelay = 0        c := srv.newConn(rw) // 2. 创建 *conn        c.setState(c.rwc, StateNew) // before Serve can return        go c.serve(ctx) // 3. 新启一个goroutine，将请求数据做为参数传给 conn，由这个新的goroutine 来处理这次请求    }}

4 goroutine 处理请求

// Serve a new connection.func (c *conn) serve(ctx context.Context) {    ...    // HTTP/1.x from here on.    c.r = &connReader{r: c.rwc}    c.bufr = newBufioReader(c.r)    c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)    ctx, cancelCtx := context.WithCancel(ctx)    defer cancelCtx()    for {        w, err := c.readRequest(ctx) // 1. 获取请求数据        ...        serverHandler{c.server}.ServeHTTP(w, w.req) // 2. 处理请求 serverHandler, 对应下面第5步        w.cancelCtx()        if c.hijacked() {            return        }        w.finishRequest() // 3. 返回响应结果        if !w.shouldReuseConnection() {            if w.requestBodyLimitHit || w.closedRequestBodyEarly() {                c.closeWriteAndWait()            }            return        }        c.setState(c.rwc, StateIdle)    }}

5 处理请求

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {    handler := sh.srv.Handler    if handler == nil {        handler = DefaultServeMux // ServeMux    }    if req.RequestURI == "*" && req.Method == "OPTIONS" {        handler = globalOptionsHandler{}    }    handler.ServeHTTP(rw, req)}

5.1 handler.ServeHTTP(rw, req)

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) // HandlerFunc, Handler    h.ServeHTTP(w, r)}

5.2 执行处理

// ServeHTTP calls f(w, r).func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {    f(w, r)}

涉及的数据类型

type Server struct {    Addr         string        // TCP address to listen on, ":http" if empty    Handler      Handler       // handler to invoke, http.DefaultServeMux if nil    ReadTimeout  time.Duration // maximum duration before timing out read of the request    WriteTimeout time.Duration // maximum duration before timing out write of the response    ...}type conn struct {    server *Server // server is the server on which the connection arrived.    rwc net.Conn // rwc is the underlying network connection. It is usually of type *net.TCPConn or *tls.Conn.    remoteAddr string // This is the value of a Handler's (*Request).RemoteAddr.    mu sync.Mutex // mu guards hijackedv, use of bufr, (*response).closeNotifyCh.    ...}type serverHandler struct {    srv *Server}

3.3 Go 代码的执行流程

调用Http.HandleFunc，按顺序做了几件事：

1. 调用了DefaultServeMux的HandleFunc
2. 调用了DefaultServeMux的Handle
3. 往DefaultServeMux的map[string]muxEntry中增加对应的handler和路由规则

调用http.ListenAndServe(":9090", nil)，按顺序做了几件事情：

1. 实例化Server
2. 调用Server的ListenAndServe()
3. 调用net.Listen(“tcp”, addr)监听端口
4. 启动一个for循环，在循环体中Accept请求
5. 对每个请求实例化一个Conn，并且开启一个goroutine为这个请求进行服务go c.serve()
6. 读取每个请求的内容w, err := c.readRequest()
7. 判断handler是否为空，如果没有设置handler（这个例子就没有设置handler），handler就设置为DefaultServeMux
8. 调用handler的ServeHttp
9. 在这个例子中，下面就进入到DefaultServeMux.ServeHttp
10. 根据request选择handler，并且进入到这个handler的ServeHTTP mux.handler(r).ServeHTTP(w, r)
11. 选择handler：
    A 判断是否有路由能满足这个request（循环遍历ServerMux的muxEntry）
    B 如果有路由满足，调用这个路由handler的ServeHttp
    C 如果没有路由满足，调用NotFoundHandler的ServeHttp

4. 自定义路由实现

定义的类型实现ServeHTTP 方法，即可实现自定义路由

package mainimport (    "fmt"    "log"    "net/http")type MyMux struct {}func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {    if r.URL.Path == "/" {        sayhelloName(w, r)        return    }    http.NotFound(w, r)    return}func sayhelloName(w http.ResponseWriter, r *http.Request) {    r.ParseForm()    fmt.Println("path:", r.URL.Path)    fmt.Fprintf(w, "hello go")}func main() {    mux := &MyMux{}    err := http.ListenAndServe(":9090", mux)    if err != nil {        log.Fatal("ListenAndServer: ", err)    }}

参考

• 3.2 Go搭建一个Web服务器
• 3.3 Go如何使得Web工作
• 3.4 Go的http包详解

可以关注我的微博了解更多信息: @刚刚小码农