Golang 学习笔记（12）—— ORM实现

本文为转载，原文：Golang 学习笔记（12）—— ORM实现

Golang

介绍

本文将利用之前所学习到的内容实现一个简单的orm，实现比较简单，没有考虑过多的设计原则，以及性能安全之类的，只是单纯的以学习为导向，做的一个练手的小工具。其中有不合理的地方还请看到的同学见谅，并指出，本人也好加以改正。

实现

首先看下完整的代码目录吧：


代码目录

数据库

数据库，这里我选择mysql数据库，可以用以下sql语句创建一个测试的表：

CREATE TABLE `userinfo` (
    `uid` INT(10) NOT NULL AUTO_INCREMENT,
    `username` VARCHAR(64) NULL DEFAULT NULL,
    `departname` VARCHAR(64) NULL DEFAULT NULL,
    `created` DATE NULL DEFAULT NULL,
    PRIMARY KEY (`uid`)
)

go

实体

建完表之后，我们在go中需要穿件一个与之对应的struct

type UserInfo struct{
    TableName orm.TableName "userinfo"
    UserName string `name:"username"`
    Uid int `name:"uid"PK:"true"auto:"true"`
    DepartName string `name:"departname"`
    Created string `name:"created"`
}

从struct中可以看到，我们的字段分为两部分，第一个就是TableName，该字段没有具体内容，只是使用后面的tag标记其对应的数据库表名，剩余的则是与数据库表字段一一对应的字段了。
每个字段的tag则说明了其在数据库的属性。name表示在数据库中的字段名，不写则与字段名一致，PK表示是否为主键，若为主键则标记为"ture"，默认为false，auto表示是否为自增长，若为自增长则标记为"true"，默认为false，由于我的设计比较简单，所以，先就标记这几种属性。

反射对象

既然有了实体对象，自然我们要通过反射去解析该对象。该代码写在orm/orm.go代码文件中。

package orm

import (
    "fmt"
    "database/sql"
    "errors"
    "strings"
    "reflect"
)

/*
  表信息
*/
type TableInfo struct{
    Name string  //表名
    Fields []FieldInfo //表字段信息
    TMMap map[string]string //表字段与实体字段名映射关系，key为表字段名，val为实体字段名
}

/*
  表字段详细信息
*/
type FieldInfo struct{
    Name string
    IsPrimaryKey bool
    IsAutoGenerate bool
    Valve reflect.Value
}

/*
  实体对象信息
*/
type ModelInfo struct{
    TableInfo  // 实体对应的表信息
    TbName string // 表名称
    Model interface{} //实体实例
}

//表名
type TableName string
//表名类型
var typeTableName TableName
var tableNameType reflect.Type = reflect.TypeOf(typeTableName)

//实体映射，key为表名，val为实体信息
var ModelMapping map[string]ModelInfo

/*
  注册实体，每当有一个实体时，需要调用该方法注册。
  注册到 ModelMapping
*/
func Register(model interface{}){
    if ModelMapping == nil{
        ModelMapping = make(map[string]ModelInfo)
    }
    tbInfo, _ := getTableInfo(model)
    ModelMapping[tbInfo.Name] = ModelInfo{TbName:tbInfo.Name, Model:model}
}

