关于go:Gin-GORM-入门到实战

本文参加了思否技术征文，欢送正在浏览的你也退出。

Hello，大家好，我是海军，最近始终在学习Go，目前在做我的项目相熟Go 阶段。 本文来分享一下 Gin + GORM 的一些 开发体验，有喜爱Go 方向的敌人，欢送一起交流学习呀！
后续会更新实战我的项目，目前在实现一个 技术论坛我的项目，结尾有效果图，前端局部实现了，当初在欠缺后端接口和前端联调的过程，没多久就会公布了。 后续，会再写一篇我的项目文章。

干就完了 🤔

导读目录

Gin

• Gin 学习路线
• Gin 入门装置
• Gin 中间件应用
• Gin 获取申请参数
• Gin 获取JSON数据
• Gin Cookie
• Gin Session
• Gin 上传文件

GORM

• 什么是GORM
• 如何建Model

Gin

学习路线

入门装置

装置Gin

1. 下载依赖

$ go get -u github.com/gin-gonic/gin

2. 将 gin 引入到代码中：

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

3. （可选）如果应用诸如 http.StatusOK 之类的常量，则须要引入 net/http 包：

import "net/http"

demo

package main

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

func main() {
    fmt.Println("Gin 入门学习")

    // 创立一个默认的路由引擎
    r := gin.Default()
    // GET：申请形式；/hello：申请的门路
    // 当客户端以GET办法申请/hello门路时，会执行前面的匿名函数
    r.GET("/hello", func(c *gin.Context) {
        // c.JSON：返回JSON格局的数据
        c.JSON(200, gin.H{
            "message": "Hello world!",
        })
    })
    // 启动HTTP服务，默认在0.0.0.0:8080启动服务
    r.Run(":8098")
}

Gin 中间件应用

目录

• 什么是 中间件？
• 中间件作用域
• 中间件数据共享
• 中间件留神

什么是中间件？

中间件是在当客户端拜访服务端接口之前和之后会做一些事件。
作用： 登陆认证， 权限校验 ， 记录日志， 耗时统计 …..

中间件作用域

全局作用域

在 main 入口文件中， 通过 创立的默认路由引擎. use(中间件1,两头2,….) 即可注册应用全局中间件了。

import (
   "Gin/middleware"
   "Gin/router"
   "fmt"
   "github.com/gin-gonic/gin"
   "net/http"
)

func mian() {

// 创立一个默认的路由引擎
var r = gin.Default()  

// 全局应用 中间价,能够应用一个/多个中间件
r.Use(middleware.GetHttpHost, middleware.GetHttpMethod)
}

创立两个中间件，别离获取 Host， Method

package middleware

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

func GetHttpHost(r *gin.Context) {
    fmt.Printf("ℹ️ : 申请的地址为------%s ", r.Request.Host)
    r.Set("token", "SDASD12312rtywe")
    fmt.Println()
    r.Next()
}

func GetHttpMethod(r *gin.Context) {
    fmt.Printf("ℹ️ : 申请办法为------%s ", r.Request.Method)
    r.Next()
}

部分作用域

通过在，路由分组参数门路前面，增加中间件即可，反对增加多个中间件

package router

import "github.com/gin-gonic/gin"
import "Gin/controller/BookStore"
import "Gin/middleware"


func BookRouter(r *gin.Engine) {
    bookRouter := r.Group("/book", middleware.GetLogInfo)  //增加部分中间件
    {
        bookRouter.GET("/", BookStore.BookController{}.Index)

        bookRouter.GET("/:bookName", BookStore.BookController{}.SearchBookName)

        bookRouter.POST("/add", BookStore.BookController{}.Add)

    }
}

中间件数据共享

• c.set(name, value) c*gin.Context
• c.get(name)

package middleware

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

func GetHttpHost(r *gin.Context) {
    fmt.Printf("ℹ️ : 申请的地址为------%s ", r.Request.Host)
    r.Set("token", "SDASD12312rtywe")
    fmt.Println()
    r.Next()
}

package middleware

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

func GetLogInfo(c *gin.Context) {
    receiveToken, _ := c.Get("token")
    fmt.Println("进入中间件------")
    fmt.Printf("测试获取中间件中共享的数据---token:  %s", receiveToken)
    fmt.Println()
    c.Next()
}

获取申请参数

获取querystring参数

querystring指的是URL中?前面携带的参数，例如：/user/search?username=小王子&address=沙河。 获取申请的querystring参数的办法如下：

