GIN Router

cmd/server/main.go

package main

import (
	"fmt"
	"github.com/TaiTitans/go-ecommerce-backend-api/internal/routers"
)

func main() {
	fmt.Println(("Start Going server..."))
	r := routers.NewRouter()
	// Run with PORT
	r.Run(":8080")
}

Cách hoạt động tổng thể:

File main.go đóng vai trò là điểm khởi động của ứng dụng. Nó khởi tạo một router từ package routers và chạy server trên port 8080. Tất cả logic định tuyến thực tế (các endpoint như /ping) được định nghĩa trong package routers.

Ví dụ thực tế:

Khi bạn chạy chương trình, terminal sẽ in: Start Going server..., sau đó server bắt đầu lắng nghe các request tại http://localhost:8080.

routers/router.go

package routers

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func NewRouter() *gin.Engine {
	r := gin.Default()
	//Group API v1
	v1 := r.Group("/v1/2025")
	{
		v1.GET("/ping", Pong)
		v1.POST("/ping", Pong)
		v1.PUT("/ping", Pong)
		v1.DELETE("/ping", Pong)
		v1.PATCH("/ping", Pong)
	}
	return r
}
func Pong(c *gin.Context) {
	name := c.Param("name") //Path params - name := c.DefaultQuery("name", "TaiTitans") -> If dont have name, default is TaiTitans
	uid := c.Query("uid")   //Query params
	c.JSON(http.StatusOK, gin.H{
		"message": "pong..pong" + name,
		"uid":     uid,
		"users":   []string{"TaiTitans", "TaiTitans2", "TaiTitans3"},
		"status":  http.StatusOK,
	})
}

Giải thích chi tiết:

package routers:
- Đây là package con trong dự án, được đặt trong thư mục internal/routers. Từ khóa internal đảm bảo rằng package này chỉ có thể được import bởi các package trong cùng dự án.
import:
- "github.com/gin-gonic/gin": Framework Gin, dùng để xây dựng API RESTful trong Go.
- "net/http": Thư viện chuẩn của Go để xử lý các hằng số HTTP như http.StatusOK (mã trạng thái 200).
func NewRouter() *gin.Engine:
- Hàm này tạo và trả về một đối tượng *gin.Engine, là cốt lõi của Gin để định nghĩa các tuyến đường (routes).
- r := gin.Default(): Khởi tạo router với các middleware mặc định của Gin (như logging và recovery để xử lý lỗi).
v1 := r.Group("/v1/2025"):
- Tạo một nhóm tuyến đường (route group) với tiền tố /v1/2025. Điều này giúp tổ chức các endpoint theo phiên bản API (ở đây là v1 cho version 1, và 2025 có thể là năm hoặc định danh cụ thể).
- Tất cả các tuyến đường trong nhóm này sẽ có URL bắt đầu bằng /v1/2025.
Định nghĩa các tuyến đường trong nhóm v1:
- v1.GET("/ping", Pong): Xử lý request GET tới /v1/2025/ping.
- v1.POST("/ping", Pong): Xử lý request POST tới /v1/2025/ping.
- v1.PUT("/ping", Pong): Xử lý request PUT tới /v1/2025/ping.
- v1.DELETE("/ping", Pong): Xử lý request DELETE tới /v1/2025/ping.
- v1.PATCH("/ping", Pong): Xử lý request PATCH tới /v1/2025/ping.
- Tất cả các phương thức HTTP này đều gọi hàm Pong để xử lý logic.
func Pong(c *gin.Context):
- Đây là handler function xử lý các request gửi đến endpoint /ping.
- Tham số c *gin.Context chứa toàn bộ thông tin về request (query params, path params, body, v.v.) và được dùng để gửi response.
Xử lý tham số trong Pong:
- name := c.Param("name"): Lấy tham số từ đường dẫn (path parameter). Tuy nhiên, trong code hiện tại, /ping không định nghĩa tham số động (như /ping/:name), nên name sẽ là chuỗi rỗng. Nếu bạn muốn dùng path params, cần thay đổi route thành v1.GET("/ping/:name", Pong).
- uid := c.Query("uid"): Lấy tham số từ query string (ví dụ: /ping?uid=123 sẽ gán uid = "123").
c.JSON(http.StatusOK, gin.H{...}):
- Trả về một response dưới dạng JSON với mã trạng thái 200 OK.
- gin.H là một kiểu map ngắn gọn của Gin, tương đương với map[string]interface{}.
- Nội dung JSON trả về:
  - "message": "pong..pong" + name: Chuỗi "pong..pong" nối với giá trị name (nếu có).
  - "uid": uid: Giá trị của query param uid.
  - "users": []string{"TaiTitans", "TaiTitans2", "TaiTitans3"}: Một mảng cố định chứa 3 tên người dùng.
  - "status": http.StatusOK: Mã trạng thái 200.

