文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

图文讲透Golang标准库 net/http实现原理 - 客户端

2024-11-30 01:50

关注

这次我把调用的核心方法和流程走读的函数也贴出来,这样看应该更有逻辑感,重要部分用红色标记了一下,可以着重看下。

图片

先了解下核心数据结构Client和Request。

Client结构体

type Client struct { 
    Transport RoundTripper 
    CheckRedirect func(req *Request, via []*Request) error 
    Jar CookieJar 
    Timeout time.Duration
}

四个字段分别是:

Request结构体

Request字段较多,这里就列举一下常见的一些字段

type Request struct {
    Method string
    URL *url.URL
    Header Header
    Body io.ReadCloser
    Host string
    Response *Response
    ...
}

构造请求

var DefaultClient = &Client{}

func Get(url string) (resp *Response, err error) {
    return DefaultClient.Get(url)
}

示例HTTP 的 Get方法会调用到 DefaultClient 的 Get 方法,,然后调用到 Client 的 Get 方法。

DefaultClient 是 Client 的一个空实例(跟DefaultServeMux有点子相似)

图片

Client.Get

func (c *Client) Get(url string) (resp *Response, err error) {
    req, err := NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }
    return c.Do(req)
}

func NewRequest(method, url string, body io.Reader) (*Request, error) {
    return NewRequestWithContext(context.Background(), method, url, body)
}

Client.Get() 根据用户的入参,请求参数 NewRequest使用上下文包装NewRequestWithContext ,接着通过 Client.Do 方法,处理这个请求。

NewRequestWithContext

func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
    ...
    // 解析url
    u, err := urlpkg.Parse(url)
    ...
    rc, ok := body.(io.ReadCloser)
    if !ok && body != nil {
        rc = ioutil.NopCloser(body)
    } 
    u.Host = removeEmptyPort(u.Host)
    req := &Request{
        ctx:        ctx,
        Method:     method,
        URL:        u,
        Proto:      "HTTP/1.1",
        ProtoMajor: 1,
        ProtoMinor: 1,
        Header:     make(Header),
        Body:       rc,
        Host:       u.Host,
    } 
    ...
    return req, nil
}

NewRequestWithContext 函数主要是功能是将请求封装成一个 Request 结构体并返回,这个结构体的名称是req。

准备发送请求

构造好的Request结构req,会传入c.Do()方法。

我们看下发送请求过程调用了哪些方法,用下图表示下

图片

🚩 其实不管是Get还是Post请求的调用流程都是一样的,只是对外封装了Post和Get请求

func (c *Client) do(req *Request) (retres *Response, reterr error) {
    ...
    for {
        ...
        resp, didTimeout, err = send(req, deadline)
        if err != nil {
            return nil, didTimeout, err
        }
    }
    ...
}
//Client 调用 Do 方法处理发送请求最后会调用到 send 函数中
func (c *Client) send(req *Request, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
    resp, didTimeout, err = send(req, c.transport(), deadline)
    if err != nil {
        return nil, didTimeout, err
    }
    ...
    return resp, nil, nil
}

c.transport()方法是为了回去Transport的默认实例 DefaultTransport ,我们看下DefaultTransport长什么样。

DefaultTransport

var DefaultTransport RoundTripper = &Transport{
    Proxy: ProxyFromEnvironment,
    DialContext: defaultTransportDialContext(&net.Dialer{
        Timeout:   30 * time.Second,
        KeepAlive: 30 * time.Second,
    }),
    ForceAttemptHTTP2:     true,
    MaxIdleConns:          100,
    IdleConnTimeout:       90 * time.Second,
    TLSHandshakeTimeout:   10 * time.Second,
    ExpectContinueTimeout: 1 * time.Second,
}

可以根据需要建立网络连接,并缓存它们以供后续调用重用,部分参数如下:

注意这里的RoundTripper是个接口,也就是说 Transport 实现 RoundTripper 接口,该接口方法接收Request,返回Response。

RoundTripper

type RoundTripper interface { 
    RoundTrip(*Request) (*Response, error)
}

