• 编写Article的API’s、Models
  • 定义接口
  • 编写路由逻辑
  • 编写models逻辑
  • 验证功能
  • 参考
    • 本系列示例代码

    编写Article的API’s、Models

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

    定义接口

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

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

    编写路由逻辑

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

    1. package v1
    3. import (
    4.     "github.com/gin-gonic/gin"
    5. )
    7. //获取单个文章
    8. func GetArticle(c *gin.Context) {
    9. }
    11. //获取多个文章
    12. func GetArticles(c *gin.Context) {
    13. }
    15. //新增文章
    16. func AddArticle(c *gin.Context) {
    17. }
    19. //修改文章
    20. func EditArticle(c *gin.Context) {
    21. }
    23. //删除文章
    24. func DeleteArticle(c *gin.Context) {
    25. }

    我们打开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，写入文件内容：

    1. package models
    3. import (
    4.     "github.com/jinzhu/gorm"
    6.     "time"
    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 (article *Article) BeforeCreate(scope *gorm.Scope) error {
    25.     scope.SetColumn("CreatedOn", time.Now().Unix())
    27.     return nil
    28. }
    30. func (article *Article) BeforeUpdate(scope *gorm.Scope) error {
    31.     scope.SetColumn("ModifiedOn", time.Now().Unix())
    33.     return nil
    34. }

    我们创建了一个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{})
    76.     return true
    77. }
    79. func (article *Article) BeforeCreate(scope *gorm.Scope) error {
    80.     scope.SetColumn("CreatedOn", time.Now().Unix())
    82.     return nil
    83. }
    85. func (article *Article) BeforeUpdate(scope *gorm.Scope) error {
    86.     scope.SetColumn("ModifiedOn", time.Now().Unix())
    88.     return nil
    89. }

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

    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？

    1. func GetArticles(pageNum int, pageSize int, maps interface {}) (articles []Article) {
    2.     db.Preload("Tag").Where(maps).Offset(pageNum).Limit(pageSize).Find(&articles)
    4.     return
    5. }

    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文件，修改文件内容：

    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.             models.AddArticle(data)
    117.             code = e.SUCCESS
    118.         } else {
    119.             code = e.ERROR_NOT_EXIST_TAG
    120.         }
    121.     } else {
    122.         for _, err := range valid.Errors {
    123.             logging.Info(err.Key, err.Message)
    124.         }
    125.     }
    127.     c.JSON(http.StatusOK, gin.H{
    128.         "code" : code,
    129.         "msg" : e.GetMsg(code),
    130.         "data" : make(map[string]interface{}),
    131.     })
    132. }
    134. //修改文章
    135. func EditArticle(c *gin.Context) {
    136.     valid := validation.Validation{}
    138.     id := com.StrTo(c.Param("id")).MustInt()
    139.     tagId := com.StrTo(c.Query("tag_id")).MustInt()
    140.     title := c.Query("title")
    141.     desc := c.Query("desc")
    142.     content := c.Query("content")
    143.     modifiedBy := c.Query("modified_by")
    145.     var state int = -1
    146.     if arg := c.Query("state"); arg != "" {
    147.         state = com.StrTo(arg).MustInt()
    148.         valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
    149.     }
    151.     valid.Min(id, 1, "id").Message("ID必须大于0")
    152.     valid.MaxSize(title, 100, "title").Message("标题最长为100字符")
    153.     valid.MaxSize(desc, 255, "desc").Message("简述最长为255字符")
    154.     valid.MaxSize(content, 65535, "content").Message("内容最长为65535字符")
    155.     valid.Required(modifiedBy, "modified_by").Message("修改人不能为空")
    156.     valid.MaxSize(modifiedBy, 100, "modified_by").Message("修改人最长为100字符")
    158.     code := e.INVALID_PARAMS
    159.     if ! valid.HasErrors() {
    160.         if models.ExistArticleByID(id) {
    161.             if models.ExistTagByID(tagId) {
    162.                 data := make(map[string]interface {})
    163.                 if tagId > 0 {
    164.                     data["tag_id"] = tagId
    165.                 }
    166.                 if title != "" {
    167.                     data["title"] = title
    168.                 }
    169.                 if desc != "" {
    170.                     data["desc"] = desc
    171.                 }
    172.                 if content != "" {
    173.                     data["content"] = content
    174.                 }
    176.                 data["modified_by"] = modifiedBy
    178.                 models.EditArticle(id, data)
    179.                 code = e.SUCCESS
    180.             } else {
    181.                 code = e.ERROR_NOT_EXIST_TAG
    182.             }
    183.         } else {
    184.             code = e.ERROR_NOT_EXIST_ARTICLE
    185.         }
    186.     } else {
    187.         for _, err := range valid.Errors {
    188.             logging.Info(err.Key, err.Message)
    189.         }
    190.     }
    192.     c.JSON(http.StatusOK, gin.H{
    193.         "code" : code,
    194.         "msg" : e.GetMsg(code),
    195.         "data" : make(map[string]string),
    196.     })
    197. }
    199. //删除文章
    200. func DeleteArticle(c *gin.Context) {
    201.     id := com.StrTo(c.Param("id")).MustInt()
    203.     valid := validation.Validation{}
    204.     valid.Min(id, 1, "id").Message("ID必须大于0")
    206.     code := e.INVALID_PARAMS
    207.     if ! valid.HasErrors() {
    208.         if models.ExistArticleByID(id) {
    209.             models.DeleteArticle(id)
    210.             code = e.SUCCESS
    211.         } else {
    212.             code = e.ERROR_NOT_EXIST_ARTICLE
    213.         }
    214.     } else {
    215.         for _, err := range valid.Errors {
    216.             logging.Info(err.Key, err.Message)
    217.         }
    218.     }
    220.     c.JSON(http.StatusOK, gin.H{
    221.         "code" : code,
    222.         "msg" : e.GetMsg(code),
    223.         "data" : make(map[string]string),
    224.     })
    225. }

    当前目录结构：

    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，检查控制台输出结果

    1. $ go run main.go 
    2. [GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
    3.  - using env:    export GIN_MODE=release
    4.  - using code:    gin.SetMode(gin.ReleaseMode)
    6. [GIN-debug] GET    /api/v1/tags              --> gin-blog/routers/api/v1.GetTags (3 handlers)
    7. [GIN-debug] POST   /api/v1/tags              --> gin-blog/routers/api/v1.AddTag (3 handlers)
    8. [GIN-debug] PUT    /api/v1/tags/:id          --> gin-blog/routers/api/v1.EditTag (3 handlers)
    9. [GIN-debug] DELETE /api/v1/tags/:id          --> gin-blog/routers/api/v1.DeleteTag (3 handlers)
    10. [GIN-debug] GET    /api/v1/articles          --> gin-blog/routers/api/v1.GetArticles (3 handlers)
    11. [GIN-debug] GET    /api/v1/articles/:id      --> gin-blog/routers/api/v1.GetArticle (3 handlers)
    12. [GIN-debug] POST   /api/v1/articles          --> gin-blog/routers/api/v1.AddArticle (3 handlers)
    13. [GIN-debug] PUT    /api/v1/articles/:id      --> gin-blog/routers/api/v1.EditArticle (3 handlers)
    14. [GIN-debug] DELETE /api/v1/articles/:id      --> gin-blog/routers/api/v1.DeleteArticle (3 handlers)

    使用Postman检验接口是否正常（大家可以选用合适的参数传递方式，此处为了方便展示我选用了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