Go HTTP handlers: стандартная библиотека vs Gin

1package main
2
3import (
4    "encoding/json"
5    "log"
6    "net/http"
7)
8
9type User struct {
10    ID   int    `json:"id"`
11    Name string `json:"name"`
12}
13
14func main() {
15    http.HandleFunc("/users", getUsers)
16    http.HandleFunc("/users/", getUser)
17
18    log.Println("Server starting on :8080")
19    log.Fatal(http.ListenAndServe(":8080", nil))
20}
21
22func getUsers(w http.ResponseWriter, r *http.Request) {
23    users := []User{
24        {ID: 1, Name: "Alice"},
25        {ID: 2, Name: "Bob"},
26    }
27
28    w.Header().Set("Content-Type", "application/json")
29    json.NewEncoder(w).Encode(users)
30}
31
32func getUser(w http.ResponseWriter, r *http.Request) {
33    // Парсинг URL параметров
34    id := r.URL.Path[len("/users/"):]
35
36    user := User{ID: 1, Name: "Alice"}
37    w.Header().Set("Content-Type", "application/json")
38    json.NewEncoder(w).Encode(user)
39}

1func loggingMiddleware(next http.Handler) http.Handler {
2    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
3        log.Printf("%s %s %s", r.RemoteAddr, r.Method, r.URL)
4        next.ServeHTTP(w, r)
5    })
6}
7
8func main() {
9    mux := http.NewServeMux()
10    mux.HandleFunc("/users", getUsers)
11
12    // Обёртка middleware
13    handler := loggingMiddleware(mux)
14    log.Fatal(http.ListenAndServe(":8080", handler))
15}

1package main
2
3import (
4    "net/http"
5
6    "github.com/gin-gonic/gin"
7)
8
9func main() {
10    r := gin.Default()
11
12    r.GET("/users", func(c *gin.Context) {
13        users := []User{
14            {ID: 1, Name: "Alice"},
15            {ID: 2, Name: "Bob"},
16        }
17        c.JSON(http.StatusOK, users)
18    })
19
20    r.GET("/users/:id", func(c *gin.Context) {
21        id := c.Param("id")
22        user := User{ID: 1, Name: "Alice"}
23        c.JSON(http.StatusOK, user)
24    })
25
26    r.Run(":8080")
27}

1func main() {
2    r := gin.Default()
3
4    v1 := r.Group("/api/v1")
5    {
6        v1.GET("/users", getUsers)
7        v1.POST("/users", createUser)
8        v1.GET("/users/:id", getUser)
9        v1.PUT("/users/:id", updateUser)
10        v1.DELETE("/users/:id", deleteUser)
11    }
12
13    v2 := r.Group("/api/v2")
14    {
15        v2.GET("/users", getUsersV2)
16    }
17
18    r.Run(":8080")
19}

1type CreateUserRequest struct {
2    Name  string `json:"name" binding:"required,min=2,max=100"`
3    Email string `json:"email" binding:"required,email"`
4    Age   int    `json:"age" binding:"gte=0,lte=130"`
5}
6
7func createUser(c *gin.Context) {
8    var req CreateUserRequest
9    if err := c.ShouldBindJSON(&req); err != nil {
10        c.JSON(http.StatusBadRequest, gin.H{
11            "error": err.Error(),
12        })
13        return
14    }
15
16    c.JSON(http.StatusCreated, gin.H{
17        "message": "User created",
18    })
19}

1func AuthMiddleware() gin.HandlerFunc {
2    return func(c *gin.Context) {
3        token := c.GetHeader("Authorization")
4        if token == "" {
5            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
6                "error": "Unauthorized",
7            })
8            return
9        }
10
11        // Проверка токена
12        userID, err := validateToken(token)
13        if err != nil {
14            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
15                "error": "Invalid token",
16            })
17            return
18        }
19
20        c.Set("userID", userID)
21        c.Next()
22    }
23}
24
25func main() {
26    r := gin.Default()
27
28    // Глобальный middleware
29    r.Use(gin.Logger())
30    r.Use(gin.Recovery())
31
32    // Protected routes
33    authorized := r.Group("/api")
34    authorized.Use(AuthMiddleware())
35    {
36        authorized.GET("/profile", getProfile)
37        authorized.POST("/orders", createOrder)
38    }
39}