ORM（对象关系映射): 把数据库映射成对象。ORM 使用对象，封装了数据库操作，因此可以不碰 SQL 语言。开发者只使用面向对象编程，与数据对象直接交互，不用关心底层数据库实现。

gorm是使用go语言实现数据库访问的ORM库。使用这个库，我们可以利用面向对象的方法，更加方便的对数据库中的数据进行CRUD(数据库的基本操作有四种：create、read、update和delete，简称 CRUD)，而无需关心底层数据库的具体实现以及数据库的类型(支持多种类型的数据库，例如MySQL，SQLite，PostgreSQL，MSSQL)。

gorm基本操作：

gorm 用法介绍

下载gorm：

  1. go get -u gorm.io/gorm
  2. go get -u gorm.io/driver/sqlite

第一个是核心库。
第二个是mysql数据库的驱动包，如果使用的是其他数据库，则需下载相应数据库的驱动包。

项目中引用：

  1. import (
  2.   "gorm.io/gorm"
  3.   "gorm.io/driver/sqlite"
  4. )

gorm包装了一些常用数据库的驱动，直接下载即可：

  1. //import _ "github.com/jinzhu/gorm/dialects/mysql"
  2. //import _ "github.com/jinzhu/gorm/dialects/postgres"
  3. //import _ "github.com/jinzhu/gorm/dialects/sqlite"
  4. //import _ "github.com/jinzhu/gorm/dialects/mssql"

连接数据库

  1. packae main
  2. import (
  3.   "github.com/jinzhu/gorm"
  4.   _ "github.com/jinzhu/gorm/dialects/mysql"
  5.   "fmt"
  6. )
  7. func main() {
  8.   db, err := gorm.Open("mysql","root:12345@/demo?charset=utf8&parseTime=True&loc=Local")
  9.   if err != nil {
  10.       fmt.Println(err)
  11.       return
  12.   }
  14.   defer db.Close()
  15.   // Migrate the schema
  16.   db.AutoMigrate(&Product{})
  18.   // Create
  19.   db.Create(&Product{Code: "L1212", Price: 1000})
  21.   // Read
  22.   var product Product
  23.   db.First(&product, 1) // find product with id 1
  24.   db.First(&product, "code = ?", "L1212") // find product with code l1212
  26.   // Update - update product's price to 2000
  27.   db.Model(&product).Update("Price", 2000)
  29.   // Delete - delete product
  30.   db.Delete(&product)
  31. }

上面代码中 mysql 是数据库驱动，root 是数据库用户名，12345 是密码，demo 则是数据库名称。

表定义

由于grom是使用的orm映射，所以需要定义要操作的表的model，在go中需要定义一个struct， struct的名字就是对应数据库中的表名。

  1. package models
  3. import "time"
  5. type Config struct {
  6.     ID int64 `gorm:"column:id" json:"id" form:"id"`
  7.     Name string `gorm:"column:name" json:"name" form:"name"`
  8.     Content string `gorm:"column:content" json:"content" form:"content"`
  9.     CreatedAt time.Time `gorm:"column:created_at" json:"created_at" form:"created_at"`
  10.     UpdatedAt time.Time `gorm:"column:updated_at" json:"updated_at" form:"updated_at"`
  11. }
  13. func (c *Config) TableName() string {
  14.     return "configs"
  15. }

注意gorm查找struct名对应数据库中的表名的时候会默认把你的struct中的大写字母转换为小写并加上“s”，所以可以加上db.SingularTable(true) 让grom转义struct名字的时候不用加上s。

也可提前在数据库中创建好表的然后再用grom去查询的，也可以用gorm去创建表，个人感觉直接在数据库上创建，修改表字段的操作方便，grom只用来查询和更新数据。

