定义接口

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

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

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

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

  1. package routers
  3. import (
  4.     "github.com/gin-gonic/gin"
  6.     "gin-blog/routers/api/v1"
  7.     "gin-blog/pkg/setting"
  8. )
  10. func InitRouter() *gin.Engine {
  11.     ...
  12.     apiv1 := r.Group("/api/v1")
  13.     {
  14.         ...
  15.         //获取文章列表
  16.         apiv1.GET("/articles", v1.GetArticles)
  17.         //获取指定文章
  18.         apiv1.GET("/articles/:id", v1.GetArticle)
  19.         //新建文章
  20.         apiv1.POST("/articles", v1.AddArticle)
  21.         //更新指定文章
  22.         apiv1.PUT("/articles/:id", v1.EditArticle)
  23.         //删除指定文章
  24.         apiv1.DELETE("/articles/:id", v1.DeleteArticle)
  25.     }
  27.     return r
  28. }

当前目录结构：

  1. gin-blog/
  2. ├── conf
  3. │   └── app.ini
  4. ├── main.go
  5. ├── middleware
  6. ├── models
  7. │   ├── models.go
  8. │   └── tag.go
  9. ├── pkg
  10. │   ├── e
  11. │   │   ├── code.go
  12. │   │   └── msg.go
  13. │   ├── setting
  14. │   │   └── setting.go
  15. │   └── util
  16. │       └── pagination.go
  17. ├── routers
  18. │   ├── api
  19. │   │   └── v1
  20. │   │       ├── article.go
  21. │   │       └── tag.go
  22. │   └── router.go
  23. ├── runtime

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

编写models逻辑

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

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

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

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

  1. package models
  3. import (
  4.     "time"
  6.     "github.com/jinzhu/gorm"
  7. )
  9. type Article struct {
  10.     Model
  12.     TagID int `json:"tag_id" gorm:"index"`
  13.     Tag   Tag `json:"tag"`
  15.     Title string `json:"title"`
  16.     Desc string `json:"desc"`
  17.     Content string `json:"content"`
  18.     CreatedBy string `json:"created_by"`
  19.     ModifiedBy string `json:"modified_by"`
  20.     State int `json:"state"`
  21. }
  24. func ExistArticleByID(id int) bool {
  25.     var article Article
  26.     db.Select("id").Where("id = ?", id).First(&article)
  28.     if article.ID > 0 {
  29.         return true
  30.     }
  32.     return false
  33. }
  35. func GetArticleTotal(maps interface {}) (count int){
  36.     db.Model(&Article{}).Where(maps).Count(&count)
  38.     return
  39. }
  41. func GetArticles(pageNum int, pageSize int, maps interface {}) (articles []Article) {
  42.     db.Preload("Tag").Where(maps).Offset(pageNum).Limit(pageSize).Find(&articles)
  44.     return
  45. }
  47. func GetArticle(id int) (article Article) {
  48.     db.Where("id = ?", id).First(&article)
  49.     db.Model(&article).Related(&article.Tag)
  51.     return 
  52. }
  54. func EditArticle(id int, data interface {}) bool {
  55.     db.Model(&Article{}).Where("id = ?", id).Updates(data)
  57.     return true
  58. }
  60. func AddArticle(data map[string]interface {}) bool {
  61.     db.Create(&Article {
  62.         TagID : data["tag_id"].(int),
  63.         Title : data["title"].(string),
  64.         Desc : data["desc"].(string),
  65.         Content : data["content"].(string),
  66.         CreatedBy : data["created_by"].(string),
  67.         State : data["state"].(int),
  68.     })
  70.     return true
  71. }
  73. func DeleteArticle(id int) bool {
  74.     db.Where("id = ?", id).Delete(Article{})
  75.     return true
  76. }
  79.     scope.SetColumn("CreatedOn", time.Now().Unix())
  81.     return nil
  82. }
  84. func (article *Article) BeforeUpdate(scope *gorm.Scope) error {
  85.     scope.SetColumn("ModifiedOn", time.Now().Unix())
  87.     return nil
  88. }

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

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

  1. func GetArticle(id int) (article Article) {
  2.     db.Where("id = ?", id).First(&article)
  3.     db.Model(&article).Related(&article.Tag)
  5.     return 
  6. }

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

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

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

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

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

  • gorm的Join
  • 循环Related

