HttpRouter

Alamat Repositori: julienschmidt/httprouter: A high performance HTTP request router that scales well (github.com)

Router yang digunakan oleh Gin adalah HttpRouter yang juga merupakan komponen routing ringan dan berkinerja tinggi seluruh komponen hanya memiliki tiga file .go kode sangat ringkas fitur utamanya adalah sebagai berikut.

Pencocokan Satu-ke-Satu: Satu request hanya dapat mencocokkan nol atau satu route dan menguntungkan optimasi SEO.

Koreksi Path Otomatis: Bebas memilih gaya URL yang disukai bahkan jika ada satu slash yang berlebih atau kurang akan dilakukan redirect otomatis. Jika ada kesalahan huruf besar kecil akan mengabaikan huruf besar kecil saat pencarian dan melakukan redirect yang benar.

Parsing Parameter Route Otomatis: Cukup berikan nama ke path segment router akan meneruskan nilai dinamis kepada Anda. Karena desain router overhead parsing parameter path sangat rendah.

Zero Garbage: Dalam proses routing dan penjadwalan tidak akan menghasilkan memory garbage apa pun.

Dukungan RestfulAPI: Desain router mendorong Restful API berlapis yang wajar.

Penanganan Error: Dapat mengatur error handler untuk menangani anomali dalam request router akan menangkap dan mencatatnya kemudian redirect ke halaman error.

Penggunaan Dasar

Sama seperti springboot satu fungsi terikat ke satu URL dan sesuai dengan satu handler.

package main

import (
   "fmt"
   "github.com/julienschmidt/httprouter"
   "log"
   "net/http"
)

func Hello(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
   fmt.Fprintf(w, "<h1>Hello World!")
}

func main() {
   router := httprouter.New()
   router.GET("/hello", Hello)
   log.Fatal(http.ListenAndServe(":8080", router))
}

Kemudian menggunakan browser atau alat uji interface apa pun masukkan 127.0.0.1:8080 akan melihat konten yang benar kita dapat melihat HttpRouter hanya melakukan routing sebenarnya masih menggunakan komponen default net/http gin juga demikian hanya encapsulation-nya relatif lebih dalam.

Parameter Named

package main

import (
   "fmt"
   "github.com/julienschmidt/httprouter"
   "log"
   "net/http"
)

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
   fmt.Fprintf(w, "<h1>Hello World!")
}

func main() {
   router := httprouter.New()
   router.GET("/hello:name", Hello)
   log.Fatal(http.ListenAndServe(":8080", router))
}

Kali ini di belakang route ditambahkan :name name adalah parameter named dapat mengakses slice parameter melalui httprouter.Params dapat mendapatkan parameter melalui index atau ByName(name). Demikian pula dapat menggunakan http.Handler dan http.HandlerFunc sebagai httprouter.Handle route sendiri mengimplementasikan interface-nya misalnya contoh berikut.

func Hello(w http.ResponseWriter, r *http.Request) {
    params := httprouter.ParamsFromContext(r.Context())
    //params := r.Context().Value(httprouter.ParamsKey) juga bisa

    fmt.Fprintf(w, "hello, %s!\n", params.ByName("name"))
}

Ketika route yang diikat method adalah /user/:user beberapa situasi pencocokan URL berikut

 /user/gordon              match
 /user/you                 match
 /user/gordon/profile      no match
 /user/                    no match

Tidak dapat mendaftarkan /user/new dan /user/:user ke method request yang sama setiap method request harus saling independen.

Menangkap Semua Parameter

Tipe kedua adalah menangkap semua parameter sesuai namanya mereka mencocokkan segalanya oleh karena itu harus berada di akhir Pattern.

Pattern: /src/*filepath

 /src/                     match
 /src/somefile.go          match
 /src/subdir/somefile.go   match

Prinsip kerja HttpRouter adalah membangun sejumlah besar prefix tree yang tertarik dapat memahami: httprouter package - github.com/julienschmidt/httprouter - Go Packages.

OPTIONS & CORS

Beberapa orang mungkin ingin memodifikasi respons otomatis untuk OPTIONS dan mengatur beberapa response header untuk mengadaptasi preflight request CORS kebutuhan ini dapat diimplementasikan melalui handler Router.GlobalOPTIONS.

router.GlobalOPTIONS = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    if r.Header.Get("Access-Control-Request-Method") != "" {
        // Mengatur response header CORS
        header := w.Header()
        header.Set("Access-Control-Allow-Methods", r.Header.Get("Allow"))
        header.Set("Access-Control-Allow-Origin", "*")
    }

    // Menyesuaikan status code 204
    w.WriteHeader(http.StatusNoContent)
})

Handler NOT FOUND

TIP

Mungkin perlu menonaktifkan Router.HandleMethodNotAllowed untuk menghindari beberapa masalah.

router.NotFound = http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
  //logika Anda
})

Validasi Dasar

package main

import (
  "fmt"
  "log"
  "net/http"

  "github.com/julienschmidt/httprouter"
)

func BasicAuth(h httprouter.Handle, requiredUser, requiredPassword string) httprouter.Handle {
  return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    //Mendapatkan kredensial autentikasi dasar
    user, password, hasAuth := r.BasicAuth()

    if hasAuth && user == requiredUser && password == requiredPassword {
      // Mendelegasikan request ke handler yang diberikan
      h(w, r, ps)
    } else {
      // Jika tidak request autentikasi
      w.Header().Set("WWW-Authenticate", "Basic realm=Restricted")
      http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
    }
  }
}

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
  fmt.Fprint(w, "Not protected!\n")
}

func Protected(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
  fmt.Fprint(w, "Protected!\n")
}

func main() {
  user := "gordon"
  pass := "secret!"

  router := httprouter.New()
  router.GET("/", Index)
  router.GET("/protected/", BasicAuth(Protected, user, pass))

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