定义model(即struct），我们可以只定义我们需要从数据库中取回的特定字段：gorm在转义表名的时候会把stuct的大写字母(首字母除外) 替换成“_”。

  1. 例如定义一个struct 
  2. type TemporaryMobile struct {
  3. }
  5.  数据库中表名会转为“temporary_mobiles”

image.png

先来定义一个点赞表，这里面一条记录表示某个用户在某个时刻对某篇文章点了一个赞，用 ip + ua 来标识用户，title 标识文章标题。

  1. type Like struct {
  2.     ID        int    `gorm:"primary_key"`
  3.     Ip        string `gorm:"type:varchar(20);not null;index:ip_idx"`
  4.     Ua        string `gorm:"type:varchar(256);not null;"`
  5.     Title     string `gorm:"type:varchar(128);not null;index:title_idx"`
  6.     Hash      uint64 `gorm:"unique_index:hash_idx;"`
  7.     CreatedAt time.Time
  8. }

gorm 用 tag 的方式来标识 mysql 里面的约束、创建索引只需要直接指定列即可，这里创建了两个索引，ip_idx 和 title_idx；如果需要多列组合索引，直接让索引的名字相同即可；如果需要创建唯一索引，指定为 unique_index 即可。
支持时间类型，直接使用 time.Time 即可

创建表

  1. if !db.HasTable(&Like{}) {
  2.     if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
  3.         panic(err)
  4.     }
  5. }

直接通过 db.CreateTable 就可以创建表了，非常方便，还可以通过 db.Set 设置一些额外的表属性

插入记录

  1. like := &Like{
  2.     Ip:        ip,
  3.     Ua:        ua,
  4.     Title:     title,
  5.     Hash:      murmur3.Sum64([]byte(strings.Join([]string{ip, ua, title}, "-"))) >> 1,
  6.     CreatedAt: time.Now(),
  7. }
  9. if err := db.Create(like).Error; err != nil {
  10.     return err
  11. }

先构造已给对象，直接调用 db.Create() 就可以插入一条记录了

删除记录

  1. if err := db.Where(&Like{Hash: hash}).Delete(Like{}).Error; err != nil {
  2.     return err
  3. }

先用 db.Where() 构造查询条件，再调用 db.Delete() 就可以删除

查询

  1. var count int
  2. err := db.Model(&Like{}).Where(&Like{Ip: ip, Ua: ua, Title: title}).Count(&count).Error
  3. if err != nil {
  4.     return false, err
  5. }

先用 db.Model() 选择一个表，再用 db.Where() 构造查询条件，后面可以使用 db.Count() 计算数量，如果要获取对象，可以使用 db.Find(&Likes) 或者只需要查一条记录 db.First(&Like)

修改

  1. db.Model(&user).Update("name", "hello")
  2. db.Model(&user).Updates(User{Name: "hello", Age: 18})
  3. db.Model(&user).Updates(User{Name: "", Age: 0, Actived: false}) // nothing update

我这个系统里面没有更新需求，这几个例子来自于官网，第一个是更新单条记录；第二个是更新整条记录，注意只有非空字段才会更新；第三个例子是不会更新的，在系统设计的时候要尽量避免这些空值有特殊的含义，如果一定要更新，可以使用第一种方式，设置单个值

错误处理

其实你已经看到了，这里基本上所有的函数都是链式的，全部都返回 db 对象，任何时候调用 db.Error 就能获取到错误信息，非常方便

事务

  1. func CreateAnimals(db *gorm.DB) err {
  2.     tx := db.Begin()
  3.     if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
  4.         tx.Rollback()
  5.         return err
  6.     }
  7.     if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
  8.         tx.Rollback()
  9.         return err
  10.     }
  11.     tx.Commit()
  12.     return nil
  13. }

事务的处理也很简单，用 db.Begin() 声明开启事务，结束的时候调用 tx.Commit()，异常的时候调用 tx.Rollback()

其他

还可以使用如下方式设置日志输出级别以及改变日志输出地方

  2. db.LogMode(true)
  3. db.SetLogger(gorm.Logger{revel.TRACE})
  4. db.SetLogger(log.New(os.Stdout, "\r\n", 0))

也支持普通的 sql，但是建议尽量不要使用