Bagaimana untuk melaksanakan rangka kerja Pelayan Go Http dengan cepat? Selesai dalam satu artikel

Artikel ini akan memperkenalkan anda kepada pengetahuan yang berkaitan tentang Golang dan bercakap tentang cara melaksanakan rangka kerja Pelayan Go Http dengan cepat, saya harap ia akan membantu anda.

Jika anda ingin menggunakan pelayan http dalam Go, cara paling mudah ialah menggunakan http/net

err := http.ListenAndServe(":8080", nil)if err != nil {
    panic(err.Error())}http.HandleFunc("/hello", func(writer http.ResponseWriter, request *http.Request) {
    writer.Write([]byte("Hello"))})

untuk mentakrifkan fungsi pemegang [Cadangan berkaitan: Tutorial video Go]

type HandlerFunc func(ResponseWriter, *Request)

Pelaksanaan pelayan http perpustakaan standard adalah sangat mudah Buka port dan daftarkan pengendali yang melaksanakan HandlerFunc

Pada masa yang sama. masa, perpustakaan standard juga menyediakan permintaan pengambilalihan yang lengkap Kaedah

func main() {
    err := http.ListenAndServe(":8080", &Engine{})
    if err != nil {
        panic(err.Error())
    }}type Engine struct {}func (e *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/hello" {
        w.Write([]byte("Hello"))
    }}

mentakrifkan ServerHTTP

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)}

Jika kita perlu menulis rangka kerja Pelayan HTTP, maka kita perlu melaksanakan kaedah ini , dan aliran input dan output net/http tidak begitu mudah, kami juga memerlukan pembungkusan, ditambah dengan Laluan yang mudah, jangan tulis Path dalam ServeHTTP.

Berikut ialah ringkasan ringkas

• Enjin yang melaksanakan ServeHTTP

• Konteks yang membungkus aliran input dan output asal HTTP

• Laluan yang melaksanakan padanan laluan

Laluan Untuk kesederhanaan, Peta digunakan untuk pemadanan lengkap

import (
    "net/http")type Engine struct {
    addr  string
    route map[string]handFunc}type Context struct {
    w      http.ResponseWriter
    r      *http.Request
    handle handFunc}type handFunc func(ctx *Context) errorfunc NewServer(addr string) *Engine {
    return &Engine{
        addr:  addr,
        route: make(map[string]handFunc),
    }}func (e *Engine) Run() {
    err := http.ListenAndServe(e.addr, e)
    if err != nil {
        panic(err)
    }}func (e *Engine) Get(path string, handle handFunc) {
    e.route[path] = handle}func (e *Engine) handle(writer http.ResponseWriter, request *http.Request, handle handFunc) {
    ctx := &Context{
        w:      writer,
        r:      request,
        handle: handle,
    }
    ctx.Next()}func (e *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    handleF := e.route[req.URL.Path]
    e.handle(w, req, handleF)}func (c *Context) Next() error {
    return c.handle(c)}func (c *Context) Write(s string) error {
    _, err := c.w.Write([]byte(s))
    return err}

Kami tulis Ujian untuk mengesahkan Pelayan Http kami

func TestHttp(t *testing.T) {
    app := NewServer(":8080")

    app.Get("/hello", func(ctx *Context) error {
        return ctx.Write("Hello")
    })

    app.Run()}

Pengendalian yang kami pakejkan di sini menggunakan mod ralat Pulangan Berbanding dengan perpustakaan standard, yang hanya menulis tetapi tidak kembali, ia mengelakkan ralat yang disebabkan oleh terlupa untuk kembali selepas tidak menulis ini selalunya sukar dikesan.

Pelayan Http juga memerlukan fungsi middleware Idea di sini adalah untuk menyimpan tatasusunan handleFunc dalam Enjin, yang menyokong pendaftaran luaran, buat Ctx baharu dan tambahkan HandleFunc global Enjin. Salin ke Ctx, dan kemudian gunakan c.Next() untuk melaksanakan panggilan gaya matryoshka.

package httpimport (
    "net/http")type Engine struct {
    addr        string
    route       map[string]handFunc
    middlewares []handFunc}type Context struct {
    w        http.ResponseWriter
    r        *http.Request
    index    int
    handlers []handFunc}type handFunc func(ctx *Context) errorfunc NewServer(addr string) *Engine {
    return &Engine{
        addr:        addr,
        route:       make(map[string]handFunc),
        middlewares: make([]handFunc, 0),
    }}func (e *Engine) Run() {
    err := http.ListenAndServe(e.addr, e)
    if err != nil {
        panic(err)
    }}func (e *Engine) Use(middleware handFunc) {
    e.middlewares = append(e.middlewares, middleware)}func (e *Engine) Get(path string, handle handFunc) {
    e.route[path] = handle}func (e *Engine) handle(writer http.ResponseWriter, request *http.Request, handle handFunc) {
    handlers := make([]handFunc, 0, len(e.middlewares)+1)
    handlers = append(handlers, e.middlewares...)
    handlers = append(handlers, handle)
    ctx := &Context{
        w:        writer,
        r:        request,
        index:    -1,
        handlers: handlers,
    }
    ctx.Next()}func (e *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    handleF := e.route[req.URL.Path]
    e.handle(w, req, handleF)}func (c *Context) Next() error {
    c.index++
    if c.index <p>Kaedah pelaksanaannya sangat mudah Di sini kami mengesahkan sama ada ia boleh menyokong pra dan pasca perantara </p><pre class="brush:php;toolbar:false">func TestHttp(t *testing.T) {
    app := NewServer(":8080")

    app.Get("/hello", func(ctx *Context) error {
        fmt.Println("Hello")
        return ctx.Write("Hello")
    })
    app.Use(func(ctx *Context) error {
        fmt.Println("A1")
        return ctx.Next()
    })
    app.Use(func(ctx *Context) error {
        err := ctx.Next()
        fmt.Println("B1")
        return err    })

    app.Run()}

Output:

=== RUN   TestHttp
A1
Hello
B1

Tidak. lagi Dengan 100 baris kod, kami telah melaksanakan Pelayan Http yang mudah Untuk butiran seterusnya, anda boleh melihat kod sumber Gin Fokus utama adalah pada Laluan dan pelaksanaan pepohon awalan.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan rangka kerja Pelayan Go Http dengan cepat? Selesai dalam satu artikel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!