1,web 工作方式
我们平时浏览网页的时候, 会打开浏览器,输入网址后按下回车键,然后就会显示出你想要 浏览的内容.在这个看似简单的用户行为背后,到底隐藏了些什么呢?
对于普通的上网过程,系统其实是这样做的:浏览器本身是一个客户端,当你输入 URL 的 时候,首先浏览器会去请求 DNS 服务器,通过 DNS 获取相应的域名对应的 IP,然后通过 IP 地址找到 IP 对应的服务器后,要求建立 TCP 连接,等浏览器发送完 HTTP Request (请求)包后,服务器接收到请求包之后才开始处理请求包,服务器调用自身服务,返回 HTTP Response(响应)包;客户端收到来自服务器的响应后开始渲染这个 Response 包 里的主体(body),等收到全部的内容随后断开与该服务器之间的 TCP 连接.
用户访问一个 web 站点的过程
Web 服务器的工作原理可以简单地归纳为:
客户机通过 TCP/IP 协议建立到服务器的 TCP 连接
客户端向服务器发送 HTTP 协议请求包,请求服务器里的资源文档
服务器向客户机发送 HTTP 协议应答包,如果请求的资源包含有动态语言的内容, 那么服务器会调用动态语言的解释引擎负责处理 "动态内容",并将处理得到的数据返回给 客户端
客户机与服务器断开.由客户端解释 html 文档,在客户端屏幕上渲染图形结果
2,golang 搭建一个 web 服务
前面已经简单的介绍了 web 服务器的工作原理,那么如何用 golang 搭建一个 web 服务呢?
下面先看个例子
然后在 main 函数中调用 start 方法
package webser
import (
"strings"
"fmt"
"net/http"
"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 chain!")
}
func Start(){
http.HandleFunc("/", sayHelloName)
err := http.ListenAndServe(":9090", nil)
if err != nil{
log.Fatal("ListenAndServe: ", err)
}
}
go run main.go 命令运行程序.
package main
import (
"gostu_demo/webser"
)
func main(){
webser.Start()
}
之后在浏览器中输入地址
http://localhost:9090
,看下结果.
浏览器结果
控制台打印
在 url 中加入参数试试
http://localhost:9090?url_long=111&url_long=222
浏览器结果
控制台打印
我们看到上面的代码,要编写一个 web 服务器很简单,只要调用 http 包的两个函数就可以了.
Go 通过简单的几行代码就已经运行起来一个 web 服务了,而且这个 Web 服务内 部有支持高并发的特性,我将会在接下来的两个小节里面详细的讲解一下 go 是如何实现 Web 高并发的.
3,Go 如何使得 Web 工作
前面小节介绍了如何通过 Go 搭建一个 Web 服务,我们可以看到简单应用一个 net/http 包 就方便的搭建起来了.那么 Go 在底层到底是怎么做的呢?
web 工作方式的几个概念
以下均是服务器端的几个概念
Request:用户请求的信息,用来解析用户的请求信息,包括 post,get,cookie,url 等信息
Response:服务器需要反馈给客户端的信息
Conn:用户的每次请求链接
Handler:处理请求和生成返回信息的处理逻辑
分析 http 包运行机制
如下图所示,是 Go 实现 Web 服务的工作模式的流程图
http 包执行流程
创建 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 处理过程:
监控之后如何接收客户端的请求呢?上面代码执行监控端口之后,调用了 srv.Serve(net.Listener) 函数,这个函数就是处理接收客户端的请求信息.这个函数里面起了 一个 for{},首先通过 Listener 接收请求,其次创建一个 Conn,最后单独开了一个 goroutine,把这个请求的数据当做参数扔给这个 conn 去服务:go c.serve().这个就是高并 发体现了,用户的每一次请求都是在一个新的 goroutine 去服务,相互不影响.
func(srv * Server) Serve(l net.Listener) error {
defer l.Close() var tempDelay time.Duration // how long to sleep on accept failure
for {
rw, e: =l.Accept() if e != nil {
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
}
log.Printf("http: Accept error: %v; retrying in %v", e, tempDelay) time.Sleep(tempDelay) continue
}
return e
}
tempDelay = 0
if srv.ReadTimeout != 0 {
rw.SetReadDeadline(time.Now().Add(srv.ReadTimeout))
}
if srv.WriteTimeout != 0 {
rw.SetWriteDeadline(time.Now().Add(srv.WriteTimeout))
}
c,
err: =srv.newConn(rw) if err != nil {
continue
}
go c.serve()
}
panic("not reached")
}
那么如何具体分配到相应的函数来处理请求呢?conn 首先会解析 request:c.readRequest(), 然后获取相应的 handler:handler := c.server.Handler,也就是我们刚才在调用函数 ListenAndServe 时候的第二个参数,我们前面例子传递的是 nil,也就是为空,那么默认获
取 handler = DefaultServeMux, 那么这个变量用来做什么的呢?对,这个变量就是一个路由 器,它用来匹配 url 跳转到其相应的 handle 函数,那么这个我们有设置过吗? 有,我们调用 的代码里面第一句不是调用了 http.HandleFunc("/", sayhelloName) 嘛.这个作用就是注册了 请求 / 的路由规则,当请求 uri 为 "/",路由就会转到函数 sayhelloName,DefaultServeMux 会调用 ServeHTTP 方法,这个方法内部其实就是调用 sayhelloName 本身,最后通过写入 response 的信息反馈到客户端.
详细的整个流程如下图所示:
一个 http 连接处理流程
4,Go 的 http 包详解
前面小节介绍了 Go 怎么样实现了 Web 工作模式的一个流程,这一小节,我们将详细地解 剖一下 http 包,看它到底是怎样实现整个过程的.
Go 的 http 有两个核心功能:Conn,ServeMux
Conn 的 goroutine
与我们一般编写的 http 服务器不同, Go 为了实现高并发和高性能, 使用了 goroutines 来处 理 Conn 的读写事件, 这样每个请求都能保持独立,相互不会阻塞,可以高效的响应网络事 件.这是 Go 高效的保证.
Go 在等待客户端请求里面是这样写的:
这里我们可以看到客户端的每次请求都会创建一个 Conn,这个 Conn 里面保存了该次请求 的信息,然后再传递到对应的 handler,该 handler 中便可以读取到相应的 header 信息, 这样保证了每个请求的独立性.
c,
err: =srv.newConn(rw) if err != nil {
continue
}
go c.serve()
ServeMux 的自定义
我们前面小节讲述 conn.server 的时候,其实内部是调用了 http 包默认的路由器,通过路 由器把本次请求的信息传递到了后端的处理函数.那么这个路由器是怎么实现的呢?
它的结构如下:
下面看一下 muxEntry
type ServeMux struct {
mu sync.RWMutex //锁,由于请求涉及到并发处理,因此这里需要一个锁机制
m map[string] muxEntry // 路由规则,一个string对应一个mux实体,这里的string就是注册 的路由表达式
}
接着看一下 Handler 的定义
type muxEntry struct {
explicit bool // 是否精确匹配
h Handler // 这个路由表达式对应哪handler
}
Handler 是一个接口,但是前一小节中的 sayhelloName 函数并没有实现 ServeHTTP 这个 接口,为什么能添加呢?原来在 http 包里面还定义了一个类型 HandlerFunc, 我们定义的函 数 sayhelloName 就是这个 HandlerFunc 调用之后的结果,这个类型默认就实现了 ServeHTTP 这个接口,即我们调用了 HandlerFunc(f), 强制类型转换 f 成为 HandlerFunc 类 型,这样 f 就拥有了 ServHTTP 方法.
type Handler interface {
ServeHTTP(ResponseWriter, *Request) // 路由实现器
}
路由器里面存储好了相应的路由规则之后,那么具体的请求又是怎么分发的呢?
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) 怎么处理的呢?
原来他是根据用户请求的 URL 和路由器里面存储的 map 去匹配的,当匹配到之后返回存 储的 handler,调用这个 handler 的 ServHTTP 接口就可以执行到相应的函数了.
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
}
如下代码所示,我们自己实现了一个简易的路由器:
在 main 中调用 Start 函数
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)
}
}
运行之后在浏览器中分别输入地址查看结果:
package main
import (
"gostu_demo/webser"
)
func main(){
webser.Start()
}
http://localhost:9090/about
浏览器结果
http://localhost:9090
浏览器结果
源码
github 源码地址
完
来源: http://www.jianshu.com/p/ae9b5628d18b