96 lines
2.4 KiB
Go
96 lines
2.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"log/slog"
|
|
"net/http"
|
|
)
|
|
|
|
// Context is the context of the current HTTP request.
|
|
type Context struct {
|
|
Ctx context.Context
|
|
W http.ResponseWriter
|
|
R *http.Request
|
|
}
|
|
|
|
// JSON serializes the given data to JSON and writes it to the response.
|
|
func (c *Context) JSON(statusCode int, data interface{}) {
|
|
c.W.Header().Set("Content-Type", "application/json")
|
|
c.W.WriteHeader(statusCode)
|
|
if err := json.NewEncoder(c.W).Encode(data); err != nil {
|
|
http.Error(c.W, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
// HandlerFunc defines the handler used by the framework.
|
|
type HandlerFunc func(c *Context)
|
|
|
|
// Engine is the framework's instance, it contains the router and middleware.
|
|
type Engine struct {
|
|
router *RouterGroup
|
|
}
|
|
|
|
// RouterGroup is used internally to configure router, associated with a prefix and an array of handlers (middlewares).
|
|
type RouterGroup struct {
|
|
Handlers []HandlerFunc
|
|
engine *Engine
|
|
}
|
|
|
|
// New creates a new Engine instance.
|
|
func New() *Engine {
|
|
engine := &Engine{}
|
|
engine.router = &RouterGroup{engine: engine}
|
|
return engine
|
|
}
|
|
|
|
// ServeHTTP conforms to the http.Handler interface.
|
|
func (engine *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
ctx := context.Background()
|
|
engine.router.handleHTTPRequest(ctx, w, r)
|
|
}
|
|
|
|
// handleHTTPRequest handles the HTTP request.
|
|
func (group *RouterGroup) handleHTTPRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) {
|
|
c := &Context{Ctx: ctx, W: w, R: r}
|
|
for _, handler := range group.Handlers {
|
|
handler(c)
|
|
}
|
|
}
|
|
|
|
// Use adds middleware to the router group.
|
|
func (group *RouterGroup) Use(middleware ...HandlerFunc) {
|
|
group.Handlers = append(group.Handlers, middleware...)
|
|
}
|
|
|
|
// GET adds a GET route to the router group.
|
|
func (group *RouterGroup) GET(path string, handler HandlerFunc) {
|
|
// Implement route registration logic here
|
|
group.Handlers = append(group.Handlers, handler)
|
|
}
|
|
|
|
func main() {
|
|
engine := New()
|
|
|
|
engine.router.GET("/", sayHelloHandler)
|
|
engine.router.GET("/json", sayHelloJSONHandler)
|
|
|
|
slog.Info("Server is running at http://localhost:8080")
|
|
http.ListenAndServe(":8080", engine)
|
|
}
|
|
|
|
func sayHelloHandler(c *Context) {
|
|
slog.Info("called sayHelloHandler")
|
|
c.W.Write([]byte("Hello, World!"))
|
|
}
|
|
|
|
type Something struct {
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
func sayHelloJSONHandler(c *Context) {
|
|
slog.Info("called sayHelloJSONHandler")
|
|
something := Something{Name: "something"}
|
|
c.JSON(http.StatusOK, something)
|
|
}
|