欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

golang实现mysql数据库备份的操作方法

程序员文章站 2022-04-16 11:49:16
背景 navicat是mysql可视化工具中最棒的,但是,在处理视图的导入导出方面,它是按照视图名称的字母顺序来处理的,若视图存在依赖,在导入过程中就会报错。前面已经用p...

背景

navicat是mysql可视化工具中最棒的,但是,在处理视图的导入导出方面,它是按照视图名称的字母顺序来处理的,若视图存在依赖,在导入过程中就会报错。前面已经用python写了一个,但在使用过程中,遇到xfffd编码,python的pymysql会直接崩溃。发现golang没有这个问题,正好用go重写,来熟悉golang。

一些关键点

  1. map & json,在处理主键与外键信息时,需要用到json数据结构来存储中间结果,因为要灵活处理,在golang中只能用map[string]interface{}来处理。
  2. interface{} 相当于java中的object,能接受任意数据类型,方便但在使用时要做到心中有数,不然一旦数据类型不匹配,程序就会崩溃。
  3. xfffd ,utf8中的占位符,超出范围的utf8mb4入库后,会被存储为xfffd,数据导出时,需要过滤掉。
  4. goroutine, golang的并发支持很独特,我们的工具支持多个库同时备份,很容易使用goroutine来实现并行。

代码解析

按功能模块对核心代码进行说明

main.go,并发、命令行参数

使用命令行参数,接受一个参数,来指定备份的内容

package common

type opflag struct {
  tables bool      //表结构
  datum bool       //表结构和数据
  views bool       //视图
  funcs bool       //函数与存储过程
}

main.go,程序入口,处理命令行参数  

 if len(os.args) > 1 {
    flag = common.opflag{
      tables: false,
      datum: false,
      views: false,
      funcs: false,
    }
    switch os.args[1] {     //接受一个参数
    case "table":
      flag.tables = true    //根据参数设定标识量
    case "data":
      flag.tables = true
      flag.datum = true
    case "views":
      flag.views = true
    case "funcs":
      flag.funcs = true
    default:          //参数不正确,报错退出
      log.fatal("you arg must be in : table, data, views or funcs.")
    }
  }else{            //无参数,默认导出所有
    flag = common.opflag{
      tables: true,
      datum: true,
      views: true,
      funcs: true,
    }
  }
  err := backup.export(flag) 根据参数进行数据库备份

export.go

备份主流程,根据configs.json生成goroutine来备份数据库,并等待完成。

var configs interface{}
  fr, err := os.open("./configs.json")
  if err != nil {
    return err
  }
  decoder := json.newdecoder(fr)         //解析配置文件
  err = decoder.decode(&configs)
  confs := configs.(map[string]interface{})
  workdir := confs["workdir"].(string)
  ch := make(chan string)            //通道变量
  for key, value := range confs {
    if strings.hasprefix(key, "db_") {
      dbconf := value.(map[string]interface{})
      dbconn := common.dbconnfields{   //数据库相应配置
        dbhost:  dbconf["db_host"].(string),
        dbport:  int(dbconf["db_port"].(float64)),
        dbuser:  dbconf["db_user"].(string),
        dbpass:  dbconf["db_pass"].(string),
        dbname:  dbconf["db_name"].(string),
        dbcharset: dbconf["db_charset"].(string),
      }
      if dbconf["file_alias"] != nil {  //生成sql备份文件的命名
        dbconn.filealias = dbconf["file_alias"].(string)
      }
      go exportone(dbconn, workdir, ch, flag) //创建协程
    }
  }
  for key := range confs {            //阻塞主进程,待所有协程完成工作
    if strings.hasprefix(key, "db_") {
      fmt.print( <- ch )
    }
  }
  return nil

你需要编写如下的配置文件来描述你要备份的数据库:

{
  "db_name1": {
    "db_host": "192.168.1.8",
    "db_port": 3306,
    "db_user": "root",
    "db_pass": "123456",
    "db_name": "name1",
    "db_charset": "utf8mb4",
    "file_alias": "file name1"
  },
  "db_name2": {
    "db_host": "localhost",
    "db_port": 3306,
    "db_user": "root",
    "db_pass": "123456",
    "db_name": "name2",
    "db_charset": "utf8mb4"
  },
  "database_dialect": "mysql",
  "workdir": "/home/zhoutk/gocodes/gotools/"
}

exportone.go

备份一个数据库      

filename := fields.filealias
  setsqlheader(fields, filename)      //设置导出文件说明
  if flag.tables {            //如果表设置为真,导出表结构
    err := exporttables(filename, fields, flag)  //具体算法请参照源代码
    if err != nil {
      ch <- fmt.sprintln("error: ", fields.dbname, "\t export tables throw, \t", err)
      return
    }
  }
  if flag.views {            //如果视图设置为真,导出视图
    err := exportviews(filename, fields)//具体算法请参照源代码,或python算法
    if err != nil {
      ch <- fmt.sprintln("error: ", fields.dbname, "\t export views throw, \t", err)
      return
    }
  }
  if flag.funcs {        //如果函数设置为真,导出函数和存储过程
    err := exportfuncs(filename, fields)//具体算法请参照源代码
    if err != nil {
      ch <- fmt.sprintln("error: ", fields.dbname, "\t export funcs throw, \t", err)
      return
    }
  }
  //导出工作完成,向通道输入信息
  ch <- fmt.sprintln("export ", fields.dbname, "\t success at \t", time.now().format("2006-01-02 15:04:05"))  

mysqldao.go

数据库查询通用封装,此工具只使用了executewithdbconn。灵活的使用map与interface{},将结果转化为键值对象返回。

func executewithdbconn(sql string, values []interface{}, fields common.dbconnfields) (map[string]interface{}, error) {
  rs := make(map[string]interface{})
  dao, err := mysql.open("mysql", fields.dbuser + ":"+fields.dbpass+"@tcp("+fields.dbhost+":"+
    strconv.itoa(fields.dbport)+")/"+fields.dbname+"?charset="+fields.dbcharset)
  defer dao.close()
  if err != nil {
    rs["code"] = 204
    return rs, err
  }
  stmt, err := dao.prepare(sql)
  if err != nil {
    rs["code"] = 204
    return rs, err
  }
  rows, err := stmt.query(values...)
  if err != nil {
    rs["code"] = 204
    return rs, err
  }
  columns, err := rows.columns()    //取出字段名称
  vs := make([]mysql.rawbytes, len(columns))
  scans := make([]interface{}, len(columns))
  for i := range vs {         //预设取值地址
    scans[i] = &vs[i]
  }
  var result []map[string]interface{}
  for rows.next() {
    _ = rows.scan(scans...)    //塡入一列值
    each := make(map[string]interface{})
    for i, col := range vs {
      if col != nil {
        each[columns[i]] = filterholder(string(col)) //过滤/xfffd
      }else{
        each[columns[i]] = nil
      }
    }
    result = append(result, each)
  }
  rs["code"] = 200
  //data, _ := json.marshal(result)
  rs["rows"] = result
  return rs, err
}

项目地址

https://github.com/zhoutk/gotools

使用方法

git clone https://github.com/zhoutk/gotools
cd gotools
go get
go run main.go
go buid main.go
./main         #export all things of database
./main table      #export tables
./main data       #export tables & data
./main views      #export views
./main funcs      #export funcs & stored procedures

总结

以上所述是小编给大家介绍的golang实现mysql数据库备份的操作方法,希望对大家有所帮助