换个语言学一下 Golang （12）——Web基础

一、web工作方式

我们平时浏览网页的时候,会打开浏览器，输入网址后按下回车键，然后就会显示出你想要浏览的内容。在这个看似简单的用户行为背后，到底隐藏了些什么呢？
对于普通的上网过程，系统其实是这样做的：浏览器本身是一个客户端，当你输入URL的时候，首先浏览器会去请求DNS服务器，通过DNS获取相应的域名对应的IP，然后通过IP地址找到IP对应的服务器后，要求建立TCP连接，等浏览器发送完HTTP Request（请求）包后，服务器接收到请求包之后才开始处理请求包，服务器调用自身服务，返回HTTP Response（响应）包；客户端收到来自服务器的响应后开始渲染这个Response包里的主体（body），等收到全部的内容随后断开与该服务器之间的TCP连接。

一个Web服务器也被称为HTTP服务器，它通过HTTP协议与客户端通信。这个客户端通常指的是Web浏览器(其实手机端客户端内部也是浏览器实现的)。
Web服务器的工作原理可以简单地归纳为：
        · 客户机通过TCP/IP协议建立到服务器的TCP连接
        · 客户端向服务器发送HTTP协议请求包，请求服务器里的资源文档
        · 服务器向客户机发送HTTP协议应答包，如果请求的资源包含有动态语言的内容，
        那么服务器会调用动态语言的解释引擎负责处理“动态内容”，并将处理得到的数据返回给客户端
        · 客户机与服务器断开。由客户端解释HTML文档，在客户端屏幕上渲染图形结果
        一个简单的HTTP事务就是这样实现的，看起来很复杂，原理其实是挺简单的。需要注意的是客户机与服务器之间的通信是非持久连接的，也就是当服务器发送了应答后就与客户机断开连接，等待下一次请求。

二、Go搭建一个Web服务器

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

http包建立Web服务器

package main

import (
    "fmt"
    "net/http"
    "strings"
    "log"
)

func sayhelloName(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["url_long"])
    for k, v := range r.Form {
        fmt.Println("key:", k)
        fmt.Println("val:", strings.Join(v, ""))
    }
    fmt.Fprintf(w, "Hello astaxie!") //这个写入到w的是输出到客户端的
}