3、 v.(I) 是什么？

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

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

  1. package v1
  3. import (
  4.     "net/http"
  5.     "log"
  7.     "github.com/gin-gonic/gin"
  8.     "github.com/astaxie/beego/validation"
  9.     "github.com/Unknwon/com"
  11.     "gin-blog/models"
  12.     "gin-blog/pkg/e"
  13.     "gin-blog/pkg/setting"
  14.     "gin-blog/pkg/util"
  15. )
  17. //获取单个文章
  18. func GetArticle(c *gin.Context) {
  19.     id := com.StrTo(c.Param("id")).MustInt()
  21.     valid := validation.Validation{}
  22.     valid.Min(id, 1, "id").Message("ID必须大于0")
  24.     code := e.INVALID_PARAMS
  25.     var data interface {}
  26.     if ! valid.HasErrors() {
  27.         if models.ExistArticleByID(id) {
  28.             data = models.GetArticle(id)
  29.             code = e.SUCCESS
  30.         } else {
  31.             code = e.ERROR_NOT_EXIST_ARTICLE
  32.         }
  33.     } else {
  34.         for _, err := range valid.Errors {
  35.             logging.Info(err.Key, err.Message)
  36.         }
  37.     }
  39.     c.JSON(http.StatusOK, gin.H{
  40.         "code" : code,
  41.         "msg" : e.GetMsg(code),
  42.         "data" : data,
  43.     })
  44. }
  46. //获取多个文章
  47. func GetArticles(c *gin.Context) {
  48.     data := make(map[string]interface{})
  49.     maps := make(map[string]interface{})
  50.     valid := validation.Validation{}
  52.     var state int = -1
  53.     if arg := c.Query("state"); arg != "" {
  54.         state = com.StrTo(arg).MustInt()
  55.         maps["state"] = state
  57.         valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
  58.     }
  60.     var tagId int = -1
  61.     if arg := c.Query("tag_id"); arg != "" {
  62.         tagId = com.StrTo(arg).MustInt()
  63.         maps["tag_id"] = tagId
  65.         valid.Min(tagId, 1, "tag_id").Message("标签ID必须大于0")
  66.     } 
  68.     code := e.INVALID_PARAMS
  69.     if ! valid.HasErrors() {
  70.         code = e.SUCCESS
  72.         data["lists"] = models.GetArticles(util.GetPage(c), setting.PageSize, maps)
  73.         data["total"] = models.GetArticleTotal(maps)
  75.     } else {
  76.         for _, err := range valid.Errors {
  77.             logging.Info(err.Key, err.Message)
  78.         }
  79.     }
  81.     c.JSON(http.StatusOK, gin.H{
  82.         "code" : code,
  83.         "msg" : e.GetMsg(code),
  84.         "data" : data,
  85.     })
  86. }
  88. //新增文章
  89. func AddArticle(c *gin.Context) {
  90.     tagId := com.StrTo(c.Query("tag_id")).MustInt()
  91.     title := c.Query("title")
  92.     desc := c.Query("desc")
  93.     content := c.Query("content")
  94.     createdBy := c.Query("created_by")
  95.     state := com.StrTo(c.DefaultQuery("state", "0")).MustInt()
  97.     valid := validation.Validation{}
  98.     valid.Min(tagId, 1, "tag_id").Message("标签ID必须大于0")
  99.     valid.Required(title, "title").Message("标题不能为空")
  100.     valid.Required(desc, "desc").Message("简述不能为空")
  101.     valid.Required(content, "content").Message("内容不能为空")
  102.     valid.Required(createdBy, "created_by").Message("创建人不能为空")
  103.     valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
  105.     code := e.INVALID_PARAMS
  106.     if ! valid.HasErrors() {
  107.         if models.ExistTagByID(tagId) {
  108.             data := make(map[string]interface {})
  109.             data["tag_id"] = tagId
  110.             data["title"] = title
  111.             data["desc"] = desc
  112.             data["content"] = content
  113.             data["created_by"] = createdBy
  114.             data["state"] = state
  116.             code = e.SUCCESS
  117.         } else {
  118.             code = e.ERROR_NOT_EXIST_TAG
  119.         }
  120.     } else {
  121.         for _, err := range valid.Errors {
  122.             logging.Info(err.Key, err.Message)
  123.         }
  124.     }
  126.     c.JSON(http.StatusOK, gin.H{
  127.         "code" : code,
  128.         "msg" : e.GetMsg(code),
  129.         "data" : make(map[string]interface{}),
  130.     })
  131. }
  133. //修改文章
  134. func EditArticle(c *gin.Context) {
  135.     valid := validation.Validation{}
  137.     id := com.StrTo(c.Param("id")).MustInt()
  138.     tagId := com.StrTo(c.Query("tag_id")).MustInt()
  139.     title := c.Query("title")
  140.     desc := c.Query("desc")
  141.     content := c.Query("content")
  142.     modifiedBy := c.Query("modified_by")
  144.     var state int = -1
  145.     if arg := c.Query("state"); arg != "" {
  146.         state = com.StrTo(arg).MustInt()
  147.         valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
  148.     }
  150.     valid.Min(id, 1, "id").Message("ID必须大于0")
  151.     valid.MaxSize(title, 100, "title").Message("标题最长为100字符")
  152.     valid.MaxSize(desc, 255, "desc").Message("简述最长为255字符")
  153.     valid.MaxSize(content, 65535, "content").Message("内容最长为65535字符")
  154.     valid.Required(modifiedBy, "modified_by").Message("修改人不能为空")
  155.     valid.MaxSize(modifiedBy, 100, "modified_by").Message("修改人最长为100字符")
  157.     code := e.INVALID_PARAMS
  158.     if ! valid.HasErrors() {
  159.         if models.ExistArticleByID(id) {
  160.             if models.ExistTagByID(tagId) {
  161.                 data := make(map[string]interface {})
  162.                 if tagId > 0 {
  163.                     data["tag_id"] = tagId
  164.                 }
  165.                 if title != "" {
  166.                     data["title"] = title
  167.                 }
  168.                 if desc != "" {
  169.                     data["desc"] = desc
  170.                 }
  171.                 if content != "" {
  172.                     data["content"] = content
  173.                 }
  175.                 data["modified_by"] = modifiedBy
  177.                 models.EditArticle(id, data)
  178.                 code = e.SUCCESS
  179.             } else {
  180.                 code = e.ERROR_NOT_EXIST_TAG
  181.             }
  182.         } else {
  183.             code = e.ERROR_NOT_EXIST_ARTICLE
  184.         }
  185.     } else {
  186.         for _, err := range valid.Errors {
  187.             logging.Info(err.Key, err.Message)
  188.         }
  189.     }
  191.     c.JSON(http.StatusOK, gin.H{
  192.         "code" : code,
  193.         "msg" : e.GetMsg(code),
  194.         "data" : make(map[string]string),
  195.     })
  196. }
  198. //删除文章
  199. func DeleteArticle(c *gin.Context) {
  200.     id := com.StrTo(c.Param("id")).MustInt()
  202.     valid := validation.Validation{}
  203.     valid.Min(id, 1, "id").Message("ID必须大于0")
  205.     code := e.INVALID_PARAMS
  206.     if ! valid.HasErrors() {
  207.         if models.ExistArticleByID(id) {
  208.             models.DeleteArticle(id)
  209.             code = e.SUCCESS
  210.         } else {
  211.             code = e.ERROR_NOT_EXIST_ARTICLE
  212.         }
  213.     } else {
  214.         for _, err := range valid.Errors {
  215.             logging.Info(err.Key, err.Message)
  216.         }
  217.     }
  219.     c.JSON(http.StatusOK, gin.H{
  220.         "code" : code,
  221.         "msg" : e.GetMsg(code),
  222.         "data" : make(map[string]string),
  223.     })
  224. }

当前目录结构：

  1. gin-blog/
  2. ├── conf
  3. │   └── app.ini
  4. ├── main.go
  5. ├── middleware
  6. ├── models
  7. │   ├── article.go
  8. │   ├── models.go
  9. │   └── tag.go
  10. ├── pkg
  11. │   ├── e
  12. │   │   ├── code.go
  13. │   │   └── msg.go
  14. │   ├── setting
  15. │   │   └── setting.go
  16. │   └── util
  17. │       └── pagination.go
  18. ├── routers
  19. │   ├── api
  20. │   │   └── v1
  21. │   │       ├── article.go
  22. │   │       └── tag.go
  23. │   └── router.go
  24. ├── runtime

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

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

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

参考