简化路由处理程序以在没有框架的情况下处理参数

在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《简化路由处理程序以在没有框架的情况下处理参数》，聊聊，希望可以帮助到正在努力赚钱的你。

在 rocket.rs 中，我们有这个简单的路由代码：

#[get("/hello//")]
fn hello(name: &str, age: u8) -> string {
    format!("hello, {} year old named {}!", age, name)
}

如果您在浏览器中访问 http://localhost:8000/hello/john/58，您会看到： 你好，58岁，名叫约翰！

我读过这篇文章，但接受的答案是关于为单个路由执行 go url 参数映射 的方法，可以将 http://localhost:8080/blob/123/test 读取为 /blob/{id}/ test 并显示所需的路线。

我知道那里有一些很棒的路由器/框架，但希望自己构建简单的代码以更好地理解 http 路由处理程序。

假设我已经：

type Tender struct {
    tenderReference string
    venderCode      int
}

func (t Tender) readWrite() {
    fmt.Printf("Tender %s is ready for vendor %d to review and submit\n", t.tenderReference, t.venderCode)
}

func (t Tender) readOnly(w http.ResponseWriter, r *http.Request) {
    fmt.Printf("Tender %s already submitted by vender %d\n", t.tenderReference, t.venderCode)
}

并希望我的路线是这样的：

1. /api/tender/readwrite/{tenderreference}/vendor/{vendercode} 正在调用 func (t tender) readwrite(){}

2. /api/tender/readonly/{tenderreference}/vendor/{vendercode} 正在调用 func (t tender) readonly(){}

我必须构建多少个路由处理程序？

正确答案

我的解决方法如下，欢迎其他想法：

1. 404.go

package main

import (
    "fmt"
    "net/http"
)

func handle404(w http.responsewriter, r *http.request) {
    fmt.fprint(w, "mmm, it looks you are playing around, page is not available :)\n")
}

1. getfield.go

package main

import "net/http"

type ctxkey struct{}

func getfield(r *http.request, index int) string {
    fields := r.context().value(ctxkey{}).([]string)
    return fields[index]
}

1. rutes.go

package main

import (
    "net/http"
    "regexp"
)

type route struct {
    method  string
    regex   *regexp.regexp
    handler http.handlerfunc
}

var routes = []route{
    newroute("get", "/api/tender/(rw|r)/([^/]+)/vendor/([0-9]+)", apitenders),
}

func newroute(method, pattern string, handler http.handlerfunc) route {
    return route{method, regexp.mustcompile("^" + pattern + "$"), handler}
}

1. tendor.go

package main

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

type tender struct {
    tenderreference string
    vendercode      int
}

// handles get /api/tender/(rw|r)/([^/]+)/vendor/([0-9]+)
func apitenders(w http.responsewriter, r *http.request) {
    action := getfield(r, 0)
    tenderreference := getfield(r, 1)
    vendercode, _ := strconv.atoi(getfield(r, 2))
    tender := tender{tenderreference, vendercode}
    switch action {
    case "rw":
        tender.readwrite(w, r) // display tender and allow vendor to submit feedback
    case "r":
        tender.readonly(w, r) // display readonly copy of the tender
    default:
        fmt.fprintf(w, "tendert error\n")
    }
}

func (t tender) readwrite(w http.responsewriter, r *http.request) {
    fmt.fprintf(w, "tender %s is ready for vendor %d to review and submit\n", t.tenderreference, t.vendercode)
}

func (t tender) readonly(w http.responsewriter, r *http.request) {
    fmt.fprintf(w, "tender %s already submitted by vender %d\n", t.tenderreference, t.vendercode)
}

1. server.go

package main

import (
    "context"
    "fmt"
    "net/http"
    "strings"
)

type apiHandler struct{}

func main() {
    http.Handle("/api/", apiHandler{})
    http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
        // The "/" pattern matches everything, so we need to check
        // that we're at the root here.
        if req.URL.Path != "/" {
            http.NotFound(w, req)
            return
        }
        fmt.Fprintf(w, "Welcome to the home page!")
    })
    http.ListenAndServe(":8000", nil)
}

func (apiHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    var allow []string
    for _, route := range routes {
        matches := route.regex.FindStringSubmatch(r.URL.Path)
        if len(matches) > 0 {
            if r.Method != route.method {
                allow = append(allow, route.method)
                continue
            }
            ctx := context.WithValue(r.Context(), ctxKey{}, matches[1:])
            route.handler(w, r.WithContext(ctx))
            return
        }
    }
    if len(allow) > 0 {
        w.Header().Set("Allow", strings.Join(allow, ", "))
        http.Error(w, "405 method not allowed", http.StatusMethodNotAllowed)
        return
    }
    handle404(w, r)
    //http.NotFound(w, r)
}

本篇关于《简化路由处理程序以在没有框架的情况下处理参数》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！