Gin 路由注册与请求参数获取

200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）。
201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。
202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）
204 NO CONTENT - [DELETE]：用户删除数据成功。
400 INVALID REQUEST - [POST/PUT/PATCH]：用户发出的请求有错误，服务器没有进行新建或修改数据的操作，该操作是幂等的。
401 Unauthorized - [*]：表示用户没有权限（令牌、用户名、密码错误）。
403 Forbidden - [*] 表示用户得到授权（与401错误相对），但是访问是被禁止的。
404 NOT FOUND - [*]：用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。
406 Not Acceptable - [GET]：用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。
410 Gone -[GET]：用户请求的资源被永久删除，且不会再得到的。
422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时，发生一个验证错误。
500 INTERNAL SERVER ERROR - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

{
    error: "Invalid API key"
}

GET /books：返回资源对象的列表（数组）[{},{},{}]
GET /books/1：返回单个资源对象    {}
POST /books：返回新生成的资源对象  {新增的书}
PUT /books/1：返回完整的资源对象   {返回修改后的}
PATCH /books/1： 返回完整的资源对象  {返回修改后的}
DELETE /books/1：  返回一个空文档
{status:100,msg:查询成功,data:null}

{"link": {
  "rel":   "collection https://www.example.com/zoos",
  "href":  "https://api.example.com/zoos",
  "title": "List of zoos",
  "type":  "application/vnd.yourformat+json"
}}

package main
import (

"github.com/gin-gonic/gin"

"net/http"

)
func main() {

r := gin.Default()

r.GET("/book", func(c *gin.Context) {

c.String(http.StatusOK, "查询书籍信息")

})
r.POST("/book", func(c *gin.Context) {
	c.String(http.StatusOK, "新增书籍信息")
})

r.PUT("/book", func(c *gin.Context) {
	c.String(http.StatusOK, "修改书籍信息")
})

r.DELETE("/book", func(c *gin.Context) {
	c.String(http.StatusOK, "删除书籍信息")
})
r.Run(":8080")

}

func main() {

//Default返回一个默认的路由引擎

r := gin.Default()

r.GET("/user/search", func(c *gin.Context) {

username := c.DefaultQuery("username", "贾维斯")

//username := c.Query("username")

address := c.Query("address")

//输出json结果给调用方

c.JSON(http.StatusOK, gin.H{

"message":  "ok",

"username": username,

"address":  address,

})

})

r.Run()

}

func main() {

//Default返回一个默认的路由引擎

r := gin.Default()

r.GET("/user/search/:username/:address", func(c *gin.Context) {

username := c.Param("username")

address := c.Param("address")

//输出json结果给调用方

c.JSON(http.StatusOK, gin.H{

"message":  "ok",

"username": username,

"address":  address,

})

})

r.Run(":8080")

}

package main

import (

"encoding/json"

"fmt"

"github.com/gin-gonic/gin"

"net/http"

)
func main() {

r := gin.Default()

r.POST("/json", func(c *gin.Context) {

// 注意：下面为了举例子方便，暂时忽略了错误处理

b, _ := c.GetRawData() // 从c.Request.Body读取请求数据

fmt.Printf("raw data: %s\n", string(b))

// 定义map或结构体

var m map[string]interface{}

// 反序列化

_ = json.Unmarshal(b, &m)
	c.JSON(http.StatusOK, m)
})
r.Run(":8080")

}

package main

import (

"github.com/gin-gonic/gin"

"net/http"

)
func main() {

router := gin.Default()
router.GET("/hello", func(c *gin.Context) {
	c.String(http.StatusOK, "Hello, Gin!")
})

router.GET("/world", func(c *gin.Context) {
	c.String(http.StatusOK, "World, Gin!")
})

router.Run(":8080")

}

package main

import (

"github.com/gin-gonic/gin"

"net/http"

)
func main() {

router := gin.Default()
// 创建一个路由组
apiGroup := router.Group("/api")

// 在路由组中注册路由
apiGroup.GET("/users", func(c *gin.Context) {
	c.String(http.StatusOK, "Get Users")
})

apiGroup.POST("/users", func(c *gin.Context) {
	c.String(http.StatusOK, "Create User")
})

router.Run(":8080")

}

r.GET("/test", func(c *gin.Context) {

c.Redirect(http.StatusMovedPermanently, "http://www.sogo.com/")

})

r.GET("/test", func(c *gin.Context) {

// 指定重定向的URL

c.Request.URL.Path = "/test2"

r.HandleContext(c)

})

r.GET("/test2", func(c *gin.Context) {

c.JSON(http.StatusOK, gin.H{"hello": "world"})

})

package main