/*
  根据实体通过反射获取表信息
  返回表信息
*/
func getTableInfo(model interface{})(tabInfo *TableInfo, err error){
    defer func(){
        if e := recover(); err != nil{
            tabInfo = nil
            err = e.(error)
        }
    }()

    err = nil
    tabInfo = &TableInfo{}
    tabInfo.TMMap = make(map[string]string)
    rt := reflect.TypeOf(model)
    rv := reflect.ValueOf(model)

    tabInfo.Name = rt.Name()
    if rt.Kind() == reflect.Ptr{
        rt = rt.Elem()
        rv = rv.Elem()
    }
    //字段解析
    for i, j := 0, rt.NumField(); i < j; i++{
        rtf := rt.Field(i)
        rvf := rv.Field(i)
        if rtf.Type == tableNameType{
            tabInfo.Name = string(rtf.Tag)
            continue
        }
        if rtf.Tag == "-"{
            continue
        }
        //解析字段的tag
        var f FieldInfo
        //没有tag,表字段名与实体字段ing一致
        if rtf.Tag == ""{
            f = FieldInfo{Name:rtf.Name, IsAutoGenerate:false, IsPrimaryKey:false, Valve:rvf}
            tabInfo.TMMap[rtf.Name] = rtf.Name
        }else{
            strTag := string(rtf.Tag)
            if strings.Index(strTag, ":") == -1{
                //tag中没有":"时，表字段名与实体字段ing一致
                f = FieldInfo{Name:rtf.Name, IsAutoGenerate:false, IsPrimaryKey:false, Valve:rvf}
                tabInfo.TMMap[rtf.Name] = rtf.Name
            }else{
                //解析tag中的name值为表字段名
                strName := rtf.Tag.Get("name")
                if strName == ""{
                    strName = rtf.Name
                }
                //解析tag中的PK
                isPk := false
                strIspk := rtf.Tag.Get("PK")
                if strIspk == "true"{
                    isPk = true
                }
                //解析tag中的auto
                isAuto := false
                strIsauto := rtf.Tag.Get("auto")
                if strIsauto == "true"{
                    isAuto = true
                }
                f = FieldInfo{Name:strName, IsPrimaryKey:isPk, IsAutoGenerate:isAuto, Valve:rvf}
                tabInfo.TMMap[strName] = rtf.Name
            }
        }
        tabInfo.Fields = append(tabInfo.Fields, f)
    }
    return
}

/*
  根据实体生成插入语句
*/
func generateInsertSql(model interface{})(string, []interface{}, *TableInfo, error){
    //获取表信息
    tbInfo, err := getTableInfo(model)
    if err != nil{
        return "", nil, nil, err
    }
    if len(tbInfo.Fields) == 0 {
        return "", nil, nil, errors.New(tbInfo.Name + "结构体中没有字段")
    }

    //根据字段信息拼Sql语句，以及参数值
    strSql := "insert into " + tbInfo.Name
    strFileds := ""
    strValues := ""
    var params []interface{}
    for _, v := range tbInfo.Fields{
        if v.IsAutoGenerate {
            continue
        }
        strFileds += v.Name + ","
        strValues += "?,"
        params = append(params, v.Valve.Interface())
    }
    if strFileds == ""{
        return "", nil, nil, errors.New(tbInfo.Name + "结构体中没有字段，或只有自增字段")
    }
    strFileds = strings.TrimRight(strFileds, ",")
    strValues = strings.TrimRight(strValues, ",")
    strSql += " (" + strFileds + ") values(" + strValues + ")"
    fmt.Println("sql: ",strSql)
    fmt.Println("params: ",params)
    return strSql, params, tbInfo, nil
}

/*
  根据实体生成修改的sql语句
*/
func generateUpdateSql(model interface{})(string, []interface{}, error){
    //获取表信息
    tbInfo, err := getTableInfo(model)
    if err != nil{
        return "", nil, err
    }
    if len(tbInfo.Fields) == 0 {
        return "", nil, errors.New(tbInfo.Name + "结构体中没有字段")
    }
    //根据字段信息拼Sql语句，以及参数值
    strSql := "update " + tbInfo.Name + " set "
    strFileds := ""
    strWhere := ""
    var p interface{}
    var params []interface{}
    for _, v := range tbInfo.Fields{
        if v.IsAutoGenerate && !v.IsPrimaryKey{
            continue
        }
        if v.IsPrimaryKey{
            strWhere += v.Name + "=?"
            p = v.Valve.Interface()
            continue
        }
        strFileds += v.Name + "=?,"
        params = append(params, v.Valve.Interface())
    }
    params = append(params, p)
    strFileds = strings.TrimRight(strFileds, ",")
    strSql += strFileds + " where " + strWhere
    fmt.Println("update sql: ", strSql)
    fmt.Println("update params: ", params)
    return strSql, params, nil
}