func main() {
    http.HandleFunc("/", sayhelloName) //设置访问的路由
    err := http.ListenAndServe(":9090", nil) //设置监听的端口
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

上面这个代码，我们build之后，然后执行web.exe,这个时候其实已经在9090端口监听http链接请求了。

但是这时候服务器是没有输出的。

在浏览器输入http://localhost:9090

可以看到浏览器页面输出了Hello astaxie!

服务器输出如下

可以换一个地址试试：http://localhost:9090/?url_long=111&url_long=222

看看浏览器输出的是什么，服务器输出的是什么？

在服务器端输出的信息如下：

三、Go如何使得Web工作

我们可以看到简单应用一个net/http包就方便的搭建起来了。那么Go在底层到底是怎么做的呢？万变不离其宗，Go的Web服务工作也离不开我们第一小节介绍的Web工作方式。

web工作方式的几个概念

以下均是服务器端的几个概念

Request：用户请求的信息，用来解析用户的请求信息，包括post、get、cookie、url等信息

Response：服务器需要反馈给客户端的信息

Conn：用户的每次请求链接

Handler：处理请求和生成返回信息的处理逻辑

分析http包运行机制

如下图所示，是Go实现Web服务的工作模式的流程图

1. 创建Listen Socket, 监听指定的端口, 等待客户端请求到来。
2. Listen Socket接受客户端的请求, 得到Client Socket, 接下来通过Client Socket与 客户端通信。
3. 处理客户端的请求, 首先从Client Socket读取HTTP请求的协议头, 如果是POST 方法, 还可能要读取客户端提交的数据, 然后交给相应的handler处理请求, handler处理完 毕准备好客户端需要的数据, 通过Client Socket写给客户端。

这整个的过程里面我们只要了解清楚下面三个问题，也就知道Go是如何让Web运行起来了

1. 如何监听端口？
2. 如何接收客户端请求？
3. 如何分配handler？

前面小节的代码里面我们可以看到，Go是通过一个函数ListenAndServe来处理这些事情 的，这个底层其实这样处理的：初始化一个server对象，然后调用了net.Listen("tcp", addr)，也就是底层用TCP协议搭建了一个服务，然后监控我们设置的端口。
下面代码来自Go的http包的源码，通过下面的代码我们可以看到整个的http处理过程：

func (srv *Server) Serve(l net.Listener) error {
    if fn := testHookServerServe; fn != nil {
        fn(srv, l) // call hook with unwrapped listener
    }

    l = &onceCloseListener{Listener: l}
    defer l.Close()

    if err := srv.setupHTTP2_Serve(); err != nil {
        return err
    }

    if !srv.trackListener(&l, true) {
        return ErrServerClosed
    }
    defer srv.trackListener(&l, false)

    var tempDelay time.Duration     // how long to sleep on accept failure
    baseCtx := context.Background() // base is always background, per Issue 16220
    ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    for {
        rw, e := l.Accept() //通过Listener接收请求
        if e != nil {
            select {
            case <-srv.getDoneChan():
                return ErrServerClosed
            default:
            }
            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)        //创建一个Conn
        c.setState(c.rwc, StateNew) // before Serve can return
        go c.serve(ctx)             //单独开了一个 goroutine.把这个请求的数据当做参数扔给这个conn去服务
    }
}

监控之后如何接收客户端的请求呢？上面代码执行监控端口之后，调用了 srv.Serve(net.Listener)函数，这个函数就是处理接收客户端的请求信息。这个函数里面起了 一个for{}，首先通过Listener接收请求，其次创建一个Conn，最后单独开了一个 goroutine，把这个请求的数据当做参数扔给这个conn去服务：go c.serve()。这个就是高并 发体现了，用户的每一次请求都是在一个新的goroutine去服务，相互不影响。
那么如何具体分配到相应的函数来处理请求呢？conn首先会解析request:c.readRequest(), 然后获取相应的handler:handler := c.server.Handler，也就是我们刚才在调用函数 ListenAndServe时候的第二个参数，我们前面例子传递的是nil，也就是为空，那么默认获
取handler = DefaultServeMux,那么这个变量用来做什么的呢？对，这个变量就是一个路由 器，它用来匹配url跳转到其相应的handle函数，那么这个我们有设置过吗?有，我们调用 的代码里面第一句不是调用了http.HandleFunc("/", sayhelloName)嘛。这个作用就是注册了 请求/的路由规则，当请求uri为"/"，路由就会转到函数sayhelloName，DefaultServeMux 会调用ServeHTTP方法，这个方法内部其实就是调用sayhelloName本身，最后通过写入 response的信息反馈到客户端。
详细的整个流程如下图所示：

四、Go的 http包详解

Go的http有两个核心功能：Conn、ServeMux

Conn的 goroutine

与我们一般编写的http服务器不同, Go为了实现高并发和高性能, 使用了goroutines来处 理Conn的读写事件, 这样每个请求都能保持独立，相互不会阻塞，可以高效的响应网络事 件。这是Go高效的保证。
Go在等待客户端请求里面是这样写的：

c, err := srv.newConn(rw)
if err != nil {
    continue
}
go c.serve()

这里我们可以看到客户端的每次请求都会创建一个Conn，这个Conn里面保存了该次请求 的信息，然后再传递到对应的handler，该handler中便可以读取到相应的header信息， 这样保证了每个请求的独立性。

ServeMux的自定义

我们前面小节讲述conn.server的时候，其实内部是调用了http包默认的路由器，通过路 由器把本次请求的信息传递到了后端的处理函数。那么这个路由器是怎么实现的呢？
它的结构如下：

type ServeMux struct {
     mu sync.RWMutex   //锁，由于请求涉及到并发处理，因此这里需要一个锁机制
     m  map[string]muxEntry  // 路由规则，一个string对应一个mux实体，这里的string就是注册 的路由表达式
}

下面看一下muxEntry

type muxEntry struct {
    explicit bool   // 是否精确匹配
    h Handler // 这个路由表达式对应哪handler
}

接着看一下Handler的定义

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)  // 路由实现器
}