import (

"github.com/gin-gonic/gin"

"net/http"

)
type QueryParams struct {

Name  string form:"name"

Age   int    form:"age"

}
func main() {

router := gin.Default()
router.GET("/user", func(c *gin.Context) {
	var queryParams QueryParams

	// 使用 c.ShouldBindQuery 绑定查询参数到结构体
	if err := c.ShouldBindQuery(&queryParams); err == nil {
		c.JSON(http.StatusOK, gin.H{
			"name": queryParams.Name,
			"age":  queryParams.Age,
		})
	} else {
		c.String(http.StatusBadRequest, "参数绑定失败")
	}
})

router.Run(":8080")

}

package main

import (

"github.com/gin-gonic/gin"

"net/http"

)
type FormData struct {

Name string form:"name"

Age  int    form:"age"

}
func main() {

router := gin.Default()
router.POST("/user", func(c *gin.Context) {
	var formData FormData

	// 使用 c.ShouldBind 绑定表单数据到结构体
	if err := c.ShouldBind(&formData); err == nil {
		c.JSON(http.StatusOK, gin.H{
			"name": formData.Name,
			"age":  formData.Age,
		})
	} else {
		c.String(http.StatusBadRequest, "参数绑定失败")
	}
})

router.Run(":8080")

}

mkdir webook

go mod init webook

package web

import (

"fmt"

regexp "github.com/dlclark/regexp2"

"github.com/gin-gonic/gin"

"net/http"

)
type UserHandler struct {

emailExp    *regexp.Regexp

passwordExp *regexp.Regexp

}
func NewUserHandler() UserHandler {

const (

emailRegexPattern    = "^\w+([-+.]\w+)@\w+([-.]\w+)\.\w+([-.]\w+)$"

passwordRegexPattern = ^(?=.*[A-Za-z])(?=.*\d)(?=.*[$@$!%*#?&])[A-Za-z\d$@$!%*#?&]{8,}$

)

emailExp := regexp.MustCompile(emailRegexPattern, regexp.None)

passwordExp := regexp.MustCompile(passwordRegexPattern, regexp.None)

return &UserHandler{

emailExp:    emailExp,

passwordExp: passwordExp,

}

}
func (u *UserHandler) RegisterRoutes(server *gin.Engine) {

ug := server.Group("/user")   //ug is user group

ug.GET("/profile", u.Profile) // 查询用户信息接口

ug.POST("/signup", u.SignUp)  // 注册接口

ug.POST("/login", u.Login)    // 登录接口

ug.POST("/logout", u.Logout)  // 登出接口

ug.POST("/edit", u.Edit)      // 修改用户信息接口
}
func (u *UserHandler) RegisterRoutesV1(ug *gin.RouterGroup) {

ug.GET("/profile", u.Profile) // 查询用户信息接口

ug.POST("/signup", u.SignUp)  // 注册接口

ug.POST("/login", u.Login)    // 登录接口

ug.POST("/logout", u.Logout)  // 登出接口

ug.POST("/edit", u.Edit)      // 修改用户信息接口
}

func (u *UserHandler) Profile(ctx *gin.Context) {

}

func (u *UserHandler) SignUp(ctx *gin.Context) {

type SignUpRequest struct {

Email           string json:"email"

Password        string json:"password"

ConfirmPassword string json:"confirmPassword"

}

var request SignUpRequest

// 如果 Bind 方法发现输入有问题，它就会直接返回一 个错误响应到前端。

if err := ctx.Bind(&request); err != nil {

return

}
ok, err := u.emailExp.MatchString(request.Email)
if err != nil {
	ctx.String(http.StatusOK, "系统错误")
	return
}
if !ok {
	ctx.String(http.StatusOK, "邮箱格式错误")
	return
}
ok, err = u.passwordExp.MatchString(request.Password)
if err != nil {
	ctx.String(http.StatusOK, "系统错误")
	return
}
if !ok {
	ctx.String(http.StatusOK, "密码必须包含至少一个数字、一个字母、一个特殊字符，并且长度至少为8位")
	return
}
if request.Password != request.ConfirmPassword {
	ctx.String(http.StatusOK, "两次密码不一致")
	return
}
ctx.String(http.StatusOK, "注册成功")
fmt.Printf("请求体为：%v", request)

}

func (u *UserHandler) Login(ctx *gin.Context) {
}
func (u *UserHandler) Logout(ctx *gin.Context) {
}

func (u *UserHandler) Edit(ctx *gin.Context) {
}

package main

import (

"github.com/gin-gonic/gin"

"strings"

"time"

"webook/internal/web"

)
func main() {

server := gin.Default()

u := web.NewUserHandler()

u.RegisterRoutes(server)

//ug := server.Group("/user/v1") //ug is user group

//c.RegisterRoutesV1(ug)

server.Run(":8080")

}