图片

虽然还没看完后面逻辑,不过我们猜测RoundTrip方法可能是实际处理客户端请求的实现。

我们继续追下后面逻辑,看下是否能验证这个猜想。

func send(ireq *Request, rt RoundTripper, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
    ...
    resp, err = rt.RoundTrip(req)
    if err != nil {
        ...
    }
    ..
}

👉 你看send函数的第二个参数就是接口类型,调用层传递的Transport的实例DefaultTransport。

而rt.RoundTrip()方法的调用具体在net/http/roundtrip.go文件中,这也是RoundTrip接口的实现,代码如下:

func (t *Transport) RoundTrip(req *Request) (*Response, error) {
    return t.roundTrip(req)
}

Transport.roundTrip 方法概况来说干了这些事:

func (t *Transport) roundTrip(req *Request) (*Response, error) {
    ...  
    for {
        ...
        // 请求封装
        treq := &transportRequest{Request: req, trace: trace, cancelKey: cancelKey} 
        cm, err := t.connectMethodForRequest(treq)
        if err != nil {
            ...
        } 
        // 获取连接
        pconn, err := t.getConn(treq, cm)
        if err != nil {
            ...
        }
        
        // 等待响应结果
        var resp *Response
        if pconn.alt != nil {
            t.setReqCanceler(cancelKey, nil) 
            resp, err = pconn.alt.RoundTrip(req)
        } else {
            resp, err = pconn.roundTrip(treq)
        }
        ...
    }
}

封装请求transportRequeste没啥好说的,因为treq被roundTrip修改,所以这里需要为每次重试重新创建。

获取连接

获取连接的方法是 getConn,这里代码还是比较长的,会有不同的两种方式去获取连接:

  1. 1. 调用 queueForIdleConn 排队等待获取空闲连接
  2. 2. 如果获取空闲连接失败,那么调用 queueForDial 异步创建一个新的连接,并通过channel来接收readdy信号,来确认连接是否构造完成

图片

getConn

