Gin实践 连载四 搭建Blog API's（三）

大佬教程收集整理的这篇文章主要介绍了Gin实践 连载四 搭建Blog API's（三），大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

编写Article的API's、Models

项目地址：https://github.com/EDDYCJY/go...

定义接口

本节编写文章的逻辑，我们定义一下接口吧！

• 获取文章列表：GET("/articles")
• 获取指定文章：POST("/articles/:id")
• 新建文章：POST("/articles")
• 更新指定文章：PUT("/articles/:id")
• 删除指定文章：deletE("/articles/:id")

编写路由逻辑

在routers的v1版本下，新建article.go文件，写入内容：

package v1

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

//获取单个文章
func GetArticle(c *gin.Context) {
}

//获取多个文章
func GetArticles(c *gin.Context) {
}

//新增文章
func AddArticle(c *gin.Context) {
}

//修改文章
func EditArticle(c *gin.Context) {
}

//删除文章
func deleteArticle(c *gin.Context) {
}

我们打开routers下的router.go文件，修改文件内容为：

package routers

import (
    "github.com/gin-gonic/gin"
    
    "gin-blog/routers/api/v1"
    "gin-blog/pkg/setTing"
)

func InitRouter() *gin.ENGIne {
    ...
    apiv1 := r.Group("/api/v1")
    {
        ...
        //获取文章列表
        apiv1.GET("/articles",v1.GetArticles)
        //获取指定文章
        apiv1.GET("/articles/:id",v1.GetArticlE)
        //新建文章
        apiv1.POST("/articles",v1.AddArticlE)
        //更新指定文章
        apiv1.PUT("/articles/:id",v1.EditArticlE)
        //删除指定文章
        apiv1.deletE("/articles/:id",v1.deleteArticlE)
    }

    return r
}

当前目录结构：

gin-blog/
├── conf
│ └── app.ini
├── main.go
├── middleware
├── models
│ ├── models.go
│ └── tag.go
├── pkg
│ ├── e
│ │ ├── code.go
│ │ └── msg.go
│ ├── setTing
│ │ └── setTing.go
│ └── util
│     └── pagination.go
├── routers
│ ├── api
│ │ └── v1
│ │     ├── article.go
│ │     └── tag.go
│ └── router.go
├── runtime

在基础的路由规则配置结束后，我们开始编写我们的接口吧！

编写models逻辑

创建@H_93_23@models目录下的article.go，写入文件内容：

package models

import (
    "github.com/jinzhu/gorm"

    "time"
)

type Article struct {
    Model

    TagID int `json:"tag_id" gorm:"index"`
    Tag   Tag `json:"tag"`

    title String `json:"title"`
    Desc String `json:"desc"`
    Content String `json:"content"`
    createdby String `json:"created_by"`
    ModifiedBy String `json:"modified_by"`
    StatE int `json:"state"`
}


func (article *ArticlE) BeforeCreate(scope *gorm.ScopE) error {
    scope.Setcolumn("CreatedOn",time.Now().Unix())

    return nil
}

func (article *ArticlE) Beforeupdate(scope *gorm.ScopE) error {
    scope.Setcolumn("ModifiedOn",time.Now().Unix())

    return nil
}

我们创建了一个Article struct {}，与Tag不同的是，Article多了几项

1. gorm:index，用于声明这个字段为索引，如果你使用了自动迁移功能则会有所影响，在不使用则无影响
2. Tag字段，实际是一个嵌套的struct，它利用TagID与Tag模型相互关联，在执行查询的时候，能够达到Article、Tag关联查询的功能
3. time.Now().Unix() 返回当前的时间戳

接下来，请确保已对上一章节的内容通读且了解，由于逻辑偏差不会太远，我们本节直接编写这五个接口

打开@H_93_23@models目录下的article.go，修改文件内容：

package models

import (
    "time"

    "github.com/jinzhu/gorm"
)

type Article struct {
    Model

    TagID int `json:"tag_id" gorm:"index"`
    Tag   Tag `json:"tag"`

    title String `json:"title"`
    Desc String `json:"desc"`
    Content String `json:"content"`
    createdby String `json:"created_by"`
    ModifiedBy String `json:"modified_by"`
    StatE int `json:"state"`
}


