简单使用Gin和Gorm搭建一个系统（二）

四、service层建立增删改查业务逻辑。

在service层建立一个Book的service类，命名为BookService.go。

这里，需要引入两个依赖，一个是dao层创建的全局SqlSession，用于操作数据库；一个是User类，用于接收数据库对应表结构的数据。

import (
    "SOABook/go/dao"
    "SOABook/go/entity"
)

接下来，就可以基于SqlSession获取到的API接口，对数据库进行简单的增删改查操作了.

1.创建book

func CreateBook(book *entity.Book) (err error) {
    if err = dao.SqlSession.Create(book).Error; err != nil {
       panic(err)
       return err
    }
    return
}

2.查询book信息

func GetBookById(id string) (book entity.Book, err error) {
    if err = dao.SqlSession.Where("book_id = ?", id).First(&book).Error; err != nil {
       return entity.Book{}, err
    }
    return
}

3.删除指定book

func DeleteBookById(id string) (err error) {
    if err = dao.SqlSession.Where("book_id = ?", id).Delete(&entity.Book{}).Error; err != nil {
       return err
    }
    return
}

4.更新book

func UpdateBookById(id string, book *entity.Book) (err error) {
    if err = dao.SqlSession.Model(&entity.Book{}).Where("book_id = ?", id).Updates(book).Error; err != nil {
       return err
    }
    return
}

五、controller层建立Book的controller类。

在controller层建立一个BookController.go类，类似Java的controller，主要用于根据url跳转执行到对应路径的方法。

首先，引入需要用到的依赖包，

import (
    "SOABook/go/entity"
    "SOABook/go/service"
    "github.com/gin-gonic/gin"
    "net/http"
)

1.实现新增book的方法

func CreateBook(c *gin.Context) {
    var book entity.Book
    // 读取并打印请求体
    err := c.ShouldBindJSON(&book)
    //随机生成id
    book.BookId = rand.Int63()
    if err != nil {
       c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
       return
    }
​
    err = service.CreateBook(&book)
    if err != nil {
       c.JSON(http.StatusBadRequest, gin.H{"err": err})
    } else {
       c.JSON(http.StatusOK, gin.H{
          "code": 200,
          "msg":  "success",
          "data": book,
       })
    }
}

2.实现获取book的方法

func GetBookById(c *gin.Context) {
    id := c.Param("id")
    book, err := service.GetBookById(id)
    if err != nil {
       c.JSON(http.StatusBadRequest, gin.H{"err": err})
    } else {
       // 获取请求头格式是xml还是json
       head := c.Request.Header.Get("Accept")
       if head == "application/xml" {
          c.XML(http.StatusOK, gin.H{
             "code": 200,
             "msg":  "success",
             "data": book,
             "url1": "http:localhost:8080/borrowing",
             "url2": "http:localhost:8080/reader",
          })
       } else {
          c.JSON(http.StatusOK, gin.H{
             "code": 200,
             "msg":  "success",
             "data": book,
             "url1": "http:localhost:8080/borrowing",
             "url2": "http:localhost:8080/reader",
          })
       }
​
    }
}

3.实现删除book的方法

func DeleteBookById(c *gin.Context) {
    id := c.Param("id")
    err := service.DeleteBookById(id)
    if err != nil {
       c.JSON(http.StatusBadRequest, gin.H{"err": err})
    } else {
       c.JSON(http.StatusOK, gin.H{
          "code": 200,
          "msg":  "success",
       })
    }
}

4.实现更新book信息的方法

func UpdateBookById(c *gin.Context) {
    id := c.Param("id")
    var book entity.Book
    err := c.ShouldBindJSON(&book)
    if err != nil {
       return
    }
    err = service.UpdateBookById(id, &book)
    if err != nil {
       c.JSON(http.StatusBadRequest, gin.H{"err": err})
    } else {
       c.JSON(http.StatusOK, gin.H{
          "code": 200,
          "msg":  "success",
       })
    }
}

六、routes层增加路由文件，用于根据请求url进行转发。

同样需要引入使用到的依赖

import (
    "SOABook/go/controller"
    "github.com/gin-gonic/gin"
)

然后搭建一个初始化路由的操作，将路由统一存放到数据book的group组里，这样可以比较方便区分这些路由数据哪个controller类的。

Routers.go的完整代码如下：

package routes
​
import (
    "SOABook/go/controller"
    "github.com/gin-gonic/gin"
)
​
func SetRouter() *gin.Engine {
    r := gin.Default()
    bookGroup := r.Group("books")
    {
       bookGroup.GET(":id", controller.GetBookById)
       bookGroup.POST("", controller.CreateBook)
       bookGroup.PUT(":id", controller.UpdateBookById)
       bookGroup.DELETE(":id", controller.DeleteBookById)
    }
    return r
}

七、main启动类。

最后一步，就是建立main的启动类了，需要注意一点是，go的启动类，必须命名在package main的包下，否则无法进行启动。

引入依赖：

import (
    "SOABook/go/dao"
    "SOABook/go/entity"
    "SOABook/go/routes"
    "fmt"
)

main函数：

func main() {
    err := dao.InitSql()
    if err != nil {
       panic(err)
    }
    defer dao.Close()
​
    err = dao.SqlSession.AutoMigrate(&entity.Book{})
    if err != nil {
       fmt.Println("###", err)
    }
    r := routes.SetRouter()
​
    r.Run(":8080")
}

最后运行成功的结果：

好了到这里这个简单的后台系统就搭建完成了，在搭建这个后台系统的过程中也遇到了许多问题

1. 不熟悉go的结构体私有与共有的约定，导致外部无法访问函数
2. 将变量首字母小写导致外部无法访问这个变量
3. 不了解gorm框架的使用导致查询数据库失败
4. 不了解路由路径的配置，param参数与path参数分不清导致找不到路径
5. 。。。

现在，终于是成功搭建好这个简单的系统了，虽然这个系统非常的基础简单，但也是我迈入go语言大门的第一步。