美文网首页
golang net/url包使用

golang net/url包使用

作者: 第八共同体 | 来源:发表于2019-05-22 17:34 被阅读0次

    1.net/url简介

    import "net/url"
    url包解析URL并实现查询转义

    • URL结构体
    // Note that the Path field is stored in decoded form: /%47%6f%2f becomes /Go/.
    // A consequence is that it is impossible to tell which slashes in the Path were
    // slashes in the raw URL and which were %2f. This distinction is rarely important,
    // but when it is, code must not use Path directly.
    // The Parse function sets both Path and RawPath in the URL it returns,
    // and URL's String method uses RawPath if it is a valid encoding of Path,
    // by calling the EscapedPath method.
    type URL struct {
        Scheme     string
        Opaque     string    // encoded opaque data
        User       *Userinfo // username and password information
        Host       string    // host or host:port
        Path       string    // path (relative paths may omit leading slash)
        RawPath    string    // encoded path hint (see EscapedPath method)
        ForceQuery bool      // append a query ('?') even if RawQuery is empty
        RawQuery   string    // encoded query values, without '?'
        Fragment   string    // fragment for references, without '#'
    }
    
    • func Parse(rawurl string) (*URL, error)
      将原生的rawurl字符串解析成URL结构体
    package main
    
    import (
        "fmt"
        "log"
        "net/url"
    )
    
    func main() {
        u, err := url.Parse("http://www.baidu.com/search?q=dotnet")
        if err != nil {
            log.Fatal(err)
        }
        u.Scheme = "https"
        u.Host = "google.com"
        q := u.Query()
        q.Set("q", "golang")
        u.RawQuery = q.Encode()
        fmt.Println(u)
    }
    
    • Values 类型为map字典
      通常用于查询参数,和表单值
    // Values maps a string key to a list of values.
    // It is typically used for query parameters and form values.
    // Unlike in the http.Header map, the keys in a Values map
    // are case-sensitive.
    type Values map[string][]string
    
    • func (u *URL) Query() Values返回的类型为Values
    // Query parses RawQuery and returns the corresponding values.
    // It silently discards malformed value pairs.
    // To check errors use ParseQuery.
    func (u *URL) Query() Values {
        v, _ := ParseQuery(u.RawQuery)
        return v
    }
    
    package main
    
    import (
            "fmt"
            "log"
            "net/url"
    )
    
    func main() {
            u, err := url.Parse("https://example.org?q=golang&limit=10&offset=2")
            if err != nil {
                    log.Fatal(err)
            }
            q := u.Query()
            fmt.Println(q["q"])   // [golang]
            fmt.Println(q.Get("limit"))  // 10
            fmt.Println(q.Get("offset"))  // 2 
    }
    
    
    • func (v Values) Encode() string
      将参数列表转化为字符串拼接形式q=golang&limit=10
    // Encode encodes the values into ``URL encoded'' form
    // ("bar=baz&foo=quux") sorted by key.
    func (v Values) Encode() string {
        if v == nil {
            return ""
        }
        var buf strings.Builder
        keys := make([]string, 0, len(v))
        for k := range v {
            keys = append(keys, k)
        }
        sort.Strings(keys)
        for _, k := range keys {
            vs := v[k]
            keyEscaped := QueryEscape(k)
            for _, v := range vs {
                if buf.Len() > 0 {
                    buf.WriteByte('&')
                }
                buf.WriteString(keyEscaped)
                buf.WriteByte('=')
                buf.WriteString(QueryEscape(v))
            }
        }
        return buf.String()
    }
    
    • func (u *URL) String() string
      String方法将URL重新组装成合法的string

    一个完整的例子

    func SendFromClientResp(method, uStr string, body io.Reader,
        headers, querys map[string]string) (io.Reader, error) {
        u, err := url.Parse(uStr)
        if err != nil {
            return nil, err
        }
        q := u.Query()
        for k, v := range querys {
            q.Set(k, v)
        }
        u.RawQuery = q.Encode()
        req, err := http.NewRequest(method, u.String(), body)
        if err != nil {
            return nil, err
        }
        for k, v := range headers {
            req.Header.Set(k, v)
        }
        var resp *http.Response
        for i := 0; i < reTryTimes; i++ {
            resp, err = http.DefaultClient.Do(req)
            if err == nil {
                break
            }
        }
        if err != nil {
            return nil, err
        }
        defer resp.Body.Close()
        buff := bytes.NewBuffer(nil)
        io.Copy(buff, resp.Body)
        dr := decode2UTF8(httpRespCharset(resp), buff)
        buff.Reset()
        io.Copy(buff, dr)
        return buff, nil
    }
    

    相关文章

      网友评论

          本文标题:golang net/url包使用

          本文链接:https://www.haomeiwen.com/subject/npklzqtx.html