func ExistArticleByID(id int) bool {
    var article Article
    db.SELEct("id").Where("id = ?",id).First(&articlE)

    if article.ID > 0 {
        return true
    }

    return false
}

func GetArticle@R_708_10586@l(maps interface {}) (count int){
    db.Model(&Article{}).Where(maps).Count(&count)

    return
}

func GetArticles(pageNum int,pageSizE int,maps interface {}) (articles []ArticlE) {
    db.Preload("Tag").Where(maps).offset(pageNum).Limit(pageSizE).Find(&articles)

    return
}

func GetArticle(id int) (article ArticlE) {
    db.Where("id = ?",id).First(&articlE)
    db.Model(&articlE).Related(&article.Tag)

    return 
}

func EditArticle(id int,data interface {}) bool {
    db.Model(&Article{}).Where("id = ?",id).updates(data)

    return true
}

func AddArticle(data map[String]interface {}) bool {
    db.Create(&Article {
        TagID : data["tag_id"].(int),title : data["title"].(String),Desc : data["desc"].(String),Content : data["content"].(String),createdby : data["created_by"].(String),State : data["state"].(int),})

    return true
}

func deleteArticle(id int) bool {
    db.Where("id = ?",id).delete(Article{})

    return true
}

func (article *ArticlE) BeforeCreate(scope *gorm.ScopE) error {
    scope.Setcolumn("CreatedOn",time.Now().Unix())

    return nil
}

在这里，我们拿出三点不同来讲

1、 我们的Article是如何关联到Tag？？？

func GetArticle(id int) (article ArticlE) {
    db.Where("id = ?",id).First(&articlE)
    db.Model(&articlE).Related(&article.Tag)

    return 
}

能够达到关联，首先是gorm本身做了大量的约定俗成

• Article有一个结构体成员是TagID，就是外键。gorm会通过类名+ID的方式去找到这两个类之间的关联关系
• Article有一个结构体成员是Tag，就是我们嵌套在Article里的Tag结构体，我们可以通过Related进行关联查询

2、 Preload是什么东西，为什么查询可以得出每一项的关联Tag？

func GetArticles(pageNum int,maps interface {}) (articles []ArticlE) {
    db.Preload("Tag").Where(maps).offset(pageNum).Limit(pageSizE).Find(&articles)

    return
}

Preload就是一个预加载器，它会执行两条sql，分别是SELECT * FROM blog_articles;和SELECT * FROM blog_tag WHERE id IN (1,2,3,4);，那么在查询出结构后，gorm内部处理对应的映射逻辑，将其填充到Article的Tag中，会特别方便，并且避免了循环查询

那么有没有别的办法呢，大致是两种

• gorm的Join
• 循环Related

综合之下，还是Preload更好，如果你有更优的方案，欢迎说一下 :)

3、 v.(I) 是什么？

v表示一个接口值，I表示接口类型。这个实际就是Golang中的类型断言，用于判断一个接口值的实际类型是否为某个类型，或一个非接口值的类型是否实现了某个接口类型

打开routers目录下v1版本的article.go文件，修改文件内容：

package v1

import (
    "net/@R_618_10107@"
    "log"

    "github.com/gin-gonic/gin"
    "github.com/astaxie/beego/validation"
    "github.com/Unknwon/com"

    "gin-blog/models"
    "gin-blog/pkg/e"
    "gin-blog/pkg/setTing"
    "gin-blog/pkg/util"
)

//获取单个文章
func GetArticle(c *gin.Context) {
    id := com.StrTo(c.Param("id")).MusTint()

    valid := validation.Validation{}
    valid.Min(id,1,"id").message("ID必须大于0")

    code := e.INVALID_PARAMS
    var data interface {}
    if ! valid.HasErrors() {
        if models.ExistArticleByID(id) {
            data = models.GetArticle(id)
            code = e.succesS
        } else {
            code = e.ERROR_NOT_EXIST_ARTICLE
        }
    } else {
        for _,err := range valid.Errors {
            logging.Info(err.Key,err.messagE)
        }
    }

    c.JSON(@R_618_10107@.StatusOK,gin.H{
        "code" : code,"msg" : e.Getmsg(codE),"data" : data,})
}

