背景

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語言，了解了一種全新的並發編程模式，給自己生成了一個方便的工具。

golang實現mysql數據庫備份