/*
  自动生成删除的sql语句，以主键为删除条件
*/
func generateDeleteSql(model interface{})(string, []interface{}, error){
    //获取表信息
    tbInfo, err := getTableInfo(model)
    if err != nil{
        return "", nil, err
    }
    //根据字段信息拼Sql语句，以及参数值
    strSql := "delete from " + tbInfo.Name + " where "
    var idVal interface{}
    for _, v := range tbInfo.Fields{
        if v.IsPrimaryKey{
            strSql += v.Name + "=?"
            idVal = v.Valve.Interface()
        }
    }
    params := []interface{}{idVal}
    fmt.Println("update sql: ", strSql)
    fmt.Println("update params: ", params)
    return strSql, params, nil
}

/*
  设置自增长字段的值
*/
func setAuto(result sql.Result, tbInfo *TableInfo)(err error){
    defer func(){
        if e := recover(); e != nil{
            err = e.(error)
        }
    }()
    id, err := result.LastInsertId()
    if id == 0{
        return
    }
    if err != nil{
        return
    }
    for _, v := range tbInfo.Fields{
        if v.IsAutoGenerate && v.Valve.CanSet(){
            v.Valve.SetInt(id)
            break
        }
    }
    return
}

这里面，我们实现了通过model实体，来生成新增，修改，删除的sql语句，以及参数。但是查询的怎么办呢？

MyRows

在orm/MyRows.go代码文件中，实现了一个自己的Rows，来处理查询：

package orm

import (
    "strconv"
    "reflect"
    "database/sql"
)

type MyRows struct{
    * sql.Rows
    Values map[string]interface{} //表字段和值的映射
    ColumnNames []string //表字段名集合
}

/*
  获取数据
*/
func (this *MyRows)Next()bool{
    bResult := this.Rows.Next()
    if bResult{
        //获取表字段名称集合
        if this.ColumnNames == nil || len(this.ColumnNames) == 0{
            this.ColumnNames, _ = this.Rows.Columns()
        }
        //初始化表字段和值的映射
        if this.Values == nil{
            this.Values = make(map[string]interface{})
        }
        //调用scan函数的参数
        scanArgs := make([]interface{}, len(this.ColumnNames))
        //scan函数的值
        values := make([][]byte, len(this.ColumnNames))
        for i := range values{
            scanArgs[i] = &values[i]
        }
        this.Rows.Scan(scanArgs...)
        //将结果存放到Values中
        for i := 0; i < len(this.ColumnNames); i++{
            this.Values[this.ColumnNames[i]] = values[i]
        }
    }
    return bResult
}

/*
  将数据映射到实体切片
  tbname：U对应的数据表名
*/
func (this *MyRows)To(tbname string) ([]interface{},error){
    mi := ModelMapping[tbname]
    ti, _ := getTableInfo(mi.Model)
    var models []interface{}
    for this.Next(){
            v := reflect.New(reflect.TypeOf(mi.Model).Elem()).Elem()
            for k, val := range this.Values{
                f := v.FieldByName(ti.TMMap[k])
                var strVal string
                if bt, ok := val.([]byte); ok{
                    strVal = string(bt)
                    switch f.Type().Name(){
                    case "int":
                        i, _ := strconv.ParseInt(strVal, 10, 64)
                        f.SetInt(i)
                        break
                    case "string":
                        f.SetString(strVal)
                        break
                    }
                }
            }
            models = append(models, v.Interface())
    }
    return models, nil
}

该代码实现了查询结果到实体的映射

MysqlDB

orm/MysqlDB.go是实现数据库方法的代码文件。

package orm

import (
    "strconv"
    "reflect"
    "database/sql"
)

type MyRows struct{
    * sql.Rows
    Values map[string]interface{} //表字段和值的映射
    ColumnNames []string //表字段名集合
}