//获取多个文章
func GetArticles(c *gin.Context) {
    data := make(map[String]interface{})
    maps := make(map[String]interface{})
    valid := validation.Validation{}

    var statE int = -1
    if arg := c.Query("state"); arg != "" {
        state = com.StrTo(arg).MusTint()
        maps["state"] = state

        valid.Range(state,"state").message("状态只允许0或1")
    }

    var tagId int = -1
    if arg := c.Query("tag_id"); arg != "" {
        tagId = com.StrTo(arg).MusTint()
        maps["tag_id"] = tagId

        valid.Min(tagId,"tag_id").message("标签ID必须大于0")
    } 

    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        code = e.succesS

        data["lists"] = models.GetArticles(util.GetPage(C),setTing.PageSize,maps)
        data["@R_708_10586@l"] = models.GetArticle@R_708_10586@l(maps)

    } else {
        for _,})
}

//新增文章
func AddArticle(c *gin.Context) {
    tagId := com.StrTo(c.Query("tag_id")).MusTint()
    title := c.Query("title")
    desc := c.Query("desc")
    content := c.Query("content")
    createdby := c.Query("created_by")
    state := com.StrTo(c.DefaultQuery("state","0")).MusTint()

    valid := validation.Validation{}
    valid.Min(tagId,"tag_id").message("标签ID必须大于0")
    valid.required(title,"title").message("标题不能为空")
    valid.required(desc,"desc").message("简述不能为空")
    valid.required(content,"content").message("内容不能为空")
    valid.required(createdby,"created_by").message("创建人不能为空")
    valid.Range(state,"state").message("状态只允许0或1")

    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        if models.ExistTagByID(tagId) {
            data := make(map[String]interface {})
            data["tag_id"] = tagId
            data["title"] = title
            data["desc"] = desc
            data["content"] = content
            data["created_by"] = createdby
            data["state"] = state
            
            models.AddArticle(data)
            code = e.succesS
        } else {
            code = e.ERROR_NOT_EXIST_TAG
        }
    } else {
        for _,"data" : make(map[String]interface{}),})
}

//修改文章
func EditArticle(c *gin.Context) {
    valid := validation.Validation{}

    id := com.StrTo(c.Param("id")).MusTint()
    tagId := com.StrTo(c.Query("tag_id")).MusTint()
    title := c.Query("title")
    desc := c.Query("desc")
    content := c.Query("content")
    modifiedBy := c.Query("modified_by")

    var statE int = -1
    if arg := c.Query("state"); arg != "" {
        state = com.StrTo(arg).MusTint()
        valid.Range(state,"state").message("状态只允许0或1")
    }

    valid.Min(id,"id").message("ID必须大于0")
    valid.MaxSize(title,100,"title").message("标题最长为100字符")
    valid.MaxSize(desc,255,"desc").message("简述最长为255字符")
    valid.MaxSize(content,65535,"content").message("内容最长为65535字符")
    valid.required(modifiedBy,"modified_by").message("修改人不能为空")
    valid.MaxSize(modifiedBy,"modified_by").message("修改人最长为100字符")

    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        if models.ExistArticleByID(id) {
            if models.ExistTagByID(tagId) {
                data := make(map[String]interface {})
                if tagId > 0 {
                    data["tag_id"] = tagId
                }
                if title != "" {
                    data["title"] = title
                }
                if Desc != "" {
                    data["desc"] = desc
                }
                if content != "" {
                    data["content"] = content
                }

                data["modified_by"] = modifiedBy

                models.EditArticle(id,data)
                code = e.succesS
            } else {
                code = e.ERROR_NOT_EXIST_TAG
            }
        } else {
            code = e.ERROR_NOT_EXIST_ARTICLE
        }
    } else {
        for _,"data" : make(map[String]String),})
}