func getLoginInfo() {
    r.GET("/login", func(c *gin.Context) {
        username := c.Query("username")
        password := c.Query("password")
        // c.JSON：返回JSON格局的数据
        c.JSON(http.StatusOK, gin.H{
            "info":     "==========",
            "username": username,
            "password": password,
        })
    })
}

⚠️ 留神

• 能够指定默认的query 值,通过 c.DefaultQuery

username := c.DefaultQuery("username", "admin")

• 指定接管的 query key ，c.Query(“username”)

username := c.Query("username")

下面拜访 “http://127.0.0.1:8098/login?username=admin&password=1123123” 即可返回指定的json 值

{
    "info": "==========",
    "password": "1123123",
    "username": "admin"
}

获取 form 参数

申请的数据通过form表单来提交的，通过 PostForm（） 接管

func getFormParams() {
    r.POST("/saveBookInfo", func(c *gin.Context) {
        bookName := c.PostForm("bookName")
        author := c.PostForm("author")
        // c.JSON：返回JSON格局的数据
        c.JSON(http.StatusOK, gin.H{
            "bookName": bookName,
            "author":   author,
        })
        fmt.Println("测试Post")
        fmt.Printf("拜访的接口为--%s,参数为： bookName--- %s, author----%s", "/saveBookInfo", bookName, author)
    })
}

获取path参数

获取URl 的 path， 能够通过 c.Param（） 接管

func getRouterPathParams() {
    r.GET("/bookStore/:bookName/:author", func(c *gin.Context) {
        bookName := c.Param("bookName")
        author := c.Param("author")
        // c.JSON：返回JSON格局的数据
        c.JSON(http.StatusOK, gin.H{
            "bookName": bookName,
            "author":   author,
        })
        fmt.Println("测试Post")
        fmt.Printf("拜访的接口为--%s,参数为： bookName--- %s, author----%s", "/saveBookInfo", bookName, author)
    })
}

拜访链接🔗 http://127.0.0.1:8098/bookStore/Go/海军 ，返回

{
    "author": "海军",
    "bookName": "Go"
}

为了可能更不便的获取申请相干参数，进步开发效率，咱们能够基于申请的Content-Type辨认申请数据类型并利用反射机制主动提取申请中QueryString、form表单、JSON、XML等参数到构造体中。 上面的示例代码演示了.ShouldBind()弱小的性能，它可能基于申请主动提取JSON、form表单和QueryString类型的数据，并把值绑定到指定的构造体对象。

Cookie

Cookie 是存储在客户端的浏览器环境中的， 它能够 在拜访同一个域下的网站 数据共享。 它解决了HTTP 无状态数据不共享问题。

Cookie 性能

:::info

• 保留用户登陆状态
• 保留用户浏览器记录
• 猜你喜爱，智能举荐等
• 购物车等
  :::

设置Cookie

SetCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool)

c.SetCookie("loginStatus", "登陆胜利状态", 5600, "/", "localhost", false, true)

获取 cookie

c.Cookie(name)

Session

session 基本原理

http协定是无状态的，就是说你在申请服务器同时，服务器不晓得哪个是你拜访的，怎么让服务器晓得哪个是你拜访的，那么session 就进去了。
session 和 cookie 不分家，每次说 session 其实就是说 cookie。

服务端 和 客户端 有状态通信原理：
第一次登录时，服务器给客户端颁发一个惟一的sessionId, 并通过http的响应头返回。客户端（浏览器）发现返回的数据中有cookie数据就把这个cookie数据寄存到内存。下次再发送http申请时，把内存中的cookie数据再塞到http申请头中，一并发给服务器，服务器在解析申请时，发现申请头中有cookie，就开始辨认cookie中的sessionId，拿到sessionId，咱们就晓得这个申请时由哪个客户端发送来的了。

Gin 中应用 session

Gin 自身是没有提供 session 的，须要应用第三方依赖。

1. 装置依赖

go get github.com/gin-contrib/sessions

2. 导入依赖 应用

import (
"github.com/gin-contrib/sessions"
"github.com/gin-contrib/sessions/cookie"
"github.com/gin-gonic/gin"
)

