我是 PHP 程序员

响应行
响应头
响应空行
响应体

Bdpagetype: 3
Connection: keep-alive
Content-Length: 154
Content-Type: text/html
Date: Wed, 15 Feb 2023 07:31:16 GMT
Location: https://www.baidu.com/search/error.html

type Response struct {
    Status           string               //表示HTTP响应的状态行中的状态码和原因短语，例如"200 OK"
    StatusCode       int                  //表示HTTP响应的状态码，例如200
    Proto            string               //表示使用的HTTP协议版本，例如"HTTP/1.1"
    ProtoMajor       int                  //表示使用的HTTP协议版本的主版本号，例如1
    ProtoMinor       int                  //表示使用的HTTP协议版本的副版本号，例如1
    Header           Header               //表示HTTP响应的头部信息，是一个Header类型的映射
    Body             io.ReadCloser        //表示HTTP响应的主体，是一个io.ReadCloser类型的接口，可以读取响应的数据
    ContentLength    int64                //表示HTTP响应的主体的长度，如果长度未知则为-1
    TransferEncoding []string             //表示HTTP响应的传输编码，例如"chunked"，如果未设置则为nil
    Close            bool                 //表示HTTP响应是否需要关闭连接
    Uncompressed     bool                 //表示HTTP响应是否已经解压缩
    Trailer          Header               //表示HTTP响应的头部信息中未确定的部分
    Request          *Request             //表示发送HTTP请求的Request结构体，如果未设置则为nil
    TLS              *tls.ConnectionState //表示HTTP响应的TLS连接信息，如果未使用TLS则为nil
}

/**
参数说明:
    r  指向bufio.Reader类型的指针r，表示HTTP响应的字节流数据来源
    req 指向http.Request类型的指针req，表示与HTTP响应相关的HTTP请求信息
*/
func ReadResponse(r *bufio.Reader, req *Request) (*Response, error) {
    //创建一个textproto.Reader类型的对象tp，并将bufio.Reader对象r传递给它，用于读取HTTP响应的文本部分
    tp := textproto.NewReader(r)
    //传入req创建Response对象
    resp := &Response{
        Request: req,
    }
    //调用tp.ReadLine()方法读取HTTP响应的第一行，即响应行，并将读取的文本内容保存在line变量中
    line, err := tp.ReadLine()
    if err != nil {
        if err == io.EOF {
            err = io.ErrUnexpectedEOF
        }
        return nil, err
    }
    //解析响应行line变量，如果格式正确，则解析变量中的Proto协议信息以及Status状态信息，否责报badStringError类型错误
    if i := strings.IndexByte(line, ' '); i == -1 {
        return nil, badStringError("malformed HTTP response", line)
    } else {
        resp.Proto = line[:i]
        resp.Status = strings.TrimLeft(line[i+1:], " ")
    }
    //解析Status状态信息，如果格式正确，则解析出状态码并赋值给statusCode，否责报badStringError类型错误
    statusCode := resp.Status
    if i := strings.IndexByte(resp.Status, ' '); i != -1 {
        statusCode = resp.Status[:i]
    }
    //校验状态码长度
    if len(statusCode) != 3 {
        return nil, badStringError("malformed HTTP status code", statusCode)
    }

    //校验状态码信息
    resp.StatusCode, err = strconv.Atoi(statusCode)
    if err != nil || resp.StatusCode < 0 {
        return nil, badStringError("malformed HTTP status code", statusCode)
    }
    var ok bool
    //解析校验协议版本信息
    if resp.ProtoMajor, resp.ProtoMinor, ok = ParseHTTPVersion(resp.Proto); !ok {
        return nil, badStringError("malformed HTTP version", resp.Proto)
    }

    //解析HTTP响应头部，并将解析结果存储在resp的Header字段中
    //ReadMIMEHeader方法实际上是先读取到HTTP头部和空行之间的所有文本行，然后将它们解析为键值对，最后返回一个map[string][]string类型的对象，其中键表示HTTP头部的名称，值表示HTTP头部的值
    mimeHeader, err := tp.ReadMIMEHeader()
    if err != nil {
        if err == io.EOF {
            err = io.ErrUnexpectedEOF
        }
        return nil, err
    }
    resp.Header = Header(mimeHeader)
    //调用了fixPragmaCacheControl函数，该函数用于规范化HTTP头部中的Pragma和Cache-Control字段，使得这两个字段只出现一次，并且同时存在时Cache-Control字段的优先级更高。
    //这样做是因为Pragma字段在HTTP/1.0时代用于控制缓存，而Cache-Control字段是HTTP/1.1引入的用于控制缓存的标准字段
    fixPragmaCacheControl(resp.Header)

    //调用readTransfer函数，读取HTTP响应消息体
    err = readTransfer(resp, r)
    if err != nil {
        return nil, err
    }
    return resp, nil
}