Handler是一个接口，但是前一小节中的sayhelloName函数并没有实现ServeHTTP这个 接口，为什么能添加呢？原来在http包里面还定义了一个类型HandlerFunc,我们定义的函 数sayhelloName就是这个HandlerFunc调用之后的结果，这个类型默认就实现了 ServeHTTP这个接口，即我们调用了HandlerFunc(f),强制类型转换f成为HandlerFunc类 型，这样f就拥有了ServHTTP方法。

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

路由器里面存储好了相应的路由规则之后，那么具体的请求又是怎么分发的呢？
路由器接收到请求之后调用mux.handler(r).ServeHTTP(w, r)
也就是调用对应路由的handler的ServerHTTP接口，那么mux.handler(r)怎么处理的呢？

func (mux *ServeMux) handler(r *Request) Handler {
    mux.mu.RLock()
    defer mux.mu.RUnlock()    // Host-specific pattern takes precedence over generic ones
    h := mux.match(r.Host + r.URL.Path)
    if h == nil {
        h = mux.match(r.URL.Path)
    }
    if h == nil {
        h = NotFoundHandler()
    }
    return h
}

原来他是根据用户请求的URL和路由器里面存储的map去匹配的，当匹配到之后返回存 储的handler，调用这个handler的ServHTTP接口就可以执行到相应的函数了。

如下代码所示，我们自己实现了一个简易的路由器：

package webser

import (
    "strings"
    "fmt"
    "net/http"
    "log"
)

type MyMux struct{
}

func (p *MyMux)ServeHTTP(w http.ResponseWriter, r *http.Request){
    if r.URL.Path == "/"{
        sayHelloName(w, r)
        return
    }
    if r.URL.Path == "/about"{
        about(w, r)
        return
    }
    http.NotFound(w,r)
    return
}

func sayHelloName(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["url_long"])
    for k, v := range r.Form{
        fmt.Println("key: ", k)
        fmt.Println("val: ", strings.Join(v, " "))
    }
    fmt.Fprintf(w, "hello chain!")
}

func about(w http.ResponseWriter, r *http.Request){
    fmt.Fprintf(w, "i am chain, from shanghai")
}

func Start(){
    mux := &MyMux{}
    err := http.ListenAndServe(":9090", mux)
    if err != nil{
        log.Fatal("ListenAndServe: ", err)
    }
}

在main中调用Start函数

package main
import (
    "gostu_demo/webser"
)
func main(){
    webser.Start()
}

运行之后在浏览器中分别输入地址查看结果：
http://localhost:9090/about

五、Go代码的执行流程

通过对http包的分析之后，现在让我们来梳理一下整个的代码执行过程。
首先调用Http.HandleFunc
按顺序做了几件事：

1. 调用了DefaultServerMux的HandleFunc
2. 调用了DefaultServerMux的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. 在这个例子中，下面就进入到DefaultServerMux.ServeHttp
10. 根据request选择handler，并且进入到这个handler的ServeHTTP
    mux.handler(r).ServeHTTP(w, r)
11. 选择handler：
    A 判断是否有路由能满足这个request（循环遍历ServerMux的muxEntry）
    B 如果有路由满足，调用这个路由handler的ServeHttp
    C 如果没有路由满足，调用NotFoundHandler的ServeHttp

源码

github 源码地址

转载自 Golang Web学习（13）—— 搭建简单的Web服务器