# Gin的使用
## Gin是什么
- Gin 是一个用 Go 语言编写的高性能 Web 框架，以其快速的路由和中间件支持著称。它基于 `httprouter`，提供了简洁的 API 和强大的功能，适合构建高效的 Web 应用和 API。

## 如何使用Gin
### 创建一个最基本的Gin程序
 ```go
package main

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

func main() {
    // 创建默认 Gin 实例
    r := gin.Default()

    // 定义路由和处理函数
    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, Gin!",
        })
    })
    // 启动服务器，默认监听 8080 端口
    r.Run()
}
```
- 修改启动端口`r.Run("80")`
### Gin的使用方式
- Gin 支持多种 HTTP 方法的路由定义：
	- `GET`
	- `POST`
	- `PUT`
	- `DELETE`
	- `PATCH`
	- `OPTIONS`
	- `HEAD`
	```go
	r.GET("/get", func(c *gin.Context) {
    c.JSON(200, gin.H{
	        "message": "GET request",
	    })
	})
	
	r.POST("/post", func(c *gin.Context) {
	    c.JSON(200, gin.H{
	        "message": "POST request",
	    })
	})
	```
- Gin获取请求参数
	- - **查询参数**：`c.Query("key")`
    - **表单参数**：`c.PostForm("key")`
    - **路径参数**：`c.Param("key")`
	```go
	r.GET("/user", func(c *gin.Context) {
	    name := c.Query("name")
	    c.JSON(200, gin.H{
	        "name": name,
	    })
	})
	
	r.POST("/user", func(c *gin.Context) {
	    name := c.PostForm("name")
	    c.JSON(200, gin.H{
	        "name": name,
	    })
	})
	
	r.GET("/user/:id", func(c *gin.Context) {
	    id := c.Param("id")
	    c.JSON(200, gin.H{
	        "id": id,
	    })
	})
	```
	- Json参数
	```go
	var orders struct {  
	    DeviceId  string `json:"deviceId"`  
	    Isrunning int    `json:"isrunning"`  
	}  
	if err := c.ShouldBind(&orders); err != nil {  
	    c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})  
	    return  
	}
	```
- 分组路由

使用 `r.Group()` 创建路由分组：
```go
v1 := r.Group("/")
{
    v1.GET("/login", func(c *gin.Context) {
        c.String(200, "v1 login")
    })
    v1.GET("/submit", func(c *gin.Context) {
        c.String(200, "v1 submit")
    })
}
```

- Gin使用中间件
```go
func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("Request received")
        c.Next()
    }
}

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

    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, Gin!",
        })
    })

    r.Run()
}
```
- 返回多种响应
	- **JSON**：`c.JSON(code, obj)`
	- **字符串**：`c.String(code, format, values...)`
	- **HTML**：`c.HTML(code, name, obj)`
	- **文件**：`c.File(filepath)`
```go
r.GET("/json", func(c *gin.Context) {
    c.JSON(200, gin.H{
        "message": "JSON response",
    })
})

r.GET("/string", func(c *gin.Context) {
    c.String(200, "String response")
})

r.GET("/html", func(c *gin.Context) {
    c.HTML(200, "index.html", gin.H{
        "title": "Main website",
    })
})
r.GET("/getfiles", getfiles)
func getfiles(c *gin.Context) {
	c.File("./Halloworld.txt")
}
```
### 常用的中间件
#### 1. **CORS 跨域中间件**
• **作用**：处理跨域请求，允许前端应用访问 API。
• **包地址**：`github.com/gin-contrib/cors`
• **安装**：
  ```bash
  go get github.com/gin-contrib/cors
  ```
• **示例**：
  ```go
  import "github.com/gin-contrib/cors"

  r.Use(cors.New(cors.Config{
    AllowOrigins:  []string{"https://example.com"},
    AllowMethods:  []string{"GET", "POST"},
    AllowHeaders:  []string{"Authorization"},
  }))
  ```

#### 2. **JWT 身份验证中间件**
• **作用**：验证请求的 Token，保护需要登录的接口。
• **包地址**：`github.com/appleboy/gin-jwt/v2`
• **安装**：
  ```bash
  go get github.com/appleboy/gin-jwt/v2
  ```
• **示例**：
  ```go
  authMiddleware, _ := jwt.New(&jwt.GinJWTMiddleware{
    Realm:       "my-app",
    Key:         []byte("secret-key"),
    Timeout:     time.Hour,
  })
  r.POST("/login", authMiddleware.LoginHandler)
  r.GET("/protected", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
    c.JSON(200, gin.H{"msg": "Authorized"})
  })
  ```

#### 3. **限流中间件（Rate Limiter）**
• **作用**：防止接口被频繁调用（如防止暴力破解）。
• **包地址**：`github.com/ulule/limiter/v3` + `github.com/ulule/limiter/v3/drivers/middleware/gin`
• **安装**：
  ```bash
  go get github.com/ulule/limiter/v3
  ```
• **示例**：
  ```go
  import (
    "github.com/ulule/limiter/v3"
    "github.com/ulule/limiter/v3/drivers/middleware/gin"
    "github.com/ulule/limiter/v3/drivers/store/memory"
  )

  rate := limiter.Rate{
    Period: 1 * time.Minute,
    Limit:  100, // 每分钟最多 100 次请求
  }
  store := memory.NewStore()
  limiterMiddleware := gin.NewMiddleware(limiter.New(store, rate))
  r.Use(limiterMiddleware)
  ```

#### 4. **GZIP 压缩中间件**
• **作用**：压缩 HTTP 响应体，减少传输体积。
• **包地址**：`github.com/gin-contrib/gzip`
• **安装**：
  ```bash
  go get github.com/gin-contrib/gzip
  ```
• **示例**：
  ```go
  import "github.com/gin-contrib/gzip"

  r.Use(gzip.Gzip(gzip.DefaultCompression))
  ```

