Go url parameters mapping

妖精的绣舞 提交于 2021-02-02 10:59:51

问题


Is there a native way for inplace url parameters in native Go?

For Example, if I have a URL: http://localhost:8080/blob/123/test I want to use this URL as /blob/{id}/test.

This is not a question about finding go libraries. I am starting with the basic question, does go itself provide a basic facility to do this natively.


回答1:


There is no built in simple way to do this, however, it is not hard to do.

This is how I do it, without adding a particular library. It is placed in a function so that you can invoke a simple getCode() function within your request handler.

Basically you just split the r.URL.Path into parts, and then analyse the parts.

// Extract a code from a URL. Return the default code if code
// is missing or code is not a valid number.
func getCode(r *http.Request, defaultCode int) (int, string) {
        p := strings.Split(r.URL.Path, "/")
        if len(p) == 1 {
                return defaultCode, p[0]
        } else if len(p) > 1 {
                code, err := strconv.Atoi(p[0])
                if err == nil {
                        return code, p[1]
                } else {
                        return defaultCode, p[1]
                }
        } else {
                return defaultCode, ""
        }
}



回答2:


Well, without external libraries you can't, but may I recommend two excellent ones:

  1. httprouter - https://github.com/julienschmidt/httprouter - is extremely fast and very lightweight. It's faster than the standard library's router, and it creates 0 allocations per call, which is great in a GCed language.

  2. Gorilla Mux - http://www.gorillatoolkit.org/pkg/mux - Very popular, nice interface, nice community.

Example usage of httprouter:

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
}

func main() {
    router := httprouter.New()
    router.GET("/hello/:name", Hello)

    log.Fatal(http.ListenAndServe(":8080", router))
}



回答3:


How about writing your own url generator (extend net/url a little bit) as below.

// --- This is how does it work like --- //
url, _ := rest.NewURLGen("http", "stack.over.flow", "1234").
    Pattern(foo/:foo_id/bar/:bar_id).
    ParamQuery("foo_id", "abc").
    ParamQuery("bar_id", "xyz").
    ParamQuery("page", "1").
    ParamQuery("offset", "5").
    Do()

log.Printf("url: %s", url) 
// url: http://stack.over.flow:1234/foo/abc/bar/xyz?page=1&offset=5

// --- Your own url generator would be like below --- //
package rest

import (
    "log"
    "net/url"
    "strings"

    "straas.io/base/errors"

    "github.com/jinzhu/copier"
)

// URLGen generates request URL
type URLGen struct {
    url.URL

    pattern    string
    paramPath  map[string]string
    paramQuery map[string]string
}

// NewURLGen new a URLGen
func NewURLGen(scheme, host, port string) *URLGen {
    h := host
    if port != "" {
        h += ":" + port
    }

    ug := URLGen{}
    ug.Scheme = scheme
    ug.Host = h
    ug.paramPath = make(map[string]string)
    ug.paramQuery = make(map[string]string)

    return &ug
}

// Clone return copied self
func (u *URLGen) Clone() *URLGen {
    cloned := &URLGen{}
    cloned.paramPath = make(map[string]string)
    cloned.paramQuery = make(map[string]string)

    err := copier.Copy(cloned, u)
    if err != nil {
        log.Panic(err)
    }

    return cloned
}

// Pattern sets path pattern with placeholder (format `:<holder_name>`)
func (u *URLGen) Pattern(pattern string) *URLGen {
    u.pattern = pattern
    return u
}

// ParamPath builds path part of URL
func (u *URLGen) ParamPath(key, value string) *URLGen {
    u.paramPath[key] = value
    return u
}

// ParamQuery builds query part of URL
func (u *URLGen) ParamQuery(key, value string) *URLGen {
    u.paramQuery[key] = value
    return u
}

// Do returns final URL result.
// The result URL string is possible not escaped correctly.
// This is input for `gorequest`, `gorequest` will handle URL escape.
func (u *URLGen) Do() (string, error) {
    err := u.buildPath()
    if err != nil {
        return "", err
    }
    u.buildQuery()

    return u.String(), nil
}

