我是 PHP 程序员

请求行
请求头
请求空行
请求体

Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Content-Length: 11

type Request struct {
    Method           string                        //HTTP请求方法，如GET、POST等
    URL              *url.URL                      //HTTP请求的URL地址，是一个指向url.URL类型的指针。
    Proto            string                        //HTTP协议版本，如"HTTP/1.0"或者"HTTP/1.1"
    ProtoMajor       int                           //HTTP协议的主版本号，整数类型。如1
    ProtoMinor       int                           //HTTP协议的次版本号，整数类型。如0
    Header           Header                        //HTTP请求头信息，是一个http.Header类型的映射，用于存储HTTP请求头。
    Body             io.ReadCloser                 //HTTP请求体，是一个io.ReadCloser类型的接口，表示一个可读可关闭的数据流。
    GetBody          func() (io.ReadCloser, error) //HTTP请求体获取函数
    ContentLength    int64                         //HTTP请求体的长度，整数类型。
    TransferEncoding []string                      //HTTP传输编码，如"chunked"等。
    Close            bool                          //表示在请求结束后是否关闭连接。
    Host             string                        //HTTP请求的主机名或IP地址，字符串类型。
    Form             url.Values                    //HTTP请求的表单数据，是一个url.Values类型的映射，用于存储表单字段和对应的值。
    PostForm         url.Values                    //HTTP POST请求的表单数据，同样是一个url.Values类型的映射。
    MultipartForm    *multipart.Form               //HTTP请求的multipart表单数据，是一个multipart.Form类型的结构体。
    Trailer          Header                        //HTTP Trailer头信息，是一个http.Header类型的映射，用于存储Trailer头部字段和对应的值。
    RemoteAddr       string                        //请求客户端的地址。
    RequestURI       string                        //请求的URI，包括查询字符串。
    TLS              *tls.ConnectionState          //如果请求是使用TLS加密的，则该字段存储TLS连接的状态信息。
    Cancel           <-chan struct{}               //一个只读通道，用于在请求被取消时发送信号。
    Response         *Response                     //一个指向http.Response类型的指针，表示HTTP响应信息。
    ctx              context.Context               //一个context.Context类型的上下文，用于控制请求的超时和取消。
}

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

func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
    //如果method未设置值，则默认使用GET方法
    if method == "" {
        method = "GET"
    }
    //校验方法有效性，此处不具体校验方法类型，指检验方法名称字符的是否来自TokenTable（数字/字母/某些特殊符号）中的内容
    if !validMethod(method) {
        return nil, fmt.Errorf("net/http: invalid method %q", method)
    }
    // ctx必须要传递，NewRequest方法调用时会传递context.Background()
    if ctx == nil {
        return nil, errors.New("net/http: nil Context")
    }

    // 解析URL，解析Scheme、Host、Path等信息
    u, err := urlpkg.Parse(url)
    if err != nil {
        return nil, err
    }
    // 将body类型包装成io.ReadCloser类型
    rc, ok := body.(io.ReadCloser)
    if !ok && body != nil {
        rc = io.NopCloser(body)
    }
    u.Host = removeEmptyPort(u.Host)
    //根据解析的内容创建Request对象
    req := &Request{
        ctx:        ctx,
        Method:     method,
        URL:        u,
        Proto:      "HTTP/1.1",
        ProtoMajor: 1,
        ProtoMinor: 1,
        Header:     make(Header),
        Body:       rc,
        Host:       u.Host,
    }
    //如果body不为空，则进入语句
    if body != nil {
        // 断言body的类型
        switch v := body.(type) {
        case *bytes.Buffer:
            req.ContentLength = int64(v.Len())
            buf := v.Bytes()
            req.GetBody = func() (io.ReadCloser, error) {
                r := bytes.NewReader(buf)
                return io.NopCloser(r), nil
            }
        case *bytes.Reader:
            req.ContentLength = int64(v.Len())
            snapshot := *v
            req.GetBody = func() (io.ReadCloser, error) {
                r := snapshot
                return io.NopCloser(&r), nil
            }
        case *strings.Reader:
            req.ContentLength = int64(v.Len())
            snapshot := *v
            req.GetBody = func() (io.ReadCloser, error) {
                r := snapshot
                return io.NopCloser(&r), nil
            }
        default:
            // body的类型断言失败，不处理
        }
        // 对于body如果不等于nil，但是content-length又是0，则对req.Body和req.GetBody进行重新赋值。
        if req.GetBody != nil && req.ContentLength == 0 {
            req.Body = NoBody
            req.GetBody = func() (io.ReadCloser, error) { return NoBody, nil }
        }
    }
    return req, nil
}

