Bagaimana untuk membina rangka kerja golang anda sendiri dari awal?

Cara membina rangka kerja Go dari awal: Mulakan projek: Cipta modul Go dan sediakan struktur projek asas. Cipta pakej yang diperlukan: Cipta dua pakej untuk mengendalikan permintaan dan menyediakan perisian tengah. Tentukan Pengendali asas: Tentukan antara muka Pengendali yang mengandungi kaedah ServeHTTP. Cipta Middleware: Tentukan antara muka Middleware yang mengandungi kaedah HandlerWrapper. Cipta Pengendali dan Middleware tertentu: Cipta HelloHandler dan LoggingMiddleware. Buat penghala HTTP: Gunakan penghala Gorilla mux untuk mengendalikan permintaan. Fungsi utama: Buat penghala dan daftar HelloHandler.

Bina rangka kerja Go anda sendiri dari awal

Dalam artikel ini, kami akan membimbing anda langkah demi langkah tentang cara membina rangka kerja Go anda sendiri dari awal. Adalah penting untuk menguasai asas rangka kerja Go supaya anda boleh menyesuaikan rangka kerja mengikut keperluan khusus anda.

1 Mulakan projek

Pertama, buat modul Go dan mulakan struktur projek asas.

mkdir my-framework
cd my-framework
go mod init my-framework

2 Cipta pakej yang diperlukan

Untuk rangka kerja asas, mari buat dua pakej: pakej pengendali untuk mengendalikan permintaan dan satu lagi pakej untuk menyediakan middleware >middleware. pakej. handler 包，另一个用于提供中间件的 middleware 包。

mkdir -p handler middleware

3. 定义基本 Handler

在 handler/handler.go 中，定义一个 Handler 接口，其中包含一个 ServeHTTP 方法。

package handler

import (
    "net/http"
)

// Handler defines an interface for handling HTTP requests.
type Handler interface {
    ServeHTTP(w http.ResponseWriter, r *http.Request)
}

4. 创建 Middleware

在 middleware/middleware.go 中，定义一个 Middleware 接口，其中包含一个 HandlerWrapper 方法。中间件将 Handler 包装成一个新的 Handler。

package middleware

import "github.com/my-framework/handler"

// Middleware defines an interface for wrapping request handlers.
type Middleware interface {
    HandlerWrapper(handler handler.Handler) handler.Handler
}

5. 创建具体的 Handler 和 Middleware

现在，让我们创建一个简单的 HelloHandler 和一个 LoggingMiddleware。

handler/hello.go:

package handler

import (
    "net/http"
)

// HelloHandler implements the Handler interface.
type HelloHandler struct{}

// ServeHTTP writes "Hello, world!" to the response.
func (h HelloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, world!"))
}

middleware/logging.go:

package middleware

import (
    "github.com/my-framework/handler"
    "log"
    "time"
)

// LoggingMiddleware logs the request method and URI.
type LoggingMiddleware struct{}

// HandlerWrapper returns a new Handler that logs requests.
func (m LoggingMiddleware) HandlerWrapper(handler handler.Handler) handler.Handler {
    return handler.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.RequestURI)
        handler.ServeHTTP(w, r)
    })
}

6. 创建 HTTP 路由器

现在，让我们创建一个简单的 HTTP 路由器来处理请求。

router/router.go:

package router

import (
    "github.com/gorilla/mux"
    "github.com/my-framework/handler"
    "github.com/my-framework/middleware"
)

// Router handles HTTP requests using a Gorilla mux router.
type Router struct {
    mux *mux.Router
    middlewares []middleware.Middleware
}

// NewRouter initializes a new HTTP router.
func NewRouter() *Router {
    return &Router{
        mux:         mux.NewRouter(),
        middlewares: []middleware.Middleware{},
    }
}

// Use adds a middleware to the router.
func (r *Router) Use(m middleware.Middleware) {
    r.middlewares = append(r.middlewares, m)
}

// Handle registers a route with a handler.
func (r *Router) Handle(path string, handler handler.Handler) {
    r.mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
        for _, m := range r.middlewares {
            handler = m.HandlerWrapper(handler)
        }
        handler.ServeHTTP(w, r)
    })
}

// ServeHTTP serves HTTP requests.
func (r *Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    r.mux.ServeHTTP(w, r)
}

7. 主函数

最后，在 main.go 中，创建一个路由器并注册我们的 HelloHandler。

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/my-framework/middleware"
    "github.com/my-framework/handler"
    "github.com/my-framework/router"
)

func main() {
    r := router.NewRouter()
    r.Use(middleware.LoggingMiddleware{})
    r.Handle("/", handler.HelloHandler{})
    server := &http.Server{
        Addr:         ":8080",
        Handler:      r,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 5 * time.Second,
    }
    fmt.Println("Listening on port 8080")
    server.ListenAndServe()
}

运行框架

现在你可以运行你的框架：

go run main.go

访问 http://localhost:8080rrreee

3 Takrifkan Pengendali asas

Dalam handler/handler.go, tentukan antara muka Handler, yang mengandungi kaedah ServeHTTP. 🎜rrreee🎜4 Cipta Middleware🎜🎜Dalam middleware/middleware.go, tentukan antara muka Middleware, yang mengandungi kaedah HandlerWrapper. Middleware membungkus Pengendali menjadi Pengendali baharu. 🎜rrreee🎜5 Cipta Pengendali dan Middleware khusus🎜🎜Sekarang, mari kita buat HelloHandler dan LoggingMiddleware. 🎜🎜pengendali/hello.go:🎜rrreee🎜middleware/logging.go:🎜rrreee🎜6 Cipta Penghala HTTP🎜🎜Sekarang, mari buat Penghala HTTP yang mudah untuk mengendalikan permintaan itu. 🎜🎜router/router.go:🎜rrreee🎜7 Fungsi utama 🎜🎜Akhir sekali, dalam main.go, buat penghala dan daftarkan HelloHandler kami. 🎜rrreee🎜Jalankan rangka kerja🎜🎜Kini anda boleh menjalankan rangka kerja anda: 🎜rrreee🎜Lawati http://localhost:8080 dan anda seharusnya melihat "Hello, world!". 🎜🎜Tahniah! Anda kini telah mencipta rangka kerja asas Go anda sendiri. Anda boleh melanjutkannya lagi dengan menambahkan lebih banyak Pengendali, Middleware dan fungsi tersuai. 🎜

Atas ialah kandungan terperinci Bagaimana untuk membina rangka kerja golang anda sendiri dari awal?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!