如何从头开始构建 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 "<a style='color:#f60; text-decoration:underline;' href="https://www.php.cn/zt/15841.html" target="_blank">git</a>hub.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 和自定义功能来进一步扩展它。