golang基础-和mysql打交道

1,389 阅读4分钟

mysql简介

mysql是关系型数据库RDBMS(Relational database management system)的典型代表,也是后台开发中打交道最多的一个组件。

go-sql-driver访问数据库

插入操作

func InsertUser(user bean.User) (bool){
  //开启事务
  tx, err := DB.Begin()
  if err != nil{
      fmt.Println("tx fail")
      return false
  }
  //准备sql语句
  stmt, err := tx.Prepare("INSERT INTO nk_user (`name`, `password`) VALUES (?, ?)")
  if err != nil{
      fmt.Println("Prepare fail")
      return false
  }
  //将参数传递到sql语句中并且执行
  res, err := stmt.Exec(user.UserName, user.Password)
  if err != nil{
      fmt.Println("Exec fail")
      return false
  }
  //将事务提交
  tx.Commit()
  //获得上一个插入自增的id
  fmt.Println(res.LastInsertId())
  return true
}

查询操作

func SelectAllUser() ([]bean.User) {
    //执行查询语句
    rows, err := DB.Query("SELECT * from nk_user")
    if err != nil{
        fmt.Println("查询出错了")    
    }
    var users []bean.User
    //循环读取结果
    for rows.Next(){
        var user bean.User
        //将每一行的结果都赋值到一个user对象中
        err := rows.Scan(&user.Id, &user.UserName, &user.Password)
        if err != nil {
            fmt.Println("rows fail")
        }
        //将user追加到users的这个数组中
        users = append(users, user)
    }
    return users
}

这里会发现,当字段比较多,有二三十个,sql语句都需要自己写,同时scan还得指定每一个字段去接收,如果类型一样的错位了,就是一个难以排查的事故。 同时,sql语句太长,也不好维护。在大型项目开发过程中,几乎所有团队都会选择用orm。

golang 的gorm

什么是orm

ORM全称是:Object Relational Mapping(对象关系映射),其主要作用是在编程中,把面向对象的概念跟数据库中表的概念对应起来。举例来说就是,我定义一个对象,那就对应着一张表,这个对象的实例,就对应着表中的一条记录。

连接数据库

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

func main() {
  db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
  defer db.Close()
}

创建记录

user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}

db.NewRecord(user) // => returns `true` as primary key is blank

db.Create(&user)

db.NewRecord(user) // => return `false` after `user` created

查询记录

// Get first record, order by primary key
db.First(&user)
//// SELECT * FROM users ORDER BY id LIMIT 1;

// Get last record, order by primary key
db.Last(&user)
//// SELECT * FROM users ORDER BY id DESC LIMIT 1;

// Get all records
db.Find(&users)
//// SELECT * FROM users;

// Get record with primary key (only works for integer primary key)
db.First(&user, 10)
//// SELECT * FROM users WHERE id = 10;

查询条件

// Get first matched record
db.Where("name = ?", "jinzhu").First(&user)
//// SELECT * FROM users WHERE name = 'jinzhu' limit 1;

// Get all matched records
db.Where("name = ?", "jinzhu").Find(&users)
//// SELECT * FROM users WHERE name = 'jinzhu';

db.Where("name <> ?", "jinzhu").Find(&users)

// IN
db.Where("name in (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)

// LIKE
db.Where("name LIKE ?", "%jin%").Find(&users)

// AND
db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)

// Time
db.Where("updated_at > ?", lastWeek).Find(&users)

db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)

Save命令

db.Save(&data) gorm支持一个Save命令,其语意是当model中Id主键有值时,更新该model。无值时创建一条。如果是需要先从数据库读model,再更新写入,就很适合用Save操作。

gorm 特性

链式组合

gromdb是链式的结构: 每个操作返回的都是gorm.DB db.Where().Limit().Offset()

在业务开发中,可以灵活运用,比如有type类型,status状态两个字段,如果填了才过滤,不填就返回所有的,可以按下面这样写:

if status != "" {
    db.Where("status = ?", status)
}
if type != 0 "" {
    db.Where("type = ?", type)
}
db.Find([]*Data)

callback

callback是一个不得不提的能力,顾名思义,回调,即 通过它可以方便地对gorm进行二次封装。目前gorm 支持如下callback

  • BeforeSave : Save操作之前
  • BeforeCreate :Create操作之前
  • AfterUpdate:Update操作之后
  • AfterSave:Save操作之后
  • BeforeDelete:Delete操作之前
  • AfterDelete:Delete操作之后
  • AfterFind:Find之后

比如,如果有加密需求,就可以在beforeCreate时运用加密。 在afterFind运用解秘。以下是一个简单的条件判断示例:

func (u *User) BeforeUpdate() (err error) {
    if u.readonly() {
        err = errors.New("read only user")
    }
    return
}

// Rollback the insertion if user's id greater than 1000
func (u *User) AfterCreate() (err error) {
    if u.Id > 1000 {
        err = errors.New("user id is already greater than 1000")
    }
    return
}

如果callback中有失败,那么整个事物都会回滚。

开发模式推荐

单独建一个model文件夹,一个model一个文件,可以理解为一个表一个文件。 在其中用类型的方法,封装好针对这个model直接访问的方法。 同时定义个对外暴露的变量Nsp,外面直接通过这个Nsp访问方法。 如果有针对多表的访问和联合,应该再封装一个更高层。这样代码结构会比较清晰。