Trong framework Gin của Go, *gin.Context là một cấu trúc cốt lõi được sử dụng để xử lý các request HTTP và trả về response. Nó đóng vai trò như một "context" (ngữ cảnh) chứa tất cả thông tin liên quan đến request hiện tại và cung cấp các phương thức để tương tác với request/response. Dưới đây là giải thích chi tiết về *gin.Context, bao gồm các thành phần, phương thức phổ biến và cách sử dụng trong thực tế.

`*gin.Context` là gì?

*gin.Context là một con trỏ tới struct gin.Context, được truyền vào mỗi handler function (hàm xử lý tuyến đường) trong Gin.
Nó chứa:
- Thông tin về request (method, URL, headers, body, query params, path params, v.v.).
- Công cụ để gửi response (JSON, HTML, status code, v.v.).
- Các tiện ích khác như middleware data, error handling, v.v.

Ví dụ cơ bản:

func handler(c *gin.Context) {
    c.JSON(200, gin.H{"message": "Hello, World!"})
}

Các thành phần chính trong `*gin.Context`

*gin.Context chứa nhiều trường (field) và phương thức. Dưới đây là các thành phần quan trọng mà bạn thường sử dụng:

1. Thông tin về Request

c.Request: Con trỏ tới http.Request (từ package net/http), chứa toàn bộ thông tin request.
- c.Request.Method: Phương thức HTTP (GET, POST, v.v.).
- c.Request.URL: URL của request.
- c.Request.Header: Header của request.
- c.Request.Body: Body của request (dạng io.ReadCloser).

2. Response Writer

c.Writer: Đối tượng http.ResponseWriter để ghi response (status code, header, body).

3. Các trường khác

Params: Danh sách các path parameters (tham số trong đường dẫn).
QueryMap: Bản đồ các query parameters.
Keys: Một map để lưu trữ dữ liệu tạm thời trong quá trình xử lý request (thường dùng với middleware).

Các phương thức phổ biến của `*gin.Context`

Dưới đây là danh sách các phương thức quan trọng mà bạn có thể sử dụng trong *gin.Context, chia theo nhóm chức năng:

1. Lấy thông tin từ Request

c.Param(key string) string: Lấy giá trị của path parameter.
- Ví dụ: Với route /users/:id, c.Param("id") trả về giá trị của id.
```
r.GET("/users/:id", func(c *gin.Context) {
    id := c.Param("id")
    c.JSON(200, gin.H{"user_id": id})
})
```
- Request: GET /users/123 → Response: {"user_id": "123"}
c.Query(key string) string: Lấy giá trị của query parameter.
- Ví dụ: GET /search?q=hello → c.Query("q") trả về "hello".
```
r.GET("/search", func(c *gin.Context) {
    q := c.Query("q")
    c.JSON(200, gin.H{"query": q})
})
```
c.DefaultQuery(key, defaultValue string) string: Lấy query parameter, nếu không có thì trả về giá trị mặc định.
```
name := c.DefaultQuery("name", "Guest") // Nếu không có ?name=... thì trả về "Guest"
```

c.PostForm(key string) string: Lấy giá trị từ form data (dùng với Content-Type: application/x-www-form-urlencoded).

r.POST("/form", func(c *gin.Context) {
    username := c.PostForm("username")
    c.JSON(200, gin.H{"username": username})
})

c.Bind(obj interface{}) error: Gắn dữ liệu từ body (JSON, XML, v.v.) vào một struct.

