如何從頭開始建立自己的golang框架？

如何從頭開始建立 Go 框架：初始化專案：建立一個 Go 模組並設定基本專案結構。建立必要的包：建立兩個包，分別用於處理請求和提供中間件。定義基本 Handler：定義一個包含 ServeHTTP 方法的 Handler 介面。建立 Middleware：定義一個包含 HandlerWrapper 方法的 Middleware 介面。創作具體的 Handler 和 Middleware：創造 HelloHandler 和 LoggingMiddleware。建立 HTTP 路由器：使用 Gorilla mux 路由器處理請求。主函數：建立路由器並註冊 HelloHandler。

從頭開始建立自己的 Go 框架

在本文中，我們將一步一步地引導你如何從頭開始建立自己的 Go 框架。掌握 Go 框架的基礎知識至關重要，這樣你才能根據自己的特定要求自訂框架。

1. 初始化專案

首先，建立一個 Go 模組並初始化一個基本專案結構。

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

2. 建立必要的套件

對於一個基本的框架，讓我們建立兩個套件：一個用於處理請求的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:8080，你應該會看到"Hello, world!"。

恭喜你！你現在已經創建了自己的基本的 Go 框架。你可以透過增加更多的 Handler、Middleware 和自訂功能來進一步擴展它。

以上是如何從頭開始建立自己的golang框架？的詳細內容。更多資訊請關注PHP中文網其他相關文章！