这篇主要学习go项目中的项目结构、项目规范等知识，ROM采用的database/sql的写法。

1.技术框架

利用的是ginweb框架，然后ROM层选用database/sql，安装mysql驱动。安装方式如下：

//使用github上的gin托管地址

$ go get -u github.com/gin-gonic/gin

$ go get github.com/go-sql-driver/mysql

2.项目结构如下

项目结构分析：

1、main.go主要是存放路由，启动项目；

2、router主要存放路由信息，然后返回一个router；

3、apis存放router的Handler函数；

4、databases存放数据连接信息；

5、models存放数据模型，类似Java中POJO对象。

│ main.go

│

├─.idea

│ │ go.iml

│ │ misc.xml

│ │ modules.xml

│ │ workspace.xml

│ │

│ └─inspectionProfiles

├─apis

│ person.go

│

├─databases

│ mysql.go

│

├─models

│ person.go

│

└─router

router.go

image.png

3.main.go代码解释

package main

import (

//这里讲db作为go/databases的一个别名，表示数据库连接池

db "go/databases"

. "go/router"

)

func main() {

//当整个程序完成之后关闭数据库连接

defer db.SqlDB.Close()

router := InitRouter()

router.Run(":8080")

}

4.router.go代码解释

package router

import (

"github.com/gin-gonic/gin"

."go/apis"

)

func InitRouter() *gin.Engine {

router := gin.Default()

//IndexApi为一个Handler

router.GET("/", IndexApi)

router.POST("/person", AddPersonApi)

router.GET("/persons", GetPersonsApi)

router.GET("/person/:id", GetPersonApi)

router.PUT("/person/:id", ModPersonApi)

router.DELETE("/person/:id", DelPersonApi)

return router

}

5.mysql.go代码解释

package databases

import (

"database/sql"

_ "github.com/go-sql-driver/mysql"

"log"

)

//因为我们需要在其他地方使用SqlDB这个变量，所以需要大写代表public

var SqlDB *sql.DB

//初始化方法

func init() {

var err error

SqlDB, err = sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/test?parseTime=true")

if err != nil {

log.Fatal(err.Error())

}

//连接检测

err = SqlDB.Ping()

if err != nil {

log.Fatal(err.Error())

}

}

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

6.models中person.go代码解释

package models

import (

"log"

db "go/databases"

)

//定义person类型结构

type Person struct {

Id int `json:"id"`

FirstName string `json:"first_name"`

LastName string `json:"last_name"`

}

func (p *Person) AddPerson() (id int64, err error) {

rs, err := db.SqlDB.Exec("INSERT INTO person(first_name, last_name) VALUES (?, ?)", p.FirstName, p.LastName)

if err != nil {

return

}

id, err = rs.LastInsertId()

return

}

func (p *Person) GetPersons() (persons []Person, err error) {

persons = make([]Person, 0)

rows, err := db.SqlDB.Query("SELECT id, first_name, last_name FROM person")

defer rows.Close()

if err != nil {

return

}

for rows.Next() {

var person Person

rows.Scan(&person.Id, &person.FirstName, &person.LastName)

persons = append(persons, person)

}

if err = rows.Err(); err != nil {

return

}

return

}

func (p *Person) GetPerson() (person Person, err error) {

err = db.SqlDB.QueryRow("SELECT id, first_name, last_name FROM person WHERE id=?", p.Id).Scan(

&person.Id, &person.FirstName, &person.LastName,

)

return

}

func (p *Person) ModPerson() (ra int64, err error) {

stmt, err := db.SqlDB.Prepare("UPDATE person SET first_name=?, last_name=? WHERE id=?")

defer stmt.Close()

if err != nil {

return

}

rs, err := stmt.Exec(p.FirstName, p.LastName, p.Id)

if err != nil {

return

}

ra, err = rs.RowsAffected()

return

}

func (p *Person) DelPerson() (ra int64, err error) {

rs, err := db.SqlDB.Exec("DELETE FROM person WHERE id=?", p.Id)

if err != nil {

log.Fatalln(err)

}

ra, err = rs.RowsAffected()

return

}

执行非query操作，使用db的Exec方法，在MySQL中使用？做占位符。最后我们把插入后的Id返回给客户端。

GetPersons方法解释：

读取MySQL的数据需要有一个绑定的过程，db.Query()方法返回一个rows对象，这个数据库连接随即转移到这个对象，因此我们需要定义rows.Close()操作，然后创建一个[]Person的切片。

使用make，而不是直接使用var persons []Person的声明方式。还是有所差别的，使用make的方式，当数组切片没有元素的时候，Json会返回[]。如果直接声明，json会返回null。

接下来就是使用rows对象的Next()方法，遍历所查询的数据，一个个绑定到person对象上，最后append到person切片。

7.apis中的person.go代码解释

package apis

import (

"net/http"

"log"

"fmt"

"strconv"

"github.com/gin-gonic/gin"

."go/models"

)

func IndexApi(c *gin.Context) {

c.String(http.StatusOK, "It works")

}

func AddPersonApi(c *gin.Context) {

firstName := c.Request.FormValue("first_name")

lastName := c.Request.FormValue("last_name")

p := Person{FirstName: firstName, LastName: lastName}

ra, err := p.AddPerson()

if err != nil {

log.Fatalln(err)

}

msg := fmt.Sprintf("insert successful %d", ra)

c.JSON(http.StatusOK, gin.H{

"msg": msg,

})

}

func GetPersonsApi(c *gin.Context) {

var p Person

persons, err := p.GetPersons()

if err != nil {

log.Fatalln(err)

}

c.JSON(http.StatusOK, gin.H{

"persons": persons,

})

}

func GetPersonApi(c *gin.Context) {

cid := c.Param("id")

id, err := strconv.Atoi(cid)

if err != nil {

log.Fatalln(err)

}

p := Person{Id: id}

person, err := p.GetPerson()

if err != nil {

log.Fatalln(err)

}

c.JSON(http.StatusOK, gin.H{

"person": person,

})

}

func ModPersonApi(c *gin.Context) {

cid := c.Param("id")

id, err := strconv.Atoi(cid)

if err != nil {

log.Fatalln(err)

}

p := Person{Id: id}

err = c.Bind(&p)

if err != nil {

log.Fatalln(err)

}

ra, err := p.ModPerson()

if err != nil {

log.Fatalln(err)

}

msg := fmt.Sprintf("Update person %d successful %d", p.Id, ra)

c.JSON(http.StatusOK, gin.H{

"msg": msg,

})

}

func DelPersonApi(c *gin.Context) {

cid := c.Param("id")

id, err := strconv.Atoi(cid)

if err != nil {

log.Fatalln(err)

}

p := Person{Id: id}

ra, err := p.DelPerson()

if err != nil {

log.Fatalln(err)

}

msg := fmt.Sprintf("Delete person %d successful %d", id, ra)

c.JSON(http.StatusOK, gin.H{

"msg": msg,

})

}

其实，整个项目的结构和CRUD操作跟Java中的思想比较类似，应该很容易上手。需要注意一点的是，如果需要将整个项目运行起来，项目的路径一定Gopath路径：F:\Go\Project\src;

image.png

image.png

项目启动结果如下：

image.png

熟悉了database/sql的写法后，下一步就是学习ROM框架gorm的写法，进而学习Docker进行部署。

参考资料