type User struct {
    Name string `json:"name"`
}
r.POST("/users", func(c *gin.Context) {
    var user User
    if err := c.Bind(&user); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    c.JSON(200, gin.H{"name": user.Name})
})

Request: POST /users với body {"name": "Tai"} → Response: {"name": "Tai"}

2. Gửi Response

c.JSON(code int, obj interface{}): Trả về response dạng JSON với mã trạng thái.
```
c.JSON(200, gin.H{"message": "Success"})
```
c.String(code int, format string, values ...interface{}): Trả về response dạng chuỗi.
```
c.String(200, "Hello, %s!", "Tai")
```

c.HTML(code int, name string, data interface{}): Trả về response dạng HTML (cần thiết lập template trước).

r.LoadHTMLGlob("templates/*")
r.GET("/page", func(c *gin.Context) {
    c.HTML(200, "index.html", gin.H{"title": "Home"})
})

c.Status(code int): Đặt mã trạng thái mà không gửi body (thường dùng với HEAD).
```
c.Status(204) // No Content
```
c.Data(code int, contentType string, data []byte): Trả về dữ liệu thô với content type tùy chỉnh.
```
c.Data(200, "text/plain", []byte("Raw data"))
```

3. Thiết lập Header

c.Header(key, value string): Đặt header cho response.

c.Header("Content-Type", "application/json")
c.Header("X-Custom-Header", "value")

4. Xử lý lỗi

c.Abort(): Dừng chuỗi xử lý middleware/handler và không gọi các handler tiếp theo.

r.GET("/test", func(c *gin.Context) {
    c.Abort()
    c.JSON(403, gin.H{"message": "Forbidden"})
})

c.AbortWithStatus(code int): Dừng và trả về mã trạng thái.
```
c.AbortWithStatus(404) // Not Found
```
c.AbortWithError(code int, err error): Dừng và ghi lỗi vào log.
```
c.AbortWithError(500, errors.New("Server error"))
```

5. Lưu trữ dữ liệu tạm thời

c.Set(key string, value interface{}): Lưu giá trị vào context (thường dùng trong middleware).

c.Get(key string) (interface{}, bool): Lấy giá trị từ context.

r.Use(func(c *gin.Context) {
    c.Set("userID", "123")
    c.Next()
})
r.GET("/profile", func(c *gin.Context) {
    userID, exists := c.Get("userID")
    if exists {
        c.JSON(200, gin.H{"user_id": userID})
    }
})

6. Điều hướng

c.Redirect(code int, location string): Chuyển hướng request tới URL khác.
```
c.Redirect(302, "https://example.com")
```

Ví dụ tổng hợp

Dưới đây là một ví dụ sử dụng nhiều phương thức của *gin.Context:

package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func main() {
	r := gin.Default()

	r.GET("/users/:id", func(c *gin.Context) {
		id := c.Param("id")            // Path param
		name := c.Query("name")        // Query param
		c.Header("X-Version", "1.0")  // Custom header
		c.JSON(http.StatusOK, gin.H{
			"id":   id,
			"name": name,
		})
	})

	r.POST("/users", func(c *gin.Context) {
		var user struct {
			Name string `json:"name"`
			Age  int    `json:"age"`
		}
		if err := c.Bind(&user); err != nil {
			c.JSON(400, gin.H{"error": err.Error()})
			return
		}
		c.JSON(201, gin.H{
			"message": "User created",
			"name":    user.Name,
			"age":     user.Age,
		})
	})

	r.Run(":8080")
}

Kiểm tra

GET http://localhost:8080/users/123?name=Tai
- Response: {"id": "123", "name": "Tai"}
POST http://localhost:8080/users với body {"name": "Tai", "age": 25}
- Response: {"message": "User created", "name": "Tai", "age": 25}

PreviousProject Structure NextGIN MVC

Last updated 14 days ago

*gin.Context là gì?

Các thành phần chính trong *gin.Context

Các phương thức phổ biến của *gin.Context

Ví dụ tổng hợp

`*gin.Context` là gì?

Các thành phần chính trong `*gin.Context`

Các phương thức phổ biến của `*gin.Context`