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 之旅五: 并发

发表一篇学习 A Tour of Go整理的笔记,主要介绍Go 轻量级线程,信道以及互斥锁的概念和使用方法。

Go 标准库介绍一: strings

本文介绍Go 标准库 strings 常用导出函数,结构体及其方法。

golang chan 单项通道与多项通道

package main import ( "fmt" ) func main() { var chan_test chan interface{} //双项通道 var read_t...

GO语言学习-并发

并发

Go在谷歌:以软件工程为目的的语言设计

[转载自 开源中国 oschina.net] 本文地址:http://www.oschina.net/translate/go-at-google-language-design-in-th...
  • kenkao
  • kenkao
  • 2016-09-08 10:39
  • 1140

GO语言学习-复杂类型(2)

map

GO语言学习-内建函数

close:用于channel通讯。来关闭channel delete:用于在map中删除实例 len和cap:可用于不同的类型,len用于返回字符串,slice和数组的长度,cap用于返回容量 ...

golang获取并解析ajax请求参数(带数组)

前台代码:(category是数组) var data = { title: title, category: category.split(","), cancomment: c...
  • samete
  • samete
  • 2017-01-19 10:25
  • 1110

Go获取命令行参数及信号量处理

部署golang项目时难免要通过命令行来设置一些参数,那么在golang中如何操作命令行参数呢?可以使用os库和flag库。 golang os库获取命令行参数 os可以通过变量Args来获取命令...
  • kenkao
  • kenkao
  • 2015-08-22 11:15
  • 3503

GO语言学习:动态Web

使用Golang在HTML中实现动态页面
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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