Heim >Backend-Entwicklung >Golang >Wie baue ich mein eigenes Golang-Framework von Grund auf auf?

Wie baue ich mein eigenes Golang-Framework von Grund auf auf?

WBOY
WBOYOriginal
2024-06-05 15:21:01725Durchsuche

So erstellen Sie ein Go-Framework von Grund auf: Initialisieren Sie das Projekt: Erstellen Sie ein Go-Modul und richten Sie die grundlegende Projektstruktur ein. Erstellen Sie die erforderlichen Pakete: Erstellen Sie zwei Pakete, um Anfragen zu verarbeiten und Middleware bereitzustellen. Definieren Sie einen grundlegenden Handler: Definieren Sie eine Handler-Schnittstelle, die die ServeHTTP-Methode enthält. Middleware erstellen: Definieren Sie eine Middleware-Schnittstelle, die die HandlerWrapper-Methode enthält. Erstellen Sie spezifische Handler und Middleware: Erstellen Sie HelloHandler und LoggingMiddleware. Erstellen Sie einen HTTP-Router: Verwenden Sie den Gorilla-Mux-Router, um Anfragen zu verarbeiten. Hauptfunktion: Erstellen Sie einen Router und registrieren Sie HelloHandler.

Wie baue ich mein eigenes Golang-Framework von Grund auf auf?

Erstellen Sie Ihr eigenes Go-Framework von Grund auf

In diesem Artikel führen wir Sie Schritt für Schritt durch die Erstellung Ihres eigenen Go-Frameworks von Grund auf. Es ist wichtig, die Grundlagen des Go-Frameworks zu beherrschen, damit Sie das Framework an Ihre spezifischen Anforderungen anpassen können.

1. Initialisieren Sie das Projekt

Erstellen Sie zunächst ein Go-Modul und initialisieren Sie eine grundlegende Projektstruktur.

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

2. Erstellen Sie die erforderlichen Pakete

Als Grundgerüst erstellen wir zwei Pakete: ein handler-Paket für die Bearbeitung von Anfragen und ein weiteres -Paket für die Bereitstellung von Middleware Paket. <code>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. Definieren Sie den Basis-Handler

Definieren Sie in handler/handler.go eine Handler-Schnittstelle, die eine ServeHTTP-Methode enthält. 🎜rrreee🎜4. Middleware erstellen🎜🎜Definieren Sie in middleware/middleware.go eine Middleware-Schnittstelle, die eine HandlerWrapper-Methode enthält. Middleware verpackt den Handler in einen neuen Handler. 🎜rrreee🎜5. Erstellen Sie spezifische Handler und Middleware🎜🎜Lassen Sie uns nun einen einfachen HelloHandler und eine LoggingMiddleware erstellen. 🎜🎜handler/hello.go:🎜rrreee🎜middleware/logging.go:🎜rrreee🎜6. Erstellen Sie einen HTTP-Router🎜🎜Jetzt erstellen wir einen einfachen HTTP-Router die Anfrage bearbeiten. 🎜🎜router/router.go:🎜rrreee🎜7. Hauptfunktion 🎜🎜Schließlich erstellen Sie in main.go einen Router und registrieren Sie unseren HelloHandler. 🎜rrreee🎜Führen Sie das Framework aus🎜🎜Jetzt können Sie Ihr Framework ausführen: 🎜rrreee🎜Besuchen Sie http://localhost:8080 und Sie sollten „Hello, world!“ sehen. 🎜🎜Herzlichen Glückwunsch! Sie haben jetzt Ihr eigenes grundlegendes Go-Framework erstellt. Sie können es weiter erweitern, indem Sie weitere Handler, Middleware und benutzerdefinierte Funktionen hinzufügen. 🎜

Das obige ist der detaillierte Inhalt vonWie baue ich mein eigenes Golang-Framework von Grund auf auf?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn