Golang通用数据库单记录转json

你在学习Golang相关的知识吗？本文《Golang通用数据库单记录转json》，主要介绍的内容就涉及到，如果你想提升自己的开发能力，就不要错过这篇文章，大家要知道编程理论基础和实战操作都是不可或缺的哦！

我想从数据库中检索记录并将其编组为 json。 我有大约 30 个不同的表，因此我想要适用于所有或任何这些表的通用函数。我使用 xorm 进行数据库访问。

我已经成功创建了检索数据的 dry 函数，这主要归功于这个问题和答案

这有效，可以将所有记录编组为 json：

type user struct {
   id   int64  `json:"id"`
   name string `json:"name"`
}
// type post
// etc.

type tablerecord struct {
    primarykey string
    data       interface{}
}

var listoftables = map[string]tablerecord{
    "users":{"id", &[]user{}},  // type user is struct for xorm with json annotation
    //"posts":{"post_id", &[]post{}},
    // etc.. 
}

for tablename, rec := range listoftables {
    err := xorm.find(rec.data)
    if err != nil {
        log.print(err)
    }

    out, err := json.marshal(rec.data)
    if err != nil {
        log.print(err)
    }
    log.print(string(out)) // this yields json array
}

但是，我很难将单个记录编组为 json。 我一直在寻找迭代持有切片的接口{}的方法，找到了这个和类似的主题。尝试过：

switch reflect.typeof(reflect.valueof(rec.data).elem().interface()).kind() {
case reflect.slice:
    s := reflect.valueof(reflect.valueof(rec.data).elem().interface())
    for i := 0; i < s.len(); i++ {
        entry := s.index(i)
        log.printf("%v\n", entry) // prints {1 john doe}
        // log.print(reflect.valueof(entry))
        data, err := json.marshalindent(entry, " ", "  ")
        if err != nil {
            log.print(err)
        }
        log.println(string(data)) // prints {} empty
    }
}

当然，如果我指定 rec.data 是 *[]user 它可以工作，但随后我必须为每个表重写这样的代码，这不是我想要的。

switch t := rec.data.(type) {
case *[]user:
    for _, entry := range *t {
        // log.printf("loop %v", entry)
        data, err := json.marshalindent(entry, " ", "  ")
        if err != nil {
            log.print(err)
        }
        log.println(string(data)) // yields needed json for single record
    }
}

或者也许有一种完全不同的、更好的方法来解决这个问题 - 数据库的任何记录到 json。

更新 现在的问题是，xorm 需要该结构吗？我将不得不阅读 xorm 的可能性和局限性。

slice := record.Slice()
log.Print(reflect.TypeOf(slice))

err = env.hxo.In(record.PrimaryKey(), insertIds).Find(slice) // or &slice
if err != nil {
    log.Print(err) // Table not found
}

// this works
var slice2 []*user
err = env.hxo.In(record.PrimaryKey(), insertIds).Find(&slice2)
if err != nil {
    log.Print(err) // 
}

解决方案

因此，正如我在评论中提到的，如果您希望能够从 tablerecord.data 字段获取单个元素，最简单的方法是将字段类型更改为实际类型：

type tablerecord struct {
    primarykey string
    data       []interface{} // slice of whatever
}

这样，您就可以编写一些非常通用的内容：

for tbl, record := range records {
    fmt.printf("first record from table %s\n", tbl)
    b, _ := json.marshalindent(record[0], " ", "  ")
    fmt.println(string(b))
    fmt.prinln("other records...")
    b, _ = json.marshalindend(record[1:], " ", "  ")
    fmt.println(string(b))
}

不过，如果我是你，我会考虑在我的数据库类型中实现一个接口。大致如下：

type dbtype interface {
    primarykey() string
    tablename() string // xorm can use this to get the table name
    slice() []dbtype // can return []user or whatever
}

所以你真的不再需要 tablerecord 类型，并且可以使用这样的 var：

listoftables := []dbtype{user{}, ...}
for _, tbl := range listoftables {
    data := tbl.slice()
    // find data here
    fmt.printf("first record from table %s\n", tbl.tablename())
    b, _ := json.marshalindent(data[0], " ", "  ")
    fmt.println(string(b))
    fmt.prinln("other records...")
    b, _ = json.marshalindend(data[1:], " ", "  ")
    fmt.println(string(b))
}

所以，我的回答/评论中缺少的内容是 tl;dr：

• 从类型 []user{}（或 []dbtable）到 []interface{} 不起作用，因为您无法将切片中的所有元素转换为一个单一的表达。您必须创建 []interface{} 类型的第二个切片并复制值，如下所示：

  slice := uservar.slice() 数据 := make([]interface{}, len(slice)) for i := 范围切片 { data[i] = slice[i] // 将类型复制到 interface{} slice } 返回 tablerecord{uservar.primarykey(), data}

我创建了一个小型工作示例，说明如何使用上述接口。

DEMO

为了避免太多混乱，您可以更改 slice 函数以立即返回 []interface{}：

func(v t) slice() []interface{
    return []interface{
        &t{},
    }
}

您的 slice 实现的问题在于您有如下内容：

func (u *user) slice() []dbtable {
    u = &user{} // you're re-assigning the receiver, losing all state!
    return []dbtable{u}
}

接收器是指针类型，因此您所做的任何重新分配都会影响调用 func 的变量。这不是一个好主意。只需使用值接收器，或者，如果您想确保接口仅在指针变量上实现（常见技巧，例如 grpc 使用的技巧）就是实现如下所示的函数：

func(*user) slice() []dbtable{
    return []dbtable{&user{}}
}

使用协议缓冲区时生成的 pb.go 文件中可以找到此技巧的一个很好的示例。消息类型将具有如下功能：

func(*MsgType) ProtoMessage() {}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。