Gin实战：Gin+Mysql简单的Restful风格的API

我们已经了解了Golang的Gin框架。对于Webservice服务，restful风格几乎一统天下。Gin也天然的支持restful。下面就使用gin写一个简单的服务，麻雀虽小，五脏俱全。我们先以一个单文件开始，然后再逐步分解模块成包，组织代码。

Hello World

使用Gin的前提是安装，我们需要安装gin和mysql的驱动，具体的安装方式就不在赘述。

创建一个文件夹用来为项目，新建一个文件main.go：

☁  newland  tree
.
└── main.go

main.go

package main

import (
 "gopkg.in/gin-gonic/gin.v1"
 "net/http"
)

func main() {
 router := gin.Default()

 router.GET("/", func(c *gin.Context) {
  c.String(http.StatusOK, "Hello world")
 })

 router.Run(":8801")
}

编译运行

数据库

安装完毕框架，完成一次请求响应之后。接下来就是安装数据库驱动和初始化数据相关的操作了。首先，我们需要新建数据表。一个及其简单的数据表：

CREATE TABLE `users` (
  `id` int() unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar() DEFAULT NULL,
  `telephone` varchar() DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT= DEFAULT CHARSET=utf8mb4;

创建数据表之后，初始化数据库连接池：

db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?parseTime=true")
 if err != nil{
  log.Fatalln(err)
 }
defer db.Close()

 db.SetMaxIdleConns()
 db.SetMaxOpenConns()

 if err := db.Ping(); err != nil{
  log.Fatalln(err)
 }

使用sql.Open方法会创建一个数据库连接池db。这个db不是数据库连接，它是一个连接池，只有当真正数据库通信的时候才创建连接。例如这里的db.Ping的操作。db.SetMaxIdleConns(20)和db.SetMaxOpenConns(20)分别设置数据库的空闲连接和最大打开连接，即向Mysql服务端发出的所有连接的最大数目。

如果不设置，默认都是0，表示打开的连接没有限制。我在压测的时候，发现会存在大量的TIME_WAIT状态的连接，虽然mysql的连接数没有上升。设置了这两个参数之后，不在存在大量TIME_WAIT状态的连接了。而且qps也没有明显的变化，出于对数据库的保护，最好设置这连个参数。

CURD 增删改查

Restful的基本就是对资源的curd操作。下面开启我们的第一个api接口，增加一个资源。

增

var db *sql.DB

type Person struct {
   Id int `json:"id" form:"id"`
   Name string `json:"name" form:"name"`
   Telephone string `json:"telephone" form:"telephone"`
}

func main() {

 ...

    //增加一条记录
    router.POST("/add", func(c *gin.Context) {
        name := c.Request.FormValue("name")
        telephone := c.Request.FormValue("telephone")
        person := Person{
            Name:name,
            Telephone:telephone,
        }
        id := person.Create()
        msg := fmt.Sprintf("insert successful %d", id)
        c.JSON(http.StatusOK, gin.H{
            "msg": msg,
        })
    })

 ...
}

//插入
func (person *Person) Create() int64 {
    rs, err := db.Exec("INSERT into users (name, telephone) value (?,?)", person.Name, person.Telephone)
    if err != nil{
        log.Fatal(err)
    }
    id, err := rs.LastInsertId()
    if err != nil{
        log.Fatal(err)
    }
    return id
}

func checkErr(err error)  {
    if err != nil{
        panic(err)
    }
}

执行非query操作，使用db的Exec方法，在mysql中使用?做占位符。最后我们把插入后的id返回给客户端。请求得到的结果如下：

查

查询列表 Query

上面我们增加了一条记录，下面就获取这个记录，查一般有两个操作，一个是查询列表，其次就是查询具体的某一条记录。两种大同小异。

为了给查询结果绑定到golang的变量或对象，我们需要先定义一个结构来绑定对象。

router.GET("/users", func(c *gin.Context) {
    rs, _ := getRows()
    c.JSON(http.StatusOK, gin.H{
        "list": rs,
    })
})

//查询所有记录
func getRows() (persons []Person, err error) {
    rows, err := db.Query("select id,name,telephone from users")
    for rows.Next(){
        person := Person{}
        err := rows.Scan(&person.Id, &person.Name, &person.Telephone)
        if err != nil {
            log.Fatal(err)
        }
        persons = append(persons, person)
    }
    rows.Close()
    return
}

返回结果如下：

查询单条记录 QueryRow

查询列表需要使用迭代rows对象，查询单个记录，就没这么麻烦了。虽然也可以迭代一条记录的结果集。因为查询单个记录的操作实在太常用了，因此golang的database/sql也专门提供了查询方法

router.GET("/users/:id", func(c *gin.Context) {
        id_string := c.Param("id")
        id, _ := strconv.Atoi(id_string)
        rs, _ := getRow(id)
        c.JSON(http.StatusOK, gin.H{
            "result": rs,
        })
    })

//查询一条记录
func getRow(id int) (person Person, err error)  {
    person = Person{}
    err = db.QueryRow("select id,name,telephone from users where id = ?", id).Scan(&person.Id, &person.Name, &person.Telephone)
    return
}

返回结果如下：

改

增删改查，下面进行更新的操作。

router.POST("/users/update", func(c *gin.Context) {
        ids := c.Request.FormValue("id")
        id, _ := strconv.Atoi(ids)
        telephone := c.Request.FormValue("telephone")
        person := Person{
            Id:id,
            Telephone:telephone,
        }
        row := person.Update()
        msg := fmt.Sprintf("updated successful %d", row)
        c.JSON(http.StatusOK, gin.H{
            "msg": msg,
        })
    })
/修改
func (person *Person) Update() int64{
    rs, err := db.Exec("update users set telephone = ? where id = ?", person.Telephone, person.Id)
    if err != nil {
        log.Fatal(err)
    }
    rows, err := rs.RowsAffected()
    if err != nil {
        log.Fatal(err)
    }
    return  rows
}

返回结果如下:

删

最后一个操作就是删除了，删除所需要的功能特性，上面的例子都覆盖了。实现删除也就特别简单了：

//删除一条记录
    router.POST("/users/del", func(c *gin.Context) {
        ids := c.Request.FormValue("id")
        id, _ := strconv.Atoi(ids)
        row := Delete(id)
        msg := fmt.Sprintf("delete successful %d", row)
        c.JSON(http.StatusOK, gin.H{
            "msg": msg,
        })
    })

func Delete(id int) int64  {
    rs, err := db.Exec("delete from users where id = ?", id)
    if err != nil {
        log.Fatal()
    }
    rows, err := rs.RowsAffected()
    if err != nil {
        log.Fatal()
    }
    return rows
}

返回结果：

至此，基本的CURD操作的restful风格的API已经完成。内容其实不复杂，甚至相当简单。