-
这块需要结合官方最新文档写。
和视频中的版本略有差异
这里贴出我的
gorm.io/driver/mysql v1.5.7
gorm.io/gorm v1.25.12package dao import ( "go-ranking/config" "go-ranking/pkg/logger" "gorm.io/driver/mysql" "gorm.io/gorm" "time" ) var ( Db *gorm.DB err error ) func init() { Db, err = gorm.Open(mysql.Open(config.Mysqldb), &gorm.Config{}) // ----------------------- Connection Pool Settings ----------------------- // SetMaxIdleConns sets the maximum number of connections in the idle connection pool. sqlDB, err := Db.DB() if err != nil { logger.Error(map[string]interface{}{"database error": err.Error()}) return } sqlDB.SetMaxIdleConns(10) // SetMaxOpenConns sets the maximum number of open connections to the database. sqlDB.SetMaxOpenConns(100) // SetConnMaxLifetime sets the maximum amount of time a connection may be reused. sqlDB.SetConnMaxLifetime(time.Hour) }查看全部 -
安 gorm依赖
go get -u gorm.io/gorm
安装 mysql驱动
go get -u gorm.io/driver/mysql
查看全部 -
package main import ( "fmt" ) func main() { fmt.Println("程序开始") safeFunction() fmt.Println("程序继续运行...") } func safeFunction() { defer func() { if r := recover(); r != nil { // 捕获 panic fmt.Println("捕获到异常:", r) } }() fmt.Println("执行函数") panic("触发异常") // 触发 panic，程序中断 fmt.Println("这行代码不会执行") }查看全部 -
思考：这里 err := context.BindJSON(&parms) 可以写成 err := context.BindJSON(parms) 吗？ /* 答：不可以写成 err := context.BindJSON(parms)，因为 BindJSON 需要一个指针类型的参数，即传入的参数必须是指向接收数据的变量的指针。 在 err := context.BindJSON(&parms) 中，&parms 是 parms 的指针，指向这个 map，所以 BindJSON 可以直接修改 parms 的内容，将请求中的 JSON 数据解析并赋值到 parms 中。如果写成 context.BindJSON(parms)，则传入的是 map 值的副本，BindJSON 将无法正确解析并赋值给 parms。 为什么 BindJSON 需要指针？ BindJSON 的参数类型是 interface{}，在 Go 中，如果要通过一个函数修改参数的内容，必须传递指针，这样函数才能直接操作参数的内存地址，进而修改参数的值。否则，如果传递的是值类型，Go 语言会复制该值，导致函数内对该副本的修改不会影响到原始变量。 示例对比 以下是对比： 正确写法 parms := make(map[string]interface{}) err := context.BindJSON(&parms) // 传入指针 // 解析后 parms 中将包含 JSON 数据 错误写法 parms := make(map[string]interface{}) err := context.BindJSON(parms) // 传入值，解析无法修改 parms 内容 // 解析不会修改 parms 的内容 小结 总之，context.BindJSON 需要一个指针类型的参数，因此必须使用 &parms。 */ func (o OrderControllerStruct) CreateOrder(context *gin.Context) { //name := context.PostForm("name") //price := context.PostForm("price") // 使用map接受json 数据 parms := make(map[string]interface{}) //使用 Gin 的 BindJSON 方法解析 JSON 数据并将其绑定到 parms // 思考 这里 err := context.BindJSON(&parms) 可以写成 err := context.BindJSON(parms) 吗？ // 不可以。 err := context.BindJSON(&parms) if err == nil { common.Succeed(1, context, parms, 10, "订单创建成功") } //common.Succeed(1, context, name, 10, price) }查看全部 -
简单示例 func (o OrderControllerStruct) CreateOrder(context *gin.Context) { name := context.PostForm("name") price := context.PostForm("price") common.Succeed(1, context, name, 10, price) }curl --location 'http://127.0.0.1:9999/order/create' \ --form 'name="小蛋糕"' \ --form 'price="100.00"'
查看全部 -
package controller import ( "github.com/gin-gonic/gin" "go-ranking/common" ) type UserControllerStruct struct { } func (u UserControllerStruct) GetUserInfo(c *gin.Context) { common.Failed(4004, c, "没有相关信息") } func (u UserControllerStruct) CreateUser(context *gin.Context) { common.Succeed(1, context, nil, 1, "创建成功") } func (u UserControllerStruct) DelUser(context *gin.Context) { common.Succeed(1, context, nil, 1, "删除成功") } func (u UserControllerStruct) UpdateUser(context *gin.Context) { common.Failed(0, context, "删除失败") }package router import ( "github.com/gin-gonic/gin" "go-ranking/controller" ) // Router 路由,这里方法名要大写,因为要导出出去，在别的包里使用 func Router() *gin.Engine { r := gin.Default() userGroup := r.Group("/user") // 注意这里,他们不是一起的。 { userGroup.GET("/info", controller.UserControllerStruct{}.GetUserInfo) //userGroup.GET("/list", func(c *gin.Context) { // c.JSON(http.StatusOK, gin.H{"message": "list"}) //}) userGroup.GET("/create", controller.UserControllerStruct{}.CreateUser) //userGroup.DELETE("/delete", controller.DelUser) userGroup.GET("/delete", controller.UserControllerStruct{}.DelUser) userGroup.PUT("/put", controller.UserControllerStruct{}.UpdateUser) } return r }package common import ( "github.com/gin-gonic/gin" "net/http" ) // json返回的数据结构 type JsonStruct struct { Code int `json:"code"` Data interface{} `json:"data"` Count int64 `json:"count"` Msg interface{} `json:"msg"` } type ErrorStruct struct { Code int `json:"code"` Msg interface{} `json:"msg"` } func Succeed(code int, c *gin.Context, data interface{}, count int64, msg interface{}) { json := &JsonStruct{code, data, count, msg} c.JSON(http.StatusOK, json) } func Failed(code int, c *gin.Context, msg interface{}) { json := &ErrorStruct{code, msg} c.JSON(http.StatusOK, json) } //func Demo(code int, c *gin.Context, msg interface{}) { // json := &JsonStruct{Code: code, Msg: msg} // c.JSON(http.StatusOK, json) //} /** 补充一个 关于 类型的值实例 和 类型的指针实例 区别、 &JsonStruct{} 和 JsonStruct{} 在 Go 中的区别在于它们的内存分配和类型。 1. JsonStruct{}：表示创建一个 JsonStruct 类型的值实例。 • 直接使用 JsonStruct{} 会在栈上分配一个 JsonStruct 类型的值，表示这个结构体的值本身。 • 当你使用 JsonStruct{} 时，得到的是一个结构体的副本。 2. &JsonStruct{}：表示创建一个 JsonStruct 类型的指针实例。 • 使用 &JsonStruct{} 会在堆上分配结构体值并返回一个指向该值的指针（类型为 *JsonStruct）。 • 返回的指针允许你直接修改结构体字段，而不会产生副本。 示例 假设有以下 JsonStruct 结构体： type JsonStruct struct { Code int Msg string } 然后我们来对比两种创建方式的不同： // 创建一个 JsonStruct 值实例 jsonValue := JsonStruct{Code: 200, Msg: "Success"} // 创建一个 JsonStruct 指针实例 jsonPointer := &JsonStruct{Code: 200, Msg: "Success"} 使用场景 • 值实例 (JsonStruct{})： • 适合在不需要对原始数据进行修改或传递副本时使用。 • 不适合处理大量数据，因为每次传递时都会复制结构体的数据。 • 指针实例 (&JsonStruct{})： • 适合在需要修改结构体字段，或在函数中传递以节省内存时使用。 • 对于较大结构体，指针实例更高效，因为不需要复制整个结构体。 示例：在函数中传递 func modifyValue(js JsonStruct) { js.Code = 500 // 只会修改副本 } func modifyPointer(js *JsonStruct) { js.Code = 500 // 修改指针所指向的原始数据 } func main() { jsValue := JsonStruct{Code: 200, Msg: "Original"} modifyValue(jsValue) fmt.Println(jsValue.Code) // 输出: 200 (未修改) jsPointer := &JsonStruct{Code: 200, Msg: "Original"} modifyPointer(jsPointer) fmt.Println(jsPointer.Code) // 输出: 500 (已修改) } 总结 • JsonStruct{}：创建结构体的值实例，每次使用时生成一个副本。 • &JsonStruct{}：创建结构体的指针实例，直接操作原始数据，更节省内存。 */查看全部 -
package common import ( "github.com/gin-gonic/gin" "net/http" ) // json返回的数据结构 type JsonStruct struct { Code int `json:"code"` Data interface{} `json:"data"` Count int64 `json:"count"` Msg interface{} `json:"msg"` } func Succeed(code int, c *gin.Context, data interface{}, count int64, msg interface{}) { json := &JsonStruct{code, data, count, msg} c.JSON(http.StatusOK, json) } func failed(code int, c *gin.Context, msg interface{}) { json := &JsonStruct{Code: code, Msg: msg} c.JSON(http.StatusOK, json) } /** 补充一个 关于 类型的值实例 和 类型的指针实例 区别、 &JsonStruct{} 和 JsonStruct{} 在 Go 中的区别在于它们的内存分配和类型。 1. JsonStruct{}：表示创建一个 JsonStruct 类型的值实例。 • 直接使用 JsonStruct{} 会在栈上分配一个 JsonStruct 类型的值，表示这个结构体的值本身。 • 当你使用 JsonStruct{} 时，得到的是一个结构体的副本。 2. &JsonStruct{}：表示创建一个 JsonStruct 类型的指针实例。 • 使用 &JsonStruct{} 会在堆上分配结构体值并返回一个指向该值的指针（类型为 *JsonStruct）。 • 返回的指针允许你直接修改结构体字段，而不会产生副本。 示例 假设有以下 JsonStruct 结构体： type JsonStruct struct { Code int Msg string } 然后我们来对比两种创建方式的不同： // 创建一个 JsonStruct 值实例 jsonValue := JsonStruct{Code: 200, Msg: "Success"} // 创建一个 JsonStruct 指针实例 jsonPointer := &JsonStruct{Code: 200, Msg: "Success"} 使用场景 • 值实例 (JsonStruct{})： • 适合在不需要对原始数据进行修改或传递副本时使用。 • 不适合处理大量数据，因为每次传递时都会复制结构体的数据。 • 指针实例 (&JsonStruct{})： • 适合在需要修改结构体字段，或在函数中传递以节省内存时使用。 • 对于较大结构体，指针实例更高效，因为不需要复制整个结构体。 示例：在函数中传递 func modifyValue(js JsonStruct) { js.Code = 500 // 只会修改副本 } func modifyPointer(js *JsonStruct) { js.Code = 500 // 修改指针所指向的原始数据 } func main() { jsValue := JsonStruct{Code: 200, Msg: "Original"} modifyValue(jsValue) fmt.Println(jsValue.Code) // 输出: 200 (未修改) jsPointer := &JsonStruct{Code: 200, Msg: "Original"} modifyPointer(jsPointer) fmt.Println(jsPointer.Code) // 输出: 500 (已修改) } 总结 • JsonStruct{}：创建结构体的值实例，每次使用时生成一个副本。 • &JsonStruct{}：创建结构体的指针实例，直接操作原始数据，更节省内存。 */查看全部 -
package main import ( "go-ranking/router" ) func main() { r := router.Router() r.Run(":9999") }package router import ( "github.com/gin-gonic/gin" "net/http" ) // Router 路由,这里方法名要大写,因为要导出出去，在别的包里使用 func Router() *gin.Engine { r := gin.Default() userGroup := r.Group("/user") // 注意这里,他们不是一起的。 { userGroup.GET("/list", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"message": "list"}) }) userGroup.POST("/create", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"message": "create"}) }) userGroup.DELETE("/delete", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"message": "delete"}) }) userGroup.PATCH("/patch", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"message": "patch "}) }) userGroup.PUT("/put", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"message": "put "}) }) } return r }对核心代码做一些解释
• 函数声明：
• func Router() 表示定义一个名为 Router 的函数。
• 返回值 *gin.Engine 表示这个函数返回一个指向 gin.Engine 实例的指针，gin.Engine 是 Gin 框架的核心路由器。
• *gin.Engine：
• gin.Engine 是 Gin 的核心类型，代表整个 HTTP 路由器和中间件系统。
• 通过 gin.Engine 实例，可以定义应用的路由、请求处理逻辑、中间件等。
查看全部 -
1. 初始化项目
// 目录 mkdir go-ranking cd go-ranking // 初始化项目
2.依赖下载
go get -u github.com/gin-gonic/gin
首次安装模块：安装指定的模块及其依赖。
更新已安装的模块：如果模块已经安装，-u 参数会更新到最新版本，并将依赖也更新到最新
解释一下 gin 是什么
Gin 是一个用 Go（Golang）编写的轻量级 Web 框架，专门用于构建高性能的 HTTP Web 应用和 RESTful API。Gin 的设计灵感来源于 Python 的 Flask 框架，提供了简洁易用的 API，能够快速地构建 Web 应用和服务。它是 Go 语言社区中使用广泛的 Web 框架之一。
Gin 的主要特点
1. 高性能：Gin 使用了 net/http 标准库构建，优化了路由处理性能，适合需要高并发的场景。
2. 简洁易用：Gin 提供了简单的接口，代码风格清晰，可以用很少的代码实现复杂的 API 逻辑。
3. 中间件支持：Gin 支持中间件机制，可以自定义日志、错误处理、认证等操作，增加了灵活性。
4. 路由功能强大：支持参数化路由、分组路由等功能，使代码结构更清晰，管理路由更方便。
5. JSON 处理便捷：Gin 内置了 JSON 序列化与反序列化操作，适合构建 JSON API。
3. 第一个Web程序：
package main import ( "fmt" "github.com/gin-gonic/gin" "net/http" ) func main() { fmt.Println("Hello World") r := gin.Default() r.GET("/ping", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{ "message": "Pong", }) }) r.Run(":9999") }4. 访问http://127.0.0.1:9999/ping 返回
{ "message": "Pong" }That's all
注意这里
查看全部 -
defer：延迟执行，先defer的后执行
panic 程序直接终止
recover在defer中执行，让程序恢复正常的状态去执行
查看全部 -
3-4章节大纲课后复习大纲
如何获取get方式xxx?id=xxx&name=xxx中的id和name
如何获取post方式请求的body中的表单对象
如何获取post方式请求的body中的json对象(map和结构体两种方式获取)
查看全部 -
记录下来查看全部 -
还可以
查看全部 -
不错
查看全部 -
1
查看全部
举报
0/150
提交
取消