func main(){

// 创立一个默认的路由引擎
var r = gin.Default()

// 1. 创立基于cookie的存储引擎，haijun 参数是用于加密的密钥，能够轻易填写
store := cookie.NewStore([]byte("haijun"))

// 2. 设置session中间件，参数mysession，指的是session的名字，也是cookie的名字
// store是后面创立的存储引擎
r.Use(sessions.Sessions("mysession", store))


r.GET("/test", func(c *gin.Context) {
        // 初始化session对象
        session := sessions.Default(c)
                
        // session是键值对格局数据，因而须要通过key查问数据
        session.Set("token", "haijun23123")
        session.Save()

                
        c.JSON(200, gin.H{"token": session.Get("token")})
    })

}

Session 操作

设置 session

session.Set("kay", value)

获取session

session.Get("key")

删除session

session.Delete("key")  //删除单个 session

session.Clear() //删除全副session

保留session

ssession.Save()

⚠️留神

1. session 仓库其实就是一个 map[interface]interface 对象，所有 session能够存储任意数据
2. session 应用的编解码器是自带的gob，所以存储相似： struct、map 这些对象时须要先注册对象，不然会报错 gob: type not registered for…
3. session 存储引擎反对： cookie、内存、mongodb、redis、postgres、memstore、memcached 以及 gorm 反对的各类数据库（mysql、sqlite）
4. session 在创立时有一个配置项，能够配置session过期工夫、cookie、domain、secure、path等参数
5. 调用 session 办法： Set()、 Delete()、 Clear()、办法后，必须调用一次 Save() 办法。否则session数据不会更新

上传文件

上传单文件

func (bk BookController) UploadOne(c *gin.Context) {
    //获取文件
    //c.FormFile("文件参数名")
    file, err := c.FormFile("file")
    //文件门路
    dst := path.Join("./static/images", file.Filename)

    // err == nil 代表上传胜利
    if err == nil {
        c.SaveUploadedFile(file, dst)
        c.JSON(200, gin.H{
            "msg": "上传文件胜利",
        })

    } else {
        c.JSON(400, gin.H{
            "msg": "上传文件失败----- 🙅",
        })
    }
}

上传多文件

// 上传多个文件
func (bk BookController) Upload(c *gin.Context) {
    //通过 c.MultipartForm() 获取多个文件 
    form, _ := c.MultipartForm()
    filesArr := form.File["file[]"]
    fmt.Println(filesArr)
    //for range 遍历保留文件
    for _, file := range filesArr {
        dst := path.Join("./static/images", file.Filename)
        c.SaveUploadedFile(file, dst)
    }

    c.JSON(200, gin.H{
        "msg":      "上传文件胜利",
        "fileList": form.File["file[]"],
    })

}

实战

// 测验上传文件的格局
func (bk BookController) CheckFileFormat(c *gin.Context) {
    //1.获取文件
    file, status := c.FormFile("companyInfo")
    if status == nil {
        //2. 获取文件格式
        fileFormat := path.Ext(file.Filename)

        allowFormat := map[string]bool{
            ".jpg": true,
            ".png": true,
        }
        _, ok := allowFormat[fileFormat]
        fmt.Println(fileFormat)
        fmt.Println(ok)
        if ok == true {
            //3。合乎接管的格局 创立保留目录
            mkDirStatus := os.MkdirAll("./static/fileDir", 0777)

            if mkDirStatus != nil {
                c.String(400, "创立目录失败")
                return
            }

            //4。 生成文件名门路
            newFilePath := path.Join("./static/fileDir", file.Filename)

            //5. 保留文件
            c.SaveUploadedFile(file, newFilePath)

            c.String(200, "上传文件胜利😊")
        } else {
            c.String(400, "上传文件失败")
        }
    } else {
        c.String(400, "上传文件失败")
    }
}

小结

• 上传文件时，类型必须为 multipart/form-data
• c.FormFile(“file”) 获取单个文件
• c.MultipartForm() 获取多个文件 ， 多个文件的参数名必须是对立的 ，
• path.Join(‘门路’，文件名) 拼接文件门路
• c.SaveUploadedFile(file, dst) 保留文件，第一个参数为 file ， 第二个参数为文件门路
• path.Ext(file.Filename) 获取到文件后缀名
• os.MkdirAll(“创立文件的门路”，权限code) 创立文件

GORM

什么是ORM

什么是ORM ？O ： Object 对象Relationall: 关系Mapping： 映射

​相当于定义了一张  数据库表type Person struct { Id      int Name    string Age     int​}​​构造体实例  相当于 数据行student ：= Person{1,”小明”,28}

ORM 优缺点

长处：

