package main

import (
	"fmt"
	"net/http"
)

// PingHandler 是一个独立封装的处理函数
func PingHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
		return
	}//判断请求方法是否是GET
	w.Write([]byte("pong"))
}

// HelloHandler 返回 "Hello, World!"
func HelloHandler(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Hello, World!"))
}

func main() {
	// 创建自定义的多路复用器
	mux := http.NewServeMux()

	// 注册路由，使用封装的处理函数
	mux.HandleFunc("/ping", PingHandler)
	mux.HandleFunc("/hello", HelloHandler)

	// 创建自定义的 HTTP 服务器
	server := &http.Server{
		Addr:    ":8080", // 监听地址和端口
		Handler: mux,     // 使用自定义的多路复用器
	}

	// 启动服务器
	fmt.Println("Server is running at http://localhost:8080")
	if err := server.ListenAndServe(); err != nil {
		fmt.Println("Error starting server:", err)
	}
}

package main

import (
    "net/http" // 引入 net/http 标准库，用于 HTTP 状态码常量
    "github.com/gin-gonic/gin"
)

func main() {
    // 1. 创建一个默认的路由引擎
    // Default() 包含了 Logger 和 Recovery 中间件，方便调试和异常恢复
    r := gin.Default()

    // 2. 定义一个 GET 路由 和对应的处理函数
    // 当访问 /ping 时，会执行后面的匿名函数
    r.GET("/ping", func(c *gin.Context) {
        // 3. 使用 c.JSON 返回 JSON 格式的响应
        // 参数：HTTP 状态码，响应数据 (gin.H 是 map[string]interface{} 的快捷方式)
        c.JSON(http.StatusOK, gin.H{
            "message": "pong!",
            "status":  "ok",
        })
    })

    // 4. 启动 HTTP 服务，默认监听在 0.0.0.0:8080
    // 你也可以指定端口，例如 r.Run(":9090")
    err := r.Run()
    if err != nil {
       panic("Failed to start Gin server: " + err.Error())
    }
}

r.GET("/someGet", getting)
r.POST("/somePost", posting)
r.PUT("/somePut", putting)
r.DELETE("/someDelete", deleting)
r.PATCH("/somePatch", patching)
r.HEAD("/someHead", head)
r.OPTIONS("/someOptions", options)

// ...对应的处理函数 getting, posting 等需要自行定义
func getting(c *gin.Context) { /* ... */ }
func posting(c *gin.Context) { /* ... */ }
// ...

// 匹配 /users/john, /users/123 等
r.GET("/users/:id", func(c *gin.Context) {
    // 使用 c.Param() 获取路径参数
    userID := c.Param("id")
    c.JSON(http.StatusOK, gin.H{"user_id": userID})
})

// 也可以有多个参数
r.GET("/articles/:category/:article_id", func(c *gin.Context) {
    category := c.Param("category")
    articleID := c.Param("article_id")
    c.JSON(http.StatusOK, gin.H{
        "category":   category,
        "article_id": articleID,
    })
})

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()
	r.GET("/search", func(c *gin.Context) {
		page := c.Query("page")
		information := c.DefaultQuery("information", "none")
		extra, ok := c.GetQuery("extra")
		if !ok {
			extra = "none"
		}
		c.JSON(http.StatusOK, gin.H{
			"page":        page,
			"information": information,
			"extra":       extra,
		})
	})
	err := r.Run(":8080")
	if err != nil {
		panic(err)
	}
}

// http://localhost:8080/search?page=3&information=%E9%87%8D%E5%BA%86%E9%82%AE%E7%94%B5%E5%A4%A7%E5%AD%A6

// 创建一个 /api/v1 的路由组
v1 := r.Group("/api/v1")
{ // 可以用花括号增加可读性
    v1.GET("/users", func(c *gin.Context) { /* 获取用户列表 */
        c.JSON(http.StatusOK, gin.H{"users": []string{"user1", "user2"}})
    })
    v1.POST("/users", func(c *gin.Context) { /* 创建用户 */
        c.JSON(http.StatusCreated, gin.H{"message": "User created"})
    })

    // 可以在分组上应用中间件 (后面会讲)
    // v1.Use(AuthMiddleware())
}

// 另一个分组
v2 := r.Group("/api/v2")
{
    v2.GET("/products", func(c *gin.Context) { /* ... */ })
}

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()
	r.POST("/login", func(c *gin.Context) {
		username := c.PostForm("username")
		password := c.DefaultPostForm("password", "none")//若没检索到则为none
		//c.GetPostForm返回两个值，value和ok
		c.JSON(http.StatusOK, gin.H{
			"status":   "logged in",
			"username": username,
			"password": password,
		})
	})
	err := r.Run()
	if err != nil {
		panic(err)
	}
}

//curl.exe -X POST http://localhost:8080/login -d "username=Claran&password=12345679"

package main

import (
	"net/http"

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

type User struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
	Email    string `json:"email" binding:"required,email"`
}

func main() {
	r := gin.Default()
	r.POST("/register", func(c *gin.Context) {
		var user User
		if err := c.ShouldBindJSON(&user); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"username": user.Username,
			"password": user.Password,
			"email":    user.Email,
		})
	})
	err := r.Run()
	if err != nil {
		panic(err)
	}
}

r := gin.Default()
// 在这里添加你的全局中间件
r.Use(MyGlobalMiddleware())
// ... 定义路由 ...

adminGroup := r.Group("/admin")
// 只对 /admin/* 路由应用 AuthMiddleware
adminGroup.Use(AuthMiddleware())
{
    adminGroup.GET("/dashboard", ...)
    adminGroup.POST("/settings", ...)
}

r.GET("/special", AnotherMiddleware(), func(c *gin.Context) { /* ... */ })

// 一个简单的自定义日志中间件示例
func LoggerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Printf("Before request: %s %s\n", c.Request.Method, c.Request.URL.Path)

        // 调用链中的下一个处理函数 (可能是另一个中间件或最终的 Handler)
        c.Next() // <--- 重要！

        // 在请求处理完成后执行
        statusCode := c.Writer.Status()
        fmt.Printf("After request: Status %d\n", statusCode)
    }
}