func (u *URLGen) buildPath() error {
    r := []string{}
    p := strings.Split(u.pattern, "/")

    for i := range p {
        part := p[i]
        if strings.Contains(part, ":") {
            key := strings.TrimPrefix(p[i], ":")

            if val, ok := u.paramPath[key]; ok {
                r = append(r, val)
            } else {
                if i != len(p)-1 {
                    // if placeholder at the end of pattern, it could be not provided
                    return errors.Errorf("placeholder[%s] not provided", key)
                }
            }
            continue
        }
        r = append(r, part)
    }

    u.Path = strings.Join(r, "/")
    return nil
}

func (u *URLGen) buildQuery() {
    q := u.URL.Query()
    for k, v := range u.paramQuery {
        q.Set(k, v)
    }
    u.RawQuery = q.Encode()
}



回答4:


What about trying using regex, and find a named group in your url, like playground:

package main

import (
    "fmt"
    "net/url"
    "regexp"
)

var myExp = regexp.MustCompile(`/blob/(?P<id>\d+)/test`) // use (?P<id>[a-zA-Z]+) if the id is alphapatic

func main() {

    s := "http://localhost:8080/blob/123/test"

    u, err := url.Parse(s)
    if err != nil {
        panic(err)
    }

    fmt.Println(u.Path)

    match := myExp.FindStringSubmatch(s) // or match := myExp.FindStringSubmatch(u.Path)
    result := make(map[string]string)
    for i, name := range myExp.SubexpNames() {
        if i != 0 && name != "" {
            result[name] = match[i]
        }
    }
    fmt.Printf("id: %s\n", result["id"])

}

output

/blob/123/test
id: 123

Below full code to use it with url, that is receiving http://localhost:8000/hello/John/58 and returning http://localhost:8000/hello/John/58:

package main

import (
    "fmt"
    "net/http"
    "regexp"
    "strconv"
)

var helloExp = regexp.MustCompile(`/hello/(?P<name>[a-zA-Z]+)/(?P<age>\d+)`)

func hello(w http.ResponseWriter, req *http.Request) {
    match := helloExp.FindStringSubmatch(req.URL.Path)
    if len(match) > 0 {
        result := make(map[string]string)
        for i, name := range helloExp.SubexpNames() {
            if i != 0 && name != "" {
                result[name] = match[i]
            }
        }
        if _, err := strconv.Atoi(result["age"]); err == nil {
            fmt.Fprintf(w, "Hello, %v year old named %s!", result["age"], result["name"])
        } else {
            fmt.Fprintf(w, "Sorry, not accepted age!")
        }
    } else {
        fmt.Fprintf(w, "Wrong url\n")
    }
}

func main() {

    http.HandleFunc("/hello/", hello)

    http.ListenAndServe(":8090", nil)
}



回答5:


No way without standard library. Why you don't want to try some library? I think its not so hard to use it, just go get bla bla bla

I use Beego. Its MVC style.




回答6:


how about a simple utility function ?

func withURLParams(u url.URL, param, val string) url.URL{
    u.Path = strings.ReplaceAll(u.Path, param, val)
    return u
}

you can use it like this:

u, err := url.Parse("http://localhost:8080/blob/:id/test")
if err != nil {
    return nil, err
}
u := withURLParams(u, ":id","123")

// now u.String() is http://localhost:8080/blob/123/test



回答7:


If you need a framework and you think it will be slow because it's 'bigger' than a router or net/http, then you 're wrong.

Iris is the fastest go web framework that you will ever find, so far according to all benchmarks.

Install by

  go get gopkg.in/kataras/iris.v6

Django templates goes easy with iris:

import (
    "gopkg.in/kataras/iris.v6"
    "gopkg.in/kataras/iris.v6/adaptors/httprouter"
    "gopkg.in/kataras/iris.v6/adaptors/view" // <-----

)

func main() {

    app := iris.New()
    app.Adapt(iris.DevLogger())
    app.Adapt(httprouter.New()) // you can choose gorillamux too
    app.Adapt(view.Django("./templates", ".html")) // <-----

    // RESOURCE: http://127.0.0.1:8080/hi
    // METHOD: "GET"
    app.Get("/hi", hi)

    app.Listen(":8080")
}

func hi(ctx *iris.Context){
   ctx.Render("hi.html", iris.Map{"Name": "iris"})
}


来源:https://stackoverflow.com/questions/29211241/go-url-parameters-mapping

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!