详解Go语言如何使用xorm实现读取mysql

Golang
316
0
0
2023-06-19
关于Go你不得不知道的一些实用小技巧
上一篇
深入了解Go的HttpClient超时机制
下一篇
目录
  • 一、介绍
  • 二、安装使用xorm，注意连接的关闭！
  • 关于连接数的坑以及engine.Close()
  • 常用方法介绍
  • 三、mysql生产struct
  • 四、xorm常用操作示例--insert数据
  • 4.1 insert 增加1条数据
  • 4.2 insert 增加多条数据
  • 4.3 insert 增加不同表数据
  • 五、xorm常用操作示例--删除某行
  • 5.1 通过id删除
  • 5.2 通过where条件删除
  • 5.3 软删除，通过某个字段实现软删除，比如status=0
  • 六、xorm常用操作示例--update更新操作
  • 6.1 以结构体的参数，传递要更新的字段
  • 6.2 以map做为参数，传递要更新的字段
  • 6.3指定字段更新，未指定的将不更新，指定了的即使为0也会更新。
  • 6.4指定字段更新，未指定的根据值是否是有值来更新。
  • 七、xorm常用操作示例--查询单条
  • 7.1 根据主键Id来获得单条数据:
  • 7.2 根据where来获得单条数据:
  • 7.3 根据user机构体中非空数据来获得单条数据:
  • 八、xorm常用操作示例--查询多条数据
  • 8.1 返回结果为 结构体slice:
  • 8.2 返回结果为 结构体map:
  • 九、xorm常用操作示例--FindAndCount 分页
  • 十、xorm常用操作示例--事务操作

一、介绍

xorm是go语言的常用orm之一，用来操作数据库。

主要特性特性：

  • 支持根据数据库自动生成xorm的结构体
  • 支持Struct和数据库表之间的灵活映射, 并支持自动同步
  • 支持事务
  • 支持使用Id, In, Where, Limit, Join, Having, Table, Sql, Cols等函数和结构体等方式作为条件
  • 支持查询结果集导出csv、tsv、xml、json、xlsx、yaml、html功能

二、安装使用xorm，注意连接的关闭！

import (
    _ "github.com/go-sql-driver/mysql"
    "xorm.io/xorm"
)

然后我们就可以构造一个new方法来初始化使用 orm客户端了。

我们在下面的代码，会通过一个函数返回 xorm.EngineInterface，以及一个 engine.Close()函数供使用者调用，之所以这样是因为，有些比如脚本脚本之类的

当执行完，就需要把 mysql连接关闭掉，以用来节省连接数。

如果都不关闭的话，在高并发的情况下，连接数很多，会把mysql打爆！

type MysqlClient xorm.EngineInterface
func NewMysqlClient() (MysqlClient, func(), error) {
    // 创建 engine 对象
    engine, err := xorm.NewEngine("mysql", "user:pwd@tcp(ip:port)/dbname?charset=utf")
    if err != nil {
        fmt.Printf("init engine fail! err:%+v", err)
    }
    // 连接池配置
    engine.SetMaxOpenConns()                  // 最大 db 连接
    engine.SetMaxIdleConns()                  // 最大 db 连接空闲数
    engine.SetConnMaxLifetime( * time.Minute) // 超过空闲数连接存活时间

    // 日志相关配置
    engine.ShowSQL(true)                    // 打印日志
    engine.Logger().SetLevel(log.LOG_DEBUG) // 打印日志级别
    engine.SetLogger(log.SimpleLogger{})    // 设置日志输出 (控制台, 日志文件, 系统日志等)

    // 测试连通性
    if err = engine.Ping(); err != nil {
        fmt.Printf("ping to db fail! err:%+v", err)
    }
    return engine, func() {
        engine.Close()
    }, err
}

关于连接数的坑以及engine.Close()

engine可以通过engine.Close来手动关闭，但是一般情况下可以不用关闭，在程序退出时会自动关闭。

但是如果，每个连接都是新建了一个 client的话，一般http服务不会退出，如果此时高并发，就会增加无数的mysql连接数，打爆mysql。

在这个NewMysqlClient函数里我们创建了一个 全局的变量 MysqlClient,全局共用一个连接。

常用方法介绍

engine.SetMaxOpenConns(30) 创建连接池

engine.ShowSQL(true) 在控制台打印sql语句

engine.Logger().SetLevel(log.LOG_DEBUG) 在控制台打印调试及以上的信息

engine.SetLogger(log.DiscardLogger{}) 把日志写入到文件，或者专门的日志收集系统里。

三、mysql生产struct

使用官方自带的reverse工具 https://gitea.com/xorm/reverse比如我们现在在有一个表