func (r *Response) Write(w io.Writer) error

func (r *Response) Write(w io.Writer) error {
    //将状态信息从Status中解析出来
    text := r.Status
    if text == "" {
        var ok bool
        text, ok = statusText[r.StatusCode]
        if !ok {
            text = "status code " + strconv.Itoa(r.StatusCode)
        }
    } else {
        text = strings.TrimPrefix(text, strconv.Itoa(r.StatusCode)+" ")
    }
    //向客户端写入响应行信息，包括协议 状态码 状态信息
    if _, err := fmt.Fprintf(w, "HTTP/%d.%d %03d %s\r\n", r.ProtoMajor, r.ProtoMinor, r.StatusCode, text); err != nil {
        return err
    }

    //创建Response指针对象r1,并将*r赋值给r1
    r1 := new(Response)
    *r1 = *r

    /**
    响应主体不为空但响应主体长度为0的情况，读取响应主体信息以及长度并赋值给n和buf变量：
    1. 如果buf不为空，并且不是io.EOF结束符，则将buf作为错误信息直接返回
    2.
        2-1 如果n等于0，表示主体为空，将Response.Body赋值为noBody空结构
        2-2 如果n不等于0，设置Response.ContentLength长度为-1，表示响应未知长度；
            接着创建了一个结构体，其中包含两个接口类型 io.Reader 和 io.Closer这个结构体被用来替换 Response 对象的 Body 属性，也就是响应体的内容
            新的响应体是一个 io.MultiReader 对象，由两个 Reader 组成，第一个 Reader 是一个长度为1的 bytes.Reader 对象，第二个 Reader 是原始响应对象的 Body。
            io.MultiReader 对象可以将多个 Reader 拼接在一起，用于顺序读取多个 Reader 的内容
    */
    if r1.ContentLength == 0 && r1.Body != nil {
        var buf [1]byte
        n, err := r1.Body.Read(buf[:])
        if err != nil && err != io.EOF {
            return err
        }
        if n == 0 {
            r1.Body = NoBody
        } else {
            r1.ContentLength = -1
            r1.Body = struct {
                io.Reader
                io.Closer
            }{
                io.MultiReader(bytes.NewReader(buf[:1]), r.Body),
                r.Body,
            }
        }
    }

    //根据HTTP协议的规范决定是否需要在响应结束后关闭连接。例如，如果响应体的长度未知，连接可能需要在响应结束后关闭
    if r1.ContentLength == -1 && !r1.Close && r1.ProtoAtLeast(1, 1) && !chunked(r1.TransferEncoding) && !r1.Uncompressed {
        r1.Close = true
    }

    //根据 r1 中的信息，创建一个新的 TransferWriter 对象并返回
    tw, err := newTransferWriter(r1)
    if err != nil {
        return err
    }
    //写入响应头信息
    err = tw.writeHeader(w, nil)
    if err != nil {
        return err
    }

    //排除掉指定的响应头部信息，即respExcludeHeader里面的头部信息
    err = r.Header.WriteSubset(w, respExcludeHeader)
    if err != nil {
        return err
    }
    //调用 tw.shouldSendContentLength() 方法，用于检查是否已经在之前的响应头部中添加了 Content-Length 字段。
    //如果已经添加过，那么无需再次添加。然后，它检查当前响应体的长度是否为 0，是否使用了分块编码，以及当前响应状态码是否允许包含响应体。
    //如果满足这些条件，则需要在响应头部中添加 Content-Length: 0 字段，表示响应体为空。
    contentLengthAlreadySent := tw.shouldSendContentLength()
    if r1.ContentLength == 0 && !chunked(r1.TransferEncoding) && !contentLengthAlreadySent && bodyAllowedForStatus(r.StatusCode) {
        if _, err := io.WriteString(w, "Content-Length: 0\r\n"); err != nil {
            return err
        }
    }

    //写入响应空行
    if _, err := io.WriteString(w, "\r\n"); err != nil {
        return err
    }
    //写入响应体
    err = tw.writeBody(w)
    if err != nil {
        return err
    }
    return nil
}