Go Web编程一: Go Web 基础

原创 2017年04月04日 09:34:24

原文链接 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 main

import (
    "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 = DefaultServeMuxDefaultServeMux 是一个路由器,它用来匹配url跳转到其相应的handle函数

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

流程图如下:

3. Web 服务代码实现

3.1 路由注册代码

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

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

2 使用默认 ServeMux

// :2027
func (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 默认实例是 DefaultServeMux
type 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:2349
func ListenAndServe(addr string, handler Handler) error {
    server := &Server{Addr: addr, Handler: handler} // handler 为空
    return server.ListenAndServe()
}

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

2 监听TCP端口

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

3 接收请求

// :2256
func (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 main

import (
    "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)
    }
}

参考

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

版权声明:本文为博主原创文章,未经博主允许不得转载。

go后台和web编程

go的应用场景更多情况下应用于后台,也可以用于开发web。后台和web都是用到net和net/http模块,而开发web则还需要html/template模块。当然了实际使用中html/templat...
  • hangeqq685042
  • hangeqq685042
  • 2016年09月10日 17:35
  • 3108

Go Web编程

  • 2013年02月06日 08:56
  • 5.8MB
  • 下载

Go Web编程:访问数据库

第一次接触数据库的操作,很多概念都是陌生的,如果你跟我一样,请先移步:MySql入门(1) ,初步了解数据库的操作。本文后面的介绍将以mysql为主。Go没有内置操作数据库的驱动,仅仅定义了一套dat...
  • uudou
  • uudou
  • 2016年10月17日 09:31
  • 1783

Go Web 编程.pdf

  • 2013年02月18日 14:28
  • 5.91MB
  • 下载

Go Web开发基础

1.Abstract 在学习web开发的过程中会遇到很多困难,因此写一篇类似综述类的文章。作为路线图,从web开发要素的index出发,来介绍golang开发的学习流程以及Example代码。在描述...
  • u011321908
  • u011321908
  • 2015年07月14日 16:28
  • 1438

Go Web编程:http包分析

一个简单的web服务package mainimport ( "io" "log" "net/http" )func HelloGoServer(w http.Response...
  • uudou
  • uudou
  • 2016年10月05日 12:22
  • 2396

[Go语言] 面向外网的Web调优详解(go1.8)

很早以前crypto/tls(TLS长连接库)和net/http的性能不敢恭维,因此我们都使用Nginx做反向代理,但是Go1.8将要来了,这种格局即将被打破了! 我们最近尝试性的将Go...
  • andylau00j
  • andylau00j
  • 2016年12月20日 18:19
  • 520

golang之web编程执行流程

为什么golang做web编程比其他语言并发高:Go是通过一个函数ListenAndServe来处理这些事情的,这个底层其实这样处 理的:初始化一个server对象,然后调用了net.Listen("...
  • e421083458
  • e421083458
  • 2015年11月10日 14:18
  • 2484

Go Web编程(Go语言性能好、语法简单、开发效率高!)

Go Web编程(Go语言性能好、语法简单、开发效率高!) 谢孟军 著 ISBN 978-7-121-20091-5 2013年6月出版 定价65.00元 352页 16开 ...
  • broadview2006
  • broadview2006
  • 2013年05月02日 11:20
  • 14012

Go搭建一个Web服务器

前面小节已经介绍了Web是基于http协议的一个服务,Go语言里面提供了一个完善的net/http包,通过http包可以很方便的就搭建起来一个可以运行的Web服务。同时使用这个包能很简单地对Web的路...
  • chenxun2009
  • chenxun2009
  • 2016年07月31日 03:14
  • 5619
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Go Web编程一: Go Web 基础
举报原因:
原因补充:

(最多只允许输入30个字)