func ReadRequest(b *bufio.Reader) (*Request, error) {
    return readRequest(b, deleteHostHeader)
}

func readRequest(b *bufio.Reader, deleteHostHeader bool) (req *Request, err error) {
    //使用textproto.Reader包装TCP连接读取HTTP请求
    tp := newTextprotoReader(b)
    //创建Request对象
    req = new(Request)

    //逐行读取HTTP请求信息并转为字符串
    var s string
    if s, err = tp.ReadLine(); err != nil {
        return nil, err
    }

    defer func() {
        //使用sync.pool来保存textproto.Reader变量
        putTextprotoReader(tp)
        if err == io.EOF {
            err = io.ErrUnexpectedEOF
        }
    }()

    var ok bool
    //解析HTTP请求的Method RequestURI RequestURI信息
    req.Method, req.RequestURI, req.Proto, ok = parseRequestLine(s)

    //解析失败则返回错误
    if !ok {
        return nil, badStringError("malformed HTTP request", s)
    }
    //校验HTTP请求方法
    if !validMethod(req.Method) {
        return nil, badStringError("invalid method", req.Method)
    }

    //校验HTTP协议版本号
    rawurl := req.RequestURI
    if req.ProtoMajor, req.ProtoMinor, ok = ParseHTTPVersion(req.Proto); !ok {
        return nil, badStringError("malformed HTTP version", req.Proto)
    }
    //检查一个HTTP请求是否为CONNECT方法，并且请求的URL不是以斜杠“/”开头，满足条件返回true，否则返回false
    justAuthority := req.Method == "CONNECT" && !strings.HasPrefix(rawurl, "/")
    if justAuthority {
        rawurl = "http://" + rawurl
    }

    //通过rawurl字符串解析URL值，并将其赋值给 req.URL
    if req.URL, err = url.ParseRequestURI(rawurl); err != nil {
        return nil, err
    }

    //如果 justAuthority 为真（即上一个问题中提到的条件满足），则将 req.URL.Scheme 设为一个空字符串，这样在后续处理中，只使用 req.URL.Host 来获取主机和端口号信息，而不会使用 URL 中的协议信息。
    //这是为了保持与 HTTP CONNECT 方法的语义一致，因为 CONNECT 方法中的 URL 只包含主机和端口号信息，没有协议部分。
    if justAuthority {
        req.URL.Scheme = ""
    }

    //从 tp 中读取 HTTP 请求的 MIME 头部，并将其解析为一个 map[string][]string 类型的对象 mimeHeader
    mimeHeader, err := tp.ReadMIMEHeader()

    //如果读取过程中出现错误，会返回一个错误对象
    if err != nil {
        return nil, err
    }

    //将 MIME 头部中的字段复制到请求的 Header 对象中
    req.Header = Header(mimeHeader)
    req.Host = req.URL.Host
    if req.Host == "" {
        req.Host = req.Header.get("Host")
    }

    //如果 deleteHostHeader 为真，即需要删除请求头部中的 Host 字段，那么会从 req.Header 中删除 Host 字段
    //这通常用于 HTTP 请求中的代理场景，因为代理服务器会在转发请求时修改 Host 字段。
    if deleteHostHeader {
        delete(req.Header, "Host")
    }
    //处理请求头部中的 Pragma 和 Cache-Control 字段，以满足 HTTP 协议的要求
    fixPragmaCacheControl(req.Header)

    //判断当前的请求是否应该关闭连接，并将结果设置为req.Close。
    //shouldClose() 函数会根据 HTTP 版本、请求头部和其他条件来判断是否需要关闭连接。
    req.Close = shouldClose(req.ProtoMajor, req.ProtoMinor, req.Header, false)

    // 读取请求中的数据（例如 POST 请求中的请求体），并将其存储在 req.Body 中。如果读取过程中出现错误，会返回一个错误对象。
    err = readTransfer(req, b)
    if err != nil {
        return nil, err
    }

    //如果请求头部中包含了 Upgrade 字段，且其值为 "h2c"，表示该请求需要升级到 HTTP/2 协议
    //那么会将 req.ContentLength 设为 -1，并将 req.Close 设为 true
    if req.isH2Upgrade() {
        req.ContentLength = -1
        req.Close = true
    }
    return req, nil
}

