Comment créer votre propre framework Golang à partir de zéro ?

Comment créer un framework Go à partir de zéro : Initialiser le projet : Créez un module Go et configurez la structure de base du projet. Créez les packages nécessaires : créez deux packages pour gérer les demandes et fournir un middleware. Définir un gestionnaire de base : définissez une interface de gestionnaire contenant la méthode ServeHTTP. Créer un middleware : définissez une interface Middleware contenant la méthode HandlerWrapper. Créez des gestionnaires et des middlewares spécifiques : créez HelloHandler et LoggingMiddleware. Créez un routeur HTTP : utilisez le routeur Gorilla mux pour gérer les requêtes. Fonction principale : Créer un routeur et enregistrer HelloHandler.

Créez votre propre framework Go à partir de zéro

Dans cet article, nous vous guiderons étape par étape sur la façon de créer votre propre framework Go à partir de zéro. Il est crucial de maîtriser les bases du framework Go afin de pouvoir personnaliser le framework en fonction de vos besoins spécifiques.

1. Initialisez le projet

Tout d'abord, créez un module Go et initialisez une structure de projet de base.

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

2. Créez les packages nécessaires

Pour un framework de base, créons deux packages : un package handler pour gérer les requêtes et un autre package pour fournir un middleware >middleware. emballer. 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. Définissez Handler de base

Dans handler/handler.go, définissez une interface Handler, qui contient une méthode ServeHTTP. 🎜rrreee🎜4. Créer un middleware🎜🎜Dans middleware/middleware.go, définissez une interface Middleware, qui contient une méthode HandlerWrapper. Le middleware enveloppe le gestionnaire dans un nouveau gestionnaire. 🎜rrreee🎜5. Créez des gestionnaires et un middleware spécifiques🎜🎜Maintenant, créons un simple HelloHandler et un LoggingMiddleware. 🎜🎜handler/hello.go :🎜rrreee🎜middleware/logging.go :🎜rrreee🎜6 Créer un routeur HTTP🎜🎜Maintenant, créons un routeur HTTP simple pour traiter la demande. 🎜🎜router/router.go :🎜rrreee🎜7. Fonction principale 🎜🎜Enfin, dans main.go, créez un routeur et enregistrez notre HelloHandler. 🎜rrreee🎜Exécutez le framework🎜🎜Vous pouvez maintenant exécuter votre framework : 🎜rrreee🎜Visitez http://localhost:8080 et vous devriez voir "Bonjour tout le monde !". 🎜🎜Félicitations ! Vous avez maintenant créé votre propre framework Go de base. Vous pouvez l'étendre davantage en ajoutant davantage de gestionnaires, de middleware et de fonctionnalités personnalisées. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!