• 进步开发效率

毛病：

• 就义执行性能
• 就义灵活性
• 弱化SQL 能力， 手写SQL 能升高

如何建Model

GoRM 默认模型

GORM内置了一个gorm.Model构造体。gorm.Model是一个蕴含了ID, CreatedAt, UpdatedAt, DeletedAt四个字段的Golang构造体。

// gorm.Model 定义
type Model struct {
  ID        uint `gorm:"primary_key"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt *time.Time
}

也能够继承到本人的构造体中

// 将 `ID`, `CreatedAt`, `UpdatedAt`, `DeletedAt`字段注入到`Student`模型中
type Student struct {
  gorm.Model
  Name string
  Age int
}

Model 定义

type User struct {
  gorm.Model
  Name         string
  Age          sql.NullInt64
  Birthday     *time.Time
  Email        string  `gorm:"type:varchar(100);unique_index"`
  Role         string  `gorm:"size:255"` // 设置字段大小为255
  MemberNumber *string `gorm:"unique;not null"` // 设置会员号（member number）惟一并且不为空
  Num          int     `gorm:"AUTO_INCREMENT"` // 设置 num 为自增类型
  Address      string  `gorm:"index:addr"` // 给address字段创立名为addr的索引
  IgnoreMe     int     `gorm:"-"` // 疏忽本字段
}

User 构造体的属性 Birthday 和 MemberNumber，应用指针，是有什么含意么？

默认所有字段的零值, 比方 0, ”, false 或者其它 零值，都不会保留到数据库内，应用指针能够防止这种状况。

构造体标记(tags)

构造体标记(tags)

应用构造体申明模型时，标记（tags）是可选项。
打标记的作用：

是对数据表的字段做润饰，例如（自增，主键，大小，类型，索引……..）

构造体标记

关联相干标记

主键. 表名. 列名约定

主键

GORM 默认会应用名为ID的字段作为表的主键。

type User struct {
  ID   string // 名为`ID`的字段会默认作为表的主键
  Name string
}

// 应用`StudentlID`作为主键
type Student struct {
  StudentID int64 `gorm:"primary_key"`
  Name     string
  Age      int64
}

表名

1. 表名默认是构造体名称的复数, 也能够勾销默认复数表名

type User struct {} // 默认表名是 `users`

// 将 User 的表名设置为 `user`
func (User) TableName() string {
  return "user"
}



// 禁用默认表名的复数模式，如果置为 true，则 `User` 的默认表名是 `user`
db.SingularTable(true)

2. 也能够通过Table()指定表名：

// 应用User构造体创立名为`student`的表
db.Table("student").CreateTable(&User{})

3. GORM还反对更改默认表名称规定：

gorm.DefaultTableNameHandler = func (db *gorm.DB, defaultTableName string) string  {
  return "prefix_" + defaultTableName;
}

"prefix_" 可任意名称

列名

列名由字段名称进行下划线宰割来生成 , 构造体字段为驼峰命名时，第二个单词会在后面以下划线显示 ，例如：
AddressInfo —> address_info

type User struct {
  ID        uint      // column name is `id`
  Name      string    // column name is `name`
  Birthday  time.Time // column name is `birthday`
  CreatedAt time.Time // column name is `created_at`
}

能够应用构造体Tag 指定列名

type Animal struct {
  AnimalId    int64     `gorm:"column:beast_id"`         // set column name to `beast_id`
  Birthday    time.Time `gorm:"column:day_of_the_beast"` // set column name to `day_of_the_beast`
  Age         int64     `gorm:"column:age_of_the_beast"` // set column name to `age_of_the_beast`
}

工夫戳跟踪

CreatedAt

如果模型有 CreatedAt字段，该字段的值将会是首次创立记录的工夫。

db.Create(&user) // `CreatedAt`将会是以后工夫 
// 能够应用`Update`办法来扭转`CreateAt`的值 
db.Model(&user).Update("CreatedAt", time.Now()) 

UpdatedAt

如果模型有UpdatedAt字段，该字段的值将会是每次更新记录的工夫。

db.Save(&user) // `UpdatedAt`将会是以后工夫 
db.Model(&user).Update("name", "jinzhu") 
// `UpdatedAt`将会是以后工夫 

DeletedAt

如果模型有DeletedAt字段，调用Delete删除该记录时，将会设置DeletedAt字段为以后工夫，而不是间接将记录从数据库中删除。

我的项目开发中