//删除文章
func deleteArticle(c *gin.Context) {
    id := com.StrTo(c.Param("id")).MusTint()

    valid := validation.Validation{}
    valid.Min(id,"id").message("ID必须大于0")

    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        if models.ExistArticleByID(id) {
            models.deleteArticle(id)
            code = e.succesS
        } else {
            code = e.ERROR_NOT_EXIST_ARTICLE
        }
    } else {
        for _,})
}

当前目录结构：

gin-blog/
├── conf
│ └── app.ini
├── main.go
├── middleware
├── models
│ ├── article.go
│ ├── models.go
│ └── tag.go
├── pkg
│ ├── e
│ │ ├── code.go
│ │ └── msg.go
│ ├── setTing
│ │ └── setTing.go
│ └── util
│     └── pagination.go
├── routers
│ ├── api
│ │ └── v1
│ │     ├── article.go
│ │     └── tag.go
│ └── router.go
├── runtime

验证功能

我们重启服务，执行go run main.go，检查控制台输出结果

$ go run main.go 
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:    export GIN_MODE=release
 - using code:    gin.SetMode(gin.ReleaseModE)

[GIN-debug] GET    /api/v1/tags              --> gin-blog/routers/api/v1.GetTags (3 handlers)
[GIN-debug] POST   /api/v1/tags              --> gin-blog/routers/api/v1.AddTag (3 handlers)
[GIN-debug] PUT    /api/v1/tags/:id          --> gin-blog/routers/api/v1.EditTag (3 handlers)
[GIN-debug] deletE /api/v1/tags/:id          --> gin-blog/routers/api/v1.deleteTag (3 handlers)
[GIN-debug] GET    /api/v1/articles          --> gin-blog/routers/api/v1.GetArticles (3 handlers)
[GIN-debug] GET    /api/v1/articles/:id      --> gin-blog/routers/api/v1.GetArticle (3 handlers)
[GIN-debug] POST   /api/v1/articles          --> gin-blog/routers/api/v1.AddArticle (3 handlers)
[GIN-debug] PUT    /api/v1/articles/:id      --> gin-blog/routers/api/v1.EditArticle (3 handlers)
[GIN-debug] deletE /api/v1/articles/:id      --> gin-blog/routers/api/v1.deleteArticle (3 handlers)

使用Postman检验接口是否正常（大家可以选用合适的参数传递方式，@R_505_6077@展示我选用了URL传参），

• POST：http://127.0.0.1:8000/api/v1/articles?tag_id=1&title=test1&desc=test-desc&content=test-content&created_by=test-created&state=1
• GET：http://127.0.0.1:8000/api/v1/articles
• GET：http://127.0.0.1:8000/api/v1/articles/1
• PUT：http://127.0.0.1:8000/api/v1/articles/1?tag_id=1&title=test-edit1&desc=test-desc-edit&content=test-content-edit&modified_by=test-created-edit&state=0
• deletE：http://127.0.0.1:8000/api/v1/articles/1

至此，我们的API's编写就到这里，下一节我们将介绍另外的一些技巧！

参考

本系列示例代码

• go-gin-example

本系列目录

• 连载一 Golang介绍与环境安装
• 连载二 搭建Blog API's（一）
• 连载三 搭建Blog API's（二）
• 连载四 搭建Blog API's（三）
• 连载五 使用JWT进行身份校验
• 连载六 编写一个简单的文件日志
• @L_262_105@
• 连载八 为它加上Swagger
• 连载九 将Golang应用部署到Docker
• 连载十 定制 GORM Callbacks
• 连载十一 Cron定时任务
• 连载十二 优化配置结构及实现图片上传
• 连载十三 优化你的应用结构和实现Redis缓存
• 连载十四 实现导出、导入 Excel
• 连载十五 生成二维码、合并海报
• 连载十六 在图片上绘制文字
• 连载十七 用 Nginx 部署 Go 应用
• 番外 Golang交叉编译
• 番外 请入门 Makefile

大佬总结

以上是大佬教程为你收集整理的Gin实践 连载四 搭建Blog API's（三）全部内容，希望文章能够帮你解决Gin实践 连载四 搭建Blog API's（三）所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。