• Golang实现小型CMS内容管理功能（一）：Gin框架搭配Gorm实现增删查改功能

    我自己开发了一款在线客服系统，最近一直琢磨把客服系统官网做好。因为访客来的人不少，大部分人可能就是看看官网界面就走了，怎样把这些访客留存下来，去测试试用客服系统，是我一直琢磨的问题。

    官网是一个企业的门面，也是一个系统的门面，还是需要把门面的内容整理总结一下，让大家能清楚看到系统的功能。网站的内容少，那么搜索引擎收录的就少，这样会导致网站的权重不高，搜索排名比较低。

    因此要简单的加上一个小型的内容管理功能。

    大家感兴趣也可以去看看唯一客服系统

    设计数据库

    很简单的两张表，分类表和内容表

    1. DROP TABLE IF EXISTS `cms_cate`;
    2. CREATE TABLE `cms_cate` (
    3.  `id` int(11) NOT NULL AUTO_INCREMENT,
    4.  `cat_name` varchar(50) NOT NULL DEFAULT '' COMMENT '分类名称',
    5.  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP  COMMENT '创建时间',
    6.  PRIMARY KEY (`id`) COMMENT '自增主键索引'
    7. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT 'CMS分类表';
    8. DROP TABLE IF EXISTS `cms_news`;
    9. CREATE TABLE `cms_news` (
    10.  `id` int(11) NOT NULL AUTO_INCREMENT,
    11.  `title` varchar(500) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '标题',
    12.  `content` text COLLATE utf8mb4_general_ci COMMENT '内容',
    13.  `cat_id` int(11) NOT NULL DEFAULT '0' COMMENT '分类ID',
    14.  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP  COMMENT '创建时间',
    15.  PRIMARY KEY (`id`) COMMENT '自增主键索引'
    16. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT 'CMS内容表';

    编写数据库操作gorm Model部分

    设计两个结构体

    1. type CmsCate struct {
    2.     Id        uint       `json:"id"`
    3.     CatName   string     `json:"cat_name"`
    4.     CreatedAt types.Time `json:"created_at"`
    5. }
    6. type CmsNews struct {
    7.     Id        uint       `json:"id"`
    8.     Title     string     `json:"title"`
    9.     Content   string     `json:"content"`
    10.     CreatedAt types.Time `json:"created_at"`
    11. }

    types.Time类型是我对time.Time类型的包装，用于在序列化为json的时候，可以格式化时间。

    默认的Time类型，JSON序列化出来后是UTC格式，不符合观看习惯

    1. package types
    2.  
    3. import (
    4.     "database/sql/driver"
    5.     "fmt"
    6.     "time"
    7. )
    8.  
    9. type Time struct {
    10.     time.Time
    11. }
    12.  
    13. func (t Time) MarshalJSON() ([]byte, error) {
    14.     localTime := t.Format("2006-01-02 15:04:05")
    15.     return []byte(fmt.Sprintf(`"%s"`, localTime)), nil
    16. }
    17. func (t Time) Value() (driver.Value, error) {
    18.     var zeroTime time.Time
    19.     if t.Time.UnixNano() == zeroTime.UnixNano() {
    20.         return nil, nil
    21.     }
    22.     return t.Time, nil
    23. }
    24. func (t *Time) Scan(v interface{}) error {
    25.     value, ok := v.(time.Time)
    26.     if ok {
    27.         *t = Time{Time: value}
    28.         return nil
    29.     }
    30.     return fmt.Errorf("can not convert %v to timestamp", v)
    31. }

    分类表和内容表的增删查改

    DB就是*gorm.DB类型，这是在链接数据库的时候，已经赋值好的全局变量

    1. /*内容表*/
    2. //根据条件查询条数
    3. func CountCmsNews(query interface{}, args ...interface{}) uint {
    4.     var v uint
    5.     DB.Table("cms_news").Where(query, args...).Count(&v)
    6.     return v
    7. }
    8.  
    9. //根据条件更新
    10. func (this *CmsNews) SaveCmsNews(query interface{}, args ...interface{}) error {
    11.     db := DB.Table("cms_news").Where(query, args...).Update(this)
    12.     return db.Error
    13. }
    14.  
    15. //增加数据
    16. func (this *CmsNews) AddCmsNews() error {
    17.     return DB.Create(this).Error
    18. }
    19.  
    20. //根据条件查询分页列表
    21. func FindCmsNews(page, pagesize int, query interface{}, args ...interface{}) []CmsNews {
    22.     offset := (page - 1) * pagesize
    23.     var res []CmsNews
    24.     DB.Table("cms_news").Where(query, args...).Order("id desc").Offset(offset).Limit(pagesize).Find(&res)
    25.     return res
    26. }
    27.  
    28. //根据条件删除
    29. func DelCmsNews(query interface{}, args ...interface{}) error {
    30.     return DB.Where(query, args...).Delete(&CmsNews{}).Error
    31. }
    32.  
    33. /*分类表*/
    34. //根据条件分类
    35. func (this *CmsCate) SaveCmsCate(query interface{}, args ...interface{}) error {
    36.     db := DB.Table("cms_cate").Where(query, args...).Update(this)
    37.     return db.Error
    38. }
    39.  
    40. //增加分类
    41. func (this *CmsCate) AddCmsCate() error {
    42.     return DB.Create(this).Error
    43. }
    44.  
    45. //根据条件查询分类列表
    46. func FindCmsCate(page, pagesize int, query interface{}, args ...interface{}) []CmsCate {
    47.     offset := (page - 1) * pagesize
    48.     var res []CmsCate
    49.     DB.Table("cms_cate").Where(query, args...).Order("id desc").Offset(offset).Limit(pagesize).Find(&res)
    50.     return res
    51. }
    52.  
    53. //根据条件删除分类
    54. func DelCmsCate(query interface{}, args ...interface{}) error {
    55.     return DB.Where(query, args...).Delete(&CmsCate{}).Error
    56. }

    编写gin路由处理部分

    gin路由入口

    1.  //系统相关
    2.     systemGroup := engine.Group("/system")
    3.     systemGroup.Use()
    4.     {
    5.         //分类列表
    6.         systemGroup.GET("/cmsCate", controller.GetCmsCate)
    7.         //删除分类
    8.         systemGroup.GET("/delCmsCate", controller.DelCmsCate)
    9.         //增加或编辑分类
    10.         systemGroup.POST("/cmsCate", controller.PostCmsCate)
    11.         //CMS内容列表
    12.         systemGroup.GET("/cmsNews", controller.GetCmsNews)
    13.         //增加或编辑内容
    14.         systemGroup.POST("/cmsNews", controller.PostCmsNews)
    15.         //删除内容
    16.         systemGroup.GET("/delCmsNews", controller.DelCmsNews)
    17.  
    18.     }

    gin框架路由处理逻辑

    返回参数部分，我进行了小的封装，可以参考去掉。

    只看调用model部分的处理逻辑

    1. package controller
    2.  
    3. import (
    4.     "github.com/gin-gonic/gin"
    5.     "kefu/models"
    6.     "kefu/types"
    7.     "strconv"
    8. )
    9.  
    10. type CmsCateForm struct {
    11.     Id       uint   `form:"id" json:"id" uri:"id" xml:"id"`
    12.     CateName string `form:"cate_name" json:"cate_name" uri:"cate_name" xml:"cate_name" binding:"required"`
    13. }
    14.  
    15. //分类列表(暂不分页)
    16. func GetCmsCate(c *gin.Context) {
    17.     list := models.FindCmsCate(1, 1000, "")
    18.     c.JSON(200, gin.H{
    19.         "code":   types.ApiCode.SUCCESS,
    20.         "msg":    types.ApiCode.GetMessage(types.ApiCode.SUCCESS),
    21.         "result": list,
    22.     })
    23. }
    24.  
    25. //编辑CMS分类
    26. func PostCmsCate(c *gin.Context) {
    27.     var form CmsCateForm
    28.     err := c.Bind(&form)
    29.  
    30.     if err != nil {
    31.         c.JSON(200, gin.H{
    32.             "code":   types.ApiCode.FAILED,
    33.             "msg":    types.ApiCode.GetMessage(types.ApiCode.INVALID),
    34.             "result": err.Error(),
    35.         })
    36.         return
    37.     }
    38.     modelCms := &models.CmsCate{
    39.         Id:      form.Id,
    40.         CatName: form.CateName,
    41.     }
    42.     //添加分类
    43.     if form.Id == 0 {
    44.         err := modelCms.AddCmsCate()
    45.         if err != nil {
    46.             c.JSON(200, gin.H{
    47.                 "code": types.ApiCode.FAILED,
    48.                 "msg":  err.Error(),
    49.             })
    50.             return
    51.         }
    52.     } else {
    53.         //修改分类
    54.         err := modelCms.SaveCmsCate("id = ?", form.Id)
    55.         if err != nil {
    56.             c.JSON(200, gin.H{
    57.                 "code": types.ApiCode.FAILED,
    58.                 "msg":  err.Error(),
    59.             })
    60.             return
    61.         }
    62.     }
    63.  
    64.     c.JSON(200, gin.H{
    65.         "code": types.ApiCode.SUCCESS,
    66.         "msg":  types.ApiCode.GetMessage(types.ApiCode.SUCCESS),
    67.     })
    68. }
    69.  
    70. type CmsNewsForm struct {
    71.     Id      uint   `form:"id" json:"id" uri:"id" xml:"id"`
    72.     CateId  string `form:"cate_id" json:"cate_id" uri:"cate_id" xml:"cate_id" binding:"required"`
    73.     Content string `form:"content" json:"content" uri:"content" xml:"content" binding:"required"`
    74.     Title   string `form:"title" json:"title" uri:"title" xml:"title" binding:"required"`
    75. }
    76.  
    77. //CMS内容列表
    78. func GetCmsNews(c *gin.Context) {
    79.     //分页处理
    80.     page, _ := strconv.Atoi(c.Query("page"))
    81.     if page <= 0 {
    82.         page = 1
    83.     }
    84.     pagesize, _ := strconv.Atoi(c.Query("pagesize"))
    85.     if pagesize <= 0 || pagesize > 50 {
    86.         pagesize = 10
    87.     }
    88.     //判断分类ID条件
    89.     catId := c.Query("cat_id")
    90.     query := "1=1 "
    91.     args := make([]interface{}, 0)
    92.  
    93.     if catId != "" {
    94.         query += "and cat_id = ? "
    95.         args = append(args, catId)
    96.     }
    97.     //分页查询
    98.     count := models.CountCmsNews(query, args...)
    99.     list := models.FindCmsNews(page, pagesize, query, args...)
    100.  
    101.     c.JSON(200, gin.H{
    102.         "code": types.ApiCode.SUCCESS,
    103.         "msg":  types.ApiCode.GetMessage(types.ApiCode.SUCCESS),
    104.         "result": gin.H{
    105.             "list":     list,
    106.             "count":    count,
    107.             "pagesize": pagesize,
    108.             "page":     page,
    109.         },
    110.     })
    111. }
    112.  
    113. //编辑CMS内容
    114. func PostCmsNews(c *gin.Context) {
    115.     var form CmsNewsForm
    116.     err := c.Bind(&form)
    117.  
    118.     if err != nil {
    119.         c.JSON(200, gin.H{
    120.             "code":   types.ApiCode.FAILED,
    121.             "msg":    types.ApiCode.GetMessage(types.ApiCode.INVALID),
    122.             "result": err.Error(),
    123.         })
    124.         return
    125.     }
    126.     modelCms := &models.CmsNews{
    127.         Id:    form.Id,
    128.         CatId: form.CateId,
    129.         Title: form.Title,
    130.     }
    131.     //添加
    132.     if form.Id == 0 {
    133.         err := modelCms.AddCmsNews()
    134.         if err != nil {
    135.             c.JSON(200, gin.H{
    136.                 "code": types.ApiCode.FAILED,
    137.                 "msg":  err.Error(),
    138.             })
    139.             return
    140.         }
    141.     } else {
    142.         //修改
    143.         err := modelCms.SaveCmsNews("id = ?", form.Id)
    144.         if err != nil {
    145.             c.JSON(200, gin.H{
    146.                 "code": types.ApiCode.FAILED,
    147.                 "msg":  err.Error(),
    148.             })
    149.             return
    150.         }
    151.     }
    152.  
    153.     c.JSON(200, gin.H{
    154.         "code": types.ApiCode.SUCCESS,
    155.         "msg":  types.ApiCode.GetMessage(types.ApiCode.SUCCESS),
    156.     })
    157. }
    158.  
    159. //删除分类
    160. func DelCmsCate(c *gin.Context) {
    161.     id := c.Query("id")
    162.     err := models.DelCmsCate("id = ?", id)
    163.     if err != nil {
    164.         c.JSON(200, gin.H{
    165.             "code": types.ApiCode.FAILED,
    166.             "msg":  err.Error(),
    167.         })
    168.         return
    169.     }
    170.     c.JSON(200, gin.H{
    171.         "code": types.ApiCode.SUCCESS,
    172.         "msg":  types.ApiCode.GetMessage(types.ApiCode.SUCCESS),
    173.     })
    174. }
    175.  
    176. //删除内容
    177. func DelCmsNews(c *gin.Context) {
    178.     id := c.Query("id")
    179.     err := models.DelCmsNews("id = ?", id)
    180.     if err != nil {
    181.         c.JSON(200, gin.H{
    182.             "code": types.ApiCode.FAILED,
    183.             "msg":  err.Error(),
    184.         })
    185.         return
    186.     }
    187.     c.JSON(200, gin.H{
    188.         "code": types.ApiCode.SUCCESS,
    189.         "msg":  types.ApiCode.GetMessage(types.ApiCode.SUCCESS),
    190.     })
    191. }

    可以使用接口测试工具，对接口进行测试

  • 相关阅读:
    使用 Watt Toolkit (原名 Steam++)加速github访问
    第十四届蓝桥杯省赛C/C++大学B组真题-飞机降落
    string类的使用方式的介绍
    http模块中----------req请求对象-req.url req.method 与客户端请求相关
    圆环进度条 两种实现方式
    java 读取pdf文件内容
    营丘福稻品牌山东大米 国稻种芯·中国水稻节：淄博高青招牌
    SpringBoot@Profile详解
    一些常用到的git命令
    Selenium —— 网页frame与多窗口处理！
  • 原文地址：https://blog.csdn.net/taoshihan/article/details/127943854