学习思维导图

互动

临近五一尾声，大家五一一定收获满满，是快乐还是知识呢！
五一小长假我又加更了，如今==Gin框架学习==这块学习也要接近尾声了，感谢你们的支持！
近期或者过段时间出Beego框架学习教程欢迎来观看！

精通篇

日志记录

日志记录是将程序上运行的动作记录下来，比如什么时候谁做了什么事情

日志框架

package main
import (
    "github.com/gin-gonic/gin"
    "io"
    "os"
)

func Logger() *logrus.Logger {
    now := time.Now()
    logFilePath := ""
    if dir, err := os.Getwd(); err == nil {
        logFilePath = dir + "/logs/"
    }
    if err := os.MkdirAll(logFilePath, 0777); err != nil {
        fmt.Println(err.Error())
    }
    logFileName := now.Format("2021-05-04") + ".log"
    //日志文件
    fileName := path.Join(logFilePath, logFileName)
    if _, err := os.Stat(fileName); err != nil {
        if _, err := os.Create(fileName); err != nil {
            fmt.Println(err.Error())
        }
    }
    //写入文件
    src, err := os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
    if err != nil {
        fmt.Println("err", err)
    }
    //实例化
    logger := logrus.New()
    //设置输出
    logger.Out = src
    //设置日志级别
    logger.SetLevel(logrus.DebugLevel)
    //设置日志格式
    logger.SetFormatter(&logrus.TextFormatter{
        TimestampFormat: "2021-05-04 19:23:51",
    })
    return logger
}

func LoggerFile() gin.HandlerFunc {
    logger := Logger()
    return func(c *gin.Context) {
        // 开始时间
        startTime := time.Now()
        // 处理请求
        c.Next()
        // 结束时间
        endTime := time.Now()
        // 执行时间
        latencyTime := endTime.Sub(startTime)
        // 请求方式
        reqMethod := c.Request.Method
        // 请求路由
        reqUri := c.Request.RequestURI
        // 状态码
        statusCode := c.Writer.Status()
        // 请求IP
        clientIP := c.ClientIP()
        //日志格式
        logger.Infof("| %3d | %13v | %15s | %s | %s |",
            statusCode,latencyTime,clientIP,reqMethod,reqUri,
        )
    }
}

func main() {
    // 记录到文件。
    r := gin.Default()
    r.Use(LoggerFile())
    r.GET("/", func(context *gin.Context) {
        //Info级别的日志
        Logger().WithFields(logrus.Fields{
            "name": "hanyun",
        }).Info("记录一下日志", "Info")
        //Error级别的日志
        Logger().WithFields(logrus.Fields{
            "name": "hanyun",
        }).Error("记录一下日志", "Error")
        //Warn级别的日志
        Logger().WithFields(logrus.Fields{
            "name": "hanyun",
        }).Warn("记录一下日志", "Warn")
        //Debug级别的日志
        Logger().WithFields(logrus.Fields{
            "name": "hanyun",
        }).Debug("记录一下日志", "Debug")
    })
    r.Run()
}

数据库

sql包：go get -u github.com/go-sql-driver/mysql

原生数据库

package main
import (
    "database/sql"
    "fmt"
    //_空导入指定包
    _ "github.com/go-sql-driver/mysql"
)
var SqlDb *sql.DB
func init() {
    // 连接数据库：root --> (数据库用户名),123456 --> (数据库密码),tcp@(127.0.0.1) --> (本地地址),mysql --> (数据库库名)
    sqladdrs := "root:123456@tcp(127.0.0.1)/mysql?charset=utf8&parseTime=true&loc=Local"
    var err error
    SqlDb, err = sql.Open("mysql", sqladdrs)
    //测试数据库是否打开成功
    if err != nil {
        fmt.Println("数据库打开出现了问题", err)
        return
    }
    // 测试数据库是否连接成功
    err = SqlDb.Ping()
    if err != nil {
        fmt.Println("数据库连接出现了问题", err)
        return
    }
}
//Sql数据
type SqlUser struct {
    Name    string `json:"name"`
    Age     int    `json:"age"`
}
func InsertData(c *gin.Context) {
    var u SqlUser
    err := c.Bind(&u)
    sql := "insert into user(name, age) values (?,?)"
    ret, err := sqlDb.Exec(sql, u.Name, u.Age)
    if err != nil {
        fmt.Printf("插入失败:%v\n", err)
        return false
    } else {
        return true
}
func main() {
    r:= gin.Default()
    r.POST("/", InsertData)
    r.Run()
}

XORM数据库

package main
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
var x *xorm.Engine
var xormResponse XormResponse

type SqlUser struct {
    Name    string `json:"name"`
    Age     int    `json:"age"`
}
func init() {
    sqladdrs:= "root:123456@tcp(127.0.0.1)/xorm?charset=utf8&parseTime=true&loc=Local" 
    var err error
    x, err = xorm.NewEngine("mysql", sqladdrs) 
    if err != nil {
        fmt.Println("数据库连接失败:", err)
    }
    err = x.Sync(new(Stu))
    if err != nil {
        fmt.Println("数据表同步失败:", err)
    }
}
func main() {
    r:= gin.Default()
    r.POST("/", InsertData)
    r.Run()
}
func InsetData(c *gin.Context) {
    var s Stu
    err := c.Bind(&s)
    if err != nil {
        fmt.Println("参数错误", err) 
        return
    }
    aff, err := x.Insert(s)
    if err != nil || aff <= 0 {
        fmt.Println("插入失败", err)
        return false
    } else {
        return true
}

GORM数据库

package main
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
var gormDB *gorm.DB
var gormResponse GormResponse

type SqlUser struct {
    Name    string `json:"name"`
    Age     int    `json:"age"`
}
func init() {
    var err error
    sqlStr := "root:123456@tcp(127.0.0.1)/gorm?charset=utf8mb4&parseTime=true&loc=Local"
    gormDB, err = gorm.Open(mysql.Open(sqlStr), &gorm.Config{}) //配置项中预设了连接池 ConnPool
    if err != nil {
        fmt.Println("数据库连接出现了问题：", err)
        return
    }
}
func main() {
    r := gin.Default()
    r.POST("/", InsertData)
}
func InsertData(c *gin.Context) {
    defer func() {
        err := recover()
        if err != nil {
            fmt.Println("捕获异常", err) 
        }
    }()
    var p Product
    err := c.Bind(&p)
    if err != nil {
           fmt.Println("参数错误", err) 
        return
    }
    fmt.Println(p)
    tx := gormDB.Create(&p)
    if tx.RowsAffected > 0 {
           fmt.Println("插入失败", err)
        return false
    } else {
        return true
}

后记

喜欢的话可以三连，后续继续更新其他内容，帮忙推一推，感谢观看!