1.golang : gorm + gin实现restful 接口

golang : gorm + gin实现restful 接口

gorm操作数据库

golang可以使用gorm工具对数据库进行操作,实现对数据的一系列操作.

主要实现的功能如下:

全功能ORM（几乎）
关联（包含一个，包含多个，属于，多对多，多种包含）
Callbacks（创建/保存/更新/删除/查找之前/之后）
预加载（急加载）
事务
复合主键
SQL Builder
自动迁移
日志
可扩展，编写基于GORM回调的插件
每个功能都有测试
开发人员友好

上述功能可以满足我们的日常开发需求.

安装gorm

可以使用go get的方式直接安装

go get -u github.com/jinzhu/gorm

连接 mysql 并创建数据表

连接mysql数据库

var db *gorm.DB
var err error

func main()  {
    db, err = gorm.Open("mysql", "用户名:密码@/go_test?charset=utf8&parseTime=True&loc=Local")
    if err != nil {
        panic(err)
    }
    defer db.Close()
}

创建数据表

type User struct {
    gorm.Model
    Birthday     time.Time
    Age          int
    Name         string  `gorm:"size:255"`       // string默认长度为255, 使用这种tag重设。
    Num          int     `gorm:"AUTO_INCREMENT"` // 自增
    Sex          string  `gorm:"size:"`

    CreditCard        CreditCard      // One-To-One (拥有一个 - CreditCard表的UserID作外键)
    Emails            []Email         // One-To-Many (拥有多个 - Email表的UserID作外键)

    BillingAddress    Address         // One-To-One (属于 - 本表的BillingAddressID作外键)
    BillingAddressID  sql.NullInt64

    ShippingAddress   Address         // One-To-One (属于 - 本表的ShippingAddressID作外键)
    ShippingAddressID int

    IgnoreMe          int `gorm:"-"`   // 忽略这个字段
    Languages         []Language `gorm:"many2many:user_languages;"` // Many-To-Many , 'user_languages'是连接表
}

type Email struct {
    ID      int
    UserID  int     `gorm:"index"` // 外键 (属于), tag `index`是为该列创建索引
    Email   string  `gorm:"type:varchar(100);unique_index"` // `type`设置 sql 类型, `unique_index` 为该列设置唯一索引
    Subscribed bool
}

type Address struct {
    ID       int
    Address1 string         `gorm:"not null;unique"` // 设置字段为非空并唯一
    Address2 string         `gorm:"type:varchar(100);unique"`
    Post     sql.NullString `gorm:"not null"`
}

type Language struct {
    ID   int
    Name string `gorm:"index:idx_name_code"` // 创建索引并命名，如果找到其他相同名称的索引则创建组合索引
    Code string `gorm:"index:idx_name_code"` // `unique_index` also works
}

type CreditCard struct {
    gorm.Model
    UserID  uint
    Number  string
}

CreditCard和User结构体中包含了gorm.Model,这是一个基础的结构体,包含了id,创建时间,修改时间和删除时间等基本信息字段:

type Model struct {
    ID        uint `gorm:"primary_key"`
    CreatedAt time.Time
    UpdatedAt time.Time
    DeletedAt *time.Time `sql:"index"`
}

如果想要在指定的数据库中创建上述表,执行如下操作:

db.AutoMigrate(
        &User{},
        &Email{},
        &Address{},
        &Language{},
        &CreditCard{})

针对数据的增加,查找,修改和删除操作,在下节配合http命令进行操作.

gin实现restful接口

安装gin

可以使用go get安装:

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

官方给出了一个简单的示例,可以快速的启动服务:

package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run(":10080") // listen and serve on 0.0.0.0:10080
}

如果在本机启动该服务,浏览器访问 http://127.0.0.1:10080/ping 地址,可以看到获取到一个json块:

{"message": "pong"}

除了GET操作之外,其他的HTTP操作POST,PUT,DELETE也可以很方便的使用.

下面可以配合gorm实现gin的restful接口

首先定义好router以及相关路由策略:

router := gin.Default()
router.GET("/user/", getUsers)
router.GET("/user/:id", getOneUser)
router.POST("/user", createUser)
router.PUT("/user/:id", updateUser)
router.DELETE("/user/:id", deleteUser)

每个路由都对应一个具体的函数操作,从而实现了对user的增,删,改,查操作.

func getUsers(c *gin.Context)  {
    users := make([]User, 0)
    //db.Find(&users)
    db.Scopes(AgeGreaterThan20).Find(&users)
    c.JSON(http.StatusOK, gin.H{
        "data": users,
    })
}

func getOneUser(c *gin.Context)  {
    id := c.Param("id")
    var user User
    if err := db.Where("id = ?", id).First(&user).Error; err != nil {
        c.AbortWithStatus(http.StatusNotFound)
        fmt.Println(err)
    } else {
        c.JSON(http.StatusOK, gin.H{
            "data": user,
        })
    }
}

func createUser(c *gin.Context)  {
    var user User
    c.BindJSON(&user)
    user.Birthday = time.Now()
    db.Create(&user)
    c.JSON(http.StatusOK, gin.H{
        "data": user,
    })
}

func updateUser(c *gin.Context)  {
    id := c.Param("id")
    var user User

    if err := db.Where("id = ?", id).First(&user).Error; err != nil {
        c.AbortWithStatus(http.StatusNotFound)
        fmt.Println(err)
    } else {
        c.BindJSON(&user)
        db.Save(&user)
        c.JSON(http.StatusOK, gin.H{
            "data": user,
        })
    }
}

func deleteUser(c *gin.Context)  {
    id := c.Param("id")
    var user User
    db.Where("id = ?", id).Delete(&user)
    c.JSON(http.StatusOK, gin.H{
        "data": "this has been deleted!",
    })
}

启动gin服务可以看到如下信息:

[GIN-debug] GET    /user/                    --> main.getUsers (3 handlers)
[GIN-debug] GET    /user/:id                 --> main.getOneUser (3 handlers)
[GIN-debug] POST   /user                     --> main.createUser (3 handlers)
[GIN-debug] PUT    /user/:id                 --> main.updateUser (3 handlers)
[GIN-debug] DELETE /user/:id                 --> main.deleteUser (3 handlers)
[GIN-debug] Listening and serving HTTP on :10080

如果要对上述接口进行测试可以使用postman等工具.经测试可以实现对user的增,删,改,查操作.

小结

通过非常简短的代码,就可以实现功能强大的restful接口,go语言的优势也是非常明显的.关于gin和gorm还有更加深入的内容.掌握好这两个 工具 可以轻松的构建web应用.