CREATE TABLE `user` (
  `id` int() NOT NULL AUTO_INCREMENT,
  `name` varchar() DEFAULT NULL,
  `status` smallint() DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB

我们使用 reverse -f sql_reverse.yaml 来生成 struct

sql_reverse.yaml的代码如下：

# 步骤：安装 go get xorm.io/reverse
# 步骤：修改上面文件中的conn_str以及include_tables的表
# 步骤：执行reverse -f sql_reverse.yaml

kind: reverse
name: mydb
source:
  database: mysql
  conn_str: 'user:pasword@tcp(localhost:)/test?charset=utf8mb4'
targets:
  - type: codes
    language: golang
    include_tables: # 需要生成的表的结构
      - user //我们要生产的表明
    multiple_files: true
    output_dir: ./internal/domain/flow/repository/po
    template: |
      package po

      {{$ilen := len .Imports}}
      {{if gt $ilen}}
      import (
        {{range .Imports}}"{{.}}"{{end}}
      )
      {{end}}

      {{range .Tables}}
      type {{TableMapper .Name}} struct {
      {{$table := .}}
      {{range .ColumnsSeq}}{{$col := $table.GetColumn .}}    {{ColumnMapper $col.Name}}    {{Type $col}} `{{Tag $table $col}}`
      {{end}}
      }

      func (m *{{TableMapper .Name}}) TableName() string {
          return "{{$table.Name}}"
      }
      {{end}}
    template_path: ./template/goxorm.tmpl # template path for code file, it has higher perior than template field on language

生成对应的go代码为

type User struct {
    Id     int  `json:"id" xorm:"'id' int(11) not null pk autoincr  "`
    Name   string `json:"name" xorm:"'name' varchar() null   "`
    Status int  `json:"status" xorm:"'status' smallint(3) null   "`
}

func (m *User) TableName() string {
    return "user"
}

四、xorm常用操作示例--insert数据

4.1 insert 增加1条数据

增加一条对象。

engine, _, _ := NewMysqlClient()
    u := User{
        Name:   "hisheng",
        Status:,
    }
    affected, err := engine.Insert(&u)
    t.Log(affected, err)

4.2 insert 增加多条数据

多条数据，还是Insert方法，参数为slice就行。

func TestInsertUsers(t *testing.T) {
    engine, _, _ := NewMysqlClient()
    us := []User{{Name: "hi", Status:}, {Name: "sheng", Status: 1}}
    affected, err := engine.Insert(&us)
    t.Log(affected, err)
}

当插入多条数据的时候，官方建议我们少于150条数据，多余150条数据的时候，容易插入失败。

4.3 insert 增加不同表数据

user := new(User)
user.Name = "myname"
...
questions := make([]Question,)
questions[].Content = "whywhywhwy?"
affected, err := engine.Insert(user, &questions)

五、xorm常用操作示例--删除某行

5.1 通过id删除

user := new(User)
affected, err := engine.ID(id).Delete(user)

5.2 通过where条件删除

user := new(User)
affected, err := engine.Where("id = ?",).Delete(user)

5.3 软删除，通过某个字段实现软删除，比如status=0

这个用更新的方法

u := User{
        Status:,
    }
    affected, err := engine.Where("id = ?",).MustCols("status").Update(&u)
    t.Log(affected, err)

注意这里，增加了一个MustCols，因为xorm默认是有值自动更新的，而status和默认值，是一样的，默认值会被忽略而不被更新，此时要更新，需要加一个 MustCols字段。

六、xorm常用操作示例--update更新操作

6.1 以结构体的参数，传递要更新的字段

func TestUpdate(t *testing.T) {
    engine, _, _ := NewMysqlClient()
    u := User{
        Name: "",
    }
    affected, err := engine.ID().Update(&u)
}

这个会Update的参数是更新字段。这里会更新Name字段。

6.2 以map做为参数，传递要更新的字段

以map作为要更新的字段，传递方式，map的格式为 map[string]interface{}

func TestUpdateMap(t *testing.T) {
    engine, _, _ := NewMysqlClient()
    u := map[string]interface{}{"name": ""}
    affected, err := engine.ID().Update(u)
}

6.3指定字段更新，未指定的将不更新，指定了的即使为0也会更新。

我们通过添加Cols函数指定需要更新结构体中的值。

affected, err := engine.ID(id).Cols("age").Update(&user)

6.4指定字段更新，未指定的根据值是否是有值来更新。

有时候希望能够指定必须更新某些字段，而其它字段根据值的情况自动判断，可以使用 MustCols 来组合 Update 使用。

affected, err := engine.ID(id).MustCols("age").Update(&user)

七、xorm常用操作示例--查询单条

查询单条数据使用Get方法，在调用Get方法时需要传入一个对应结构体的指针，同时结构体中的非空field自动成为查询的条件和前面的方法条件组合在一起查询。

7.1 根据主键Id来获得单条数据:

user := new(User)
has, err := engine.ID(id).Get(user)

7.2 根据where来获得单条数据:

user := new(User)
has, err := engine.Where("name=?", "xlw").Get(user)

7.3 根据user机构体中非空数据来获得单条数据:

user := &User{Id:}
has, err := engine.Get(user)

八、xorm常用操作示例--查询多条数据

查询多条数据使用Find方法，Find方法的第一个参数为slice的指针或Map指针，即为查询后返回的结果，第二个参数可选，为查询的条件struct的指针。

8.1 返回结果为 结构体slice:

everyone := make([]User,)
err := engine.Find(&everyone)

8.2 返回结果为 结构体map:

users := make(map[int]User)
err := engine.Find(&users)

九、xorm常用操作示例--FindAndCount 分页

FindAndCount 返回结果为 结构体slice 以及总数:

everyone := make([]User,)
count,err := engine.Limit(,20).FindAndCount(&everyone)

十、xorm常用操作示例--事务操作

func TestTransaction(t *testing.T) {
    engine, _, _ := NewMysqlClient()
    session := engine.NewSession()
    defer session.Close()
    if err := session.Begin(); err != nil {
        fmt.Println(err)
        return
    }
    if _, err := session.Insert(&User{Name: "", Status: 0}); err != nil {
        fmt.Println(err)
        _ = session.Rollback()
        return
    }
    _ = session.Commit()
}
关于Go你不得不知道的一些实用小技巧
上一篇
深入了解Go的HttpClient超时机制
下一篇