func (r *Request) write(w io.Writer, usingProxy bool, extraHeaders Header, waitForContinue func() bool) (err error) {...}

func (r *Request) write(w io.Writer, usingProxy bool, extraHeaders Header, waitForContinue func() bool) (err error) {
    closed := false
    defer func() {
        if closed {
            return
        }
        if closeErr := r.closeBody(); closeErr != nil && err == nil {
            err = closeErr
        }
    }()

    // cleanHost() 函数的作用是对主机名进行规范化处理，主要是去掉主机名中的端口号和空格等无关字符。
    // 调用 cleanHost() 函数，将 r.Host 中的主机名进行规范化处理。
    // 如果主机名为空，那么会从 r.URL.Host 中获取主机名。
    // 如果 r.URL 也为空，则会返回一个错误对象 errMissingHost。
    host := cleanHost(r.Host)
    if host == "" {
        if r.URL == nil {
            return errMissingHost
        }
        host = cleanHost(r.URL.Host)
    }

    //调用 removeZone() 函数，去掉主机名中的 IPv6 地址的 Zone Identifier 部分
    host = removeZone(host)
    //调用 r.URL.RequestURI() 函数获取请求的相对路径部分
    ruri := r.URL.RequestURI()
    //1. 如果使用了代理服务器且 URL 中包含了协议和主机名，则会将它们拼接到相对路径前面，形成完整的 URI
    //2. 如果是 CONNECT 方法且 URL 的路径为空，则 URI 只包含主机名。
    if usingProxy && r.URL.Scheme != "" && r.URL.Opaque == "" {
        ruri = r.URL.Scheme + "://" + host + ruri
    } else if r.Method == "CONNECT" && r.URL.Path == "" {
        ruri = host
        if r.URL.Opaque != "" {
            ruri = r.URL.Opaque
        }
    }
    //如果 URI 中包含控制字符，则会返回一个错误对象。
    //控制字符是指 ASCII 字符集中，数值为 0 至 31 和 127 的字符。它们没有可见的图形符号，主要用于控制计算机的硬件设备和通讯协议。
    //在 HTTP 协议中，请求和响应中的头部和正文部分都只能包含 ASCII 字符集中的可见字符。如果包含了控制字符，则可能会导致解析错误或安全问题。
    if stringContainsCTLByte(ruri) {
        return errors.New("net/http: can't write control character in Request.URL")
    }

    //检查w是否实现了io.ByteWriter接口，如果没实现，则创建一个新的bufio.Writer
    //将它的输出流定向到传入的io.Writer，并将新创建的bufio.Writer赋值给变量bw
    var bw *bufio.Writer
    if _, ok := w.(io.ByteWriter); !ok {
        bw = bufio.NewWriter(w)
        w = bw
    }

    //向w写入请求行
    _, err = fmt.Fprintf(w, "%s %s HTTP/1.1\r\n", valueOrDefault(r.Method, "GET"), ruri)
    if err != nil {
        return err
    }

    //向w写入请求头的HOST信息
    _, err = fmt.Fprintf(w, "Host: %s\r\n", host)
    if err != nil {
        return err
    }

    //向w写入请求头的User-Agent信息
    userAgent := defaultUserAgent
    if r.Header.has("User-Agent") {
        userAgent = r.Header.Get("User-Agent")
    }
    if userAgent != "" {
        _, err = fmt.Fprintf(w, "User-Agent: %s\r\n", userAgent)
        if err != nil