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

发布时间：2020-12-16 09:24:05 所属栏目：大数据来源：网络整理

导读：我们平时浏览网页的时候,会打开浏览器，输入网址后按下回车键，然后就会显示出你想要浏览的内容。在这个看似简单的用户行为背后，到底隐藏了些什么呢？对于普通的上网过程，系统其实是这样做的：浏览器本身是一个客户端，当你输入URL的时候，首先浏览器会去

我们平时浏览网页的时候,会打开浏览器，输入网址后按下回车键，然后就会显示出你想要浏览的内容。在这个看似简单的用户行为背后，到底隐藏了些什么呢？
对于普通的上网过程，系统其实是这样做的：浏览器本身是一个客户端，当你输入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服务的工作模式的流程图

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

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

如何监听端口？
如何接收客户端请求？
如何分配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: ",v := range r.Form{
        fmt.Println("key: ",k)
        fmt.Println("val: "," "))
    }
    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

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!