/*
  获取数据
*/
func (this *MyRows)Next()bool{
    bResult := this.Rows.Next()
    if bResult{
        //获取表字段名称集合
        if this.ColumnNames == nil || len(this.ColumnNames) == 0{
            this.ColumnNames, _ = this.Rows.Columns()
        }
        //初始化表字段和值的映射
        if this.Values == nil{
            this.Values = make(map[string]interface{})
        }
        //调用scan函数的参数
        scanArgs := make([]interface{}, len(this.ColumnNames))
        //scan函数的值
        values := make([][]byte, len(this.ColumnNames))
        for i := range values{
            scanArgs[i] = &values[i]
        }
        this.Rows.Scan(scanArgs...)
        //将结果存放到Values中
        for i := 0; i < len(this.ColumnNames); i++{
            this.Values[this.ColumnNames[i]] = values[i]
        }
    }
    return bResult
}

/*
  将数据映射到实体切片
  tbname：U对应的数据表名
*/
func (this *MyRows)To(tbname string) ([]interface{},error){
    mi := ModelMapping[tbname]
    ti, _ := getTableInfo(mi.Model)
    var models []interface{}
    for this.Next(){
            v := reflect.New(reflect.TypeOf(mi.Model).Elem()).Elem()
            for k, val := range this.Values{
                f := v.FieldByName(ti.TMMap[k])
                var strVal string
                if bt, ok := val.([]byte); ok{
                    strVal = string(bt)
                    switch f.Type().Name(){
                    case "int":
                        i, _ := strconv.ParseInt(strVal, 10, 64)
                        f.SetInt(i)
                        break
                    case "string":
                        f.SetString(strVal)
                        break
                    }
                }
            }
            models = append(models, v.Interface())
    }
    return models, nil
}

详情请见注释

调用

package main

import (
    "time"
    "fmt"
    "stu_demo/orm"
    _ "github.com/go-sql-driver/mysql"
)

type UserInfo struct{
    TableName orm.TableName "userinfo"
    UserName string `name:"username"`
    Uid int `name:"uid"PK:"true"auto:"true"`
    DepartName string `name:"departname"`
    Created string `name:"created"`
}

func main(){
    ui := UserInfo{UserName:"CHAIN", DepartName:"TEST", Created:time.Now().String()}
    orm.Register(new(UserInfo))
    db, err := orm.NewDb("mysql", "root:pwd@tcp(xxx.xxx.xxx.xxx:x3306/demo?charset=utf8")
    if err != nil {
        fmt.Println("打开SQL时出错:", err.Error())
        return
    }
    defer db.Close()
    
    //插入测试
    err = db.Insert(&ui)
    if err != nil {
        fmt.Println("插入时错误:", err.Error())
    }
    fmt.Println("插入成功")
    //修改测试
    ui.UserName = "BBBB"
    err = db.Update(ui)
    if err != nil {
        fmt.Println("修改时错误:", err.Error())
    }
    fmt.Println("修改成功")
    //删除测试
    err = db.Delete(ui)
    if err != nil {
        fmt.Println("删除时错误:", err.Error())
    }
    fmt.Println("删除成功")
    //查询测试
    res, err := db.From("userinfo").
    Select("username", "departname", "uid").
    Where("uid__gt", 20).
    Where("username", "chain").Get()
    if err != nil{
        fmt.Println("err: ", err.Error())
    }
    fmt.Println(res)
}
运行结果

源码

github 源码地址

完

转载请注明出处：
Golang 学习笔记（12）—— ORM实现

目录
上一节：Golang 学习笔记（11）—— 反射
下一节：Golang Web学习（13）—— 搭建简单的Web服务器

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 157,012评论 4赞 359
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 66,589评论 1赞 290
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 106,819评论 0赞 237
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,652评论 0赞 202
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 51,954评论 3赞 285
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,381评论 1赞 210
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,687评论 2赞 310
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,404评论 0赞 194
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,082评论 1赞 238
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,355评论 2赞 241
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,880评论 1赞 255
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,249评论 2赞 250
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 32,864评论 3赞 232
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,007评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,760评论 0赞 192
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,394评论 2赞 269
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,281评论 2赞 259