func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {
    ...
    //  初始化wantConn结构体
    w := &wantConn{
        cm:         cm,
        key:        cm.key(),
        ctx:        ctx,
        ready:      make(chan struct{}, 1),
        beforeDial: testHookPrePendingDial,
        afterDial:  testHookPostPendingDial,
    }
    ...
    // 获取空闲连接
    if delivered := t.queueForIdleConn(w); delivered {
        ...
    }
 
    // 异步创建新连接
    t.queueForDial(w)
 
    select {
    // 阻塞等待获取到连接完成
    case <-w.ready:
        ...
        return w.pc, w.err
    ...
}

queueForIdleConn获取空闲连接

获取成功

成功空闲获取连接Conn流程如下图

图片

  1. 1. 根据wantConn的key从 transport.idleConn 这个map中查找,看是否存不存在空闲的 connection 列表
  2. 2. 获取到空闲的 connection 列表后,从列表中拿最后一个 connection
  3. 3. 获取到连接后会调用 wantConn.tryDeliver 方法将连接绑定到 wantConn 请求参数上

获取失败

图片

当不存在该请求的 connection 列表,会将当前 wantConn 加入到名称为 idleConnWait 的等待空闲map中。

不过此时的idleConnWait这个map的值是个队列

queueForIdleConn方法

从上面的两张图解中差不多能看出是如何获取空闲连接和如何获取失败时如何做的了,这里也贴下代码体验下,让大家更清楚里面的实现逻辑。

//idleConn是map类型,指定key返回切片列表
idleConn     map[connectMethodKey][]*persistConn 
//idleConnWait,指定key返回队列
idleConnWait map[connectMethodKey]wantConnQueue

这里将获取空闲连接的代码实现多进行注释,更好理解一些!

func (t *Transport) queueForIdleConn(w *wantConn) (delivered bool) {
    //参数判断
    if t.DisableKeepAlives {
        return false
    }

    if w == nil { 
        return false
    }
 
    // 计算空闲连接超时时间
    var oldTime time.Time
    if t.IdleConnTimeout > 0 {
        oldTime = time.Now().Add(-t.IdleConnTimeout)
    }
    //从idleConn根据w.key找对应的persistConn 列表
    if list, ok := t.idleConn[w.key]; ok {
        stop := false
        delivered := false
        for len(list) > 0 && !stop {
            // 找到persistConn列表最后一个
            pconn := list[len(list)-1] 
            // 检查这个 persistConn 是不是过期
            tooOld := !oldTime.IsZero() && pconn.idleAt.Round(0).Before(oldTime)
            if tooOld {
                //如果过期进行异步清理
                go pconn.closeConnIfStillIdle()
            }
            // 该 persistConn 被标记为 broken 或 闲置太久 continue
            if pconn.isBroken() || tooOld { 
                list = list[:len(list)-1]
                continue
            }
            // 尝试将该 persistConn 写入到 wantConn(w)中
            delivered = w.tryDeliver(pconn, nil)
            if delivered {
                // 写入成功,将persistConn从空闲列表中移除
                if pconn.alt != nil { 
                } else { 
                    t.idleLRU.remove(pconn)
                    //缺省了最后一个conn
                    list = list[:len(list)-1]
                }
            }
            stop = true
        }
        //对被获取连接后的列表进行判断
        if len(list) > 0 {
            t.idleConn[w.key] = list
        } else {
            // 如果该 key 对应的空闲列表不存在,那么将该key从字典中移除
            delete(t.idleConn, w.key)
        }
        if stop {
            return delivered
        }
    } 
    // 如果找不到空闲的 persistConn
    if t.idleConnWait == nil {
        t.idleConnWait = make(map[connectMethodKey]wantConnQueue)
    }
    // 将该 wantConn添加到等待空闲idleConnWait中
    q := t.idleConnWait[w.key] 
    q.cleanFront()
    q.pushBack(w)
    t.idleConnWait[w.key] = q
    return false
}

我们知道了为找到的空闲连接会被放到空闲 idleConnWait 这个等待map中,最后会被Transport.tryPutIdleConn方法将pconne添加到等待新请求的空闲持久连接列表中。

queueForDial创建新连接

queueForDial意思是排队等待拨号,为什么说是等带呢,因为最终的结果是在ready这个channel上进行通知的。

流程如下图:

图片

我们先看下Transport结构体的这两个map,名称不一样map的属性和解释都是一样的,其中idleConnWait是在没查找空闲连接的时候存放当前连接的map。

而connsPerHostWait用在了创建新连接的地方,可以猜测一下创建新链接的地方就是将当前的请求放入到 connsPerHostWait 等待map中。

// waiting getConns
idleConnWait map[connectMethodKey]wantConnQueue 
// waiting getConns
connsPerHostWait map[connectMethodKey]wantConnQueue

Transport.queueForDial

func (t *Transport) queueForDial(w *wantConn) {
    w.beforeDial()
    // 小于等于零,意思是限制,直接异步建立连接
    if t.MaxConnsPerHost <= 0 {
        go t.dialConnFor(w)
        return
    }
    ...
    //host建立的连接数没达到上限,执行异步建立连接
    if n := t.connsPerHost[w.key]; n < t.MaxConnsPerHost {
        if t.connsPerHost == nil {
            t.connsPerHost = make(map[connectMethodKey]int)
        }
        t.connsPerHost[w.key] = n + 1
        go t.dialConnFor(w)
        return
    }
    //进入等待队列
    if t.connsPerHostWait == nil {
        t.connsPerHostWait = make(map[connectMethodKey]wantConnQueue)
    }
    q := t.connsPerHostWait[w.key]
    q.cleanFront()
    q.pushBack(w)
    t.connsPerHostWait[w.key] = q
}

在获取不到空闲连接之后,会尝试去建立连接:

  1. 1. queueForDial 方法的内部会先校验 MaxConnsPerHost 是否未设置和是否已达上限
  2. 1.
  1. 1. 检验不通过则将当前的请求放入到 connsPerHostWait 这个等待map中
  2. 2. 校验通过那么会异步的调用 dialConnFor 方法创建连接

👉那会不会queueForDial方法中将idleConnWait和connsPerHostWait打包到等待空闲连接idleConn这个map中呢?

我们继续看dialConnFor的实现,它会给我们这个问题的答案!

dialConnFor

func (t *Transport) dialConnFor(w *wantConn) {
    defer w.afterDial()
    //创建 persistConn
    pc, err := t.dialConn(w.ctx, w.cm)
    //绑定到 wantConn
    delivered := w.tryDeliver(pc, err)
    if err == nil && (!delivered || pc.alt != nil) {
        //绑定wantConn失败
        //放到存放空闲连接idleConn的map中
        t.putOrCloseIdleConn(pc)
    }
    if err != nil {
        t.decConnsPerHost(w.key)
    }
}

我们可以追踪下代码会发现Transport.tryPutIdleConn() 方法就是将persistConn添加到等待的空闲持久连接列表中的实现。

Transport.dialConn创建连接

func (t *Transport) dialConn(ctx context.Context, cm connectMethod) (pconn *persistConn, err error) {
    pconn = &persistConn{
        t:             t,
        cacheKey:      cm.key(),
        reqch:         make(chan requestAndChan, 1),
        writech:       make(chan writeRequest, 1),
        closech:       make(chan struct{}),
        writeErrCh:    make(chan error, 1),
        writeLoopDone: make(chan struct{}),
    }
    ...
    // 创建 tcp 连接,给pconn.conn
    conn, err := t.dial(ctx, "tcp", cm.addr())
    if err != nil {
        return nil, wrapErr(err)
    }
    pconn.conn = conn
    ...
    //开启两个goroutine处理读写
    go pconn.readLoop()
    go pconn.writeLoop()
    return pconn, nil
}

👉 看完这个创建persistConn的代码是不是心里仿佛懂了什么?

上述代码中HTTP 连接的创建过程是建立 tcp 连接,然后为连接异步处理读写数据,最后将创建好的连接返回。

我们可以看到创建的每个连接会分别创建两个goroutine循环地进行进行读写的处理,这就是为什么我们连接能接受请求参数和处理请求的响应的关键。

👉 这两个协程功能是这样的!

  1. 1. persisConn.writeLoop(),通过 persistConn.writech 通道读取到客户端提交的请求,将其发送到服务端
  2. 2. persisConn.readLoop(),读取来自服务端的响应,并添加到 persistConn.reqCh 通道中,给persistConn.roundTrip 方法接收

想看这两个协程

等待响应

persistConn 连接本身创建了两个读写goroutine,而这两个goroutine就是通过两个channel进行通信的。

这个通信就是在persistConn.roundTrip()方法中的进行传递交互的,其中writech 是用来写入请求数据,reqch是用来读取响应数据。

图片

func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err error) {
    ...
    // 请求数据写入到 writech channel中
    pc.writech <- writeRequest{req, writeErrCh, continueCh}

    // 接收响应的channel
    resc := make(chan responseAndError)
    // 接收响应的结构体 requestAndChan 写到 reqch channel中
    pc.reqch <- requestAndChan{
        req:        req.Request,
        cancelKey:  req.cancelKey,
        ch:         resc,
        ...
    }
    ...
    for {
        ...
        select { 
            // 接收到响应数据
        case re := <-resc:
            ...
            // return响应数据
            return re.res, nil
        ...
    }
}

 连接获取到之后,会调用连接的 roundTrip 方法,将请求数据写入到 persisConn.writech channel中,而连接 persisConn 中的协程 writeLoop() 接收到请求后就会处理请求

 响应结构体 requestAndChan 写入到 persisConn.reqch 中

 通过readLoop 接受响应数据,然后读取 resc channel 的响应结果

 接受到响应数据之后循环结束,连接处理完成

好了,net/http标准库的客户端构造请求、发送请求、接受服务端的请求数据流程就讲完了,看完之后是否意欲未尽呢?

还别说,小许也是第一次看是如何实现的,确实还是了解到了点东西呢!

来源:小许code内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