XORM框架JSON字段怎么映射?结构体处理方法
在xorm中,处理json字段最直接的方法是使用`sql.nullstring`或自定义类型实现`driver.valuer`和`sql.scanner`接口。对于go 1.13+版本,推荐使用`json.rawmessage`配合自定义类型,或者直接使用支持json序列化的第三方库如`github.com/guregu/null`。核心思路是将json字符串的存储与解析逻辑封装在结构体字段的类型定义中,确保xorm在读写数据库时自动调用序列化/反序列化方法。

使用NullString处理可空JSON字段
当JSON字段允许为NULL时,应使用`sql.NullString`作为基础类型,并扩展其方法以支持JSON解析。这种方法简单可靠,适用于大多数场景。通过实现`Value()`和`Scan()`接口,可以在数据库交互时自动处理JSON编码和解码。

exa-js 是 Exa 官方 JavaScript 软件开发工具包,Exa 是一个为 AI 工作流构建的网络搜索 API。它为代理提供了一种具体的方式来搜索网络、检索页面内容,并从代码中生成有来源的答案,而不是手动拼接原始 HTTP 调用。
package main
import (
"database/sql"
"encoding/json"
"fmt"
"log"
"xorm.io/xorm"
)
// NullJSON 扩展 sql.NullString 以支持 JSON 解析
type NullJSON struct {
sql.NullString
}
// Scan 实现 sql.Scanner 接口
func (n *NullJSON) Scan(value interface{}) error {
if value == nil {
n.NullString.Valid = false
return nil
}
n.NullString.String = string(value.([]byte))
n.NullString.Valid = true
return nil
}
// Value 实现 driver.Valuer 接口
func (n NullJSON) Value() (interface{}, error) {
if !n.NullString.Valid {
return nil, nil
}
return n.NullString.String, nil
}
// Unmarshal 将 JSON 字符串解析为目标结构体
func (n NullJSON) Unmarshal(v interface{}) error {
if !n.NullString.Valid {
return fmt.Errorf("null json")
}
return json.Unmarshal([]byte(n.NullString.String), v)
}
// Marshal 将结构体序列化为 JSON 字符串
func (n *NullJSON) Marshal(v interface{}) error {
data, err := json.Marshal(v)
if err != nil {
return err
}
n.NullString.String = string(data)
n.NullString.Valid = true
return nil
}
// User 示例结构体
type User struct {
ID int64 `xorm:"id autoincr"`
Name string `xorm:"name"`
Data NullJSON `xorm:"data json"`
}
func main() {
engine, err := xorm.NewEngine("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
if err != nil {
log.Fatal(err)
}
defer engine.Close()
// 创建表
err = engine.Sync2(new(User))
if err != nil {
log.Fatal(err)
}
// 插入数据
user := &User{
Name: "test",
}
jsonData := map[string]string{"key": "value"}
err = user.Data.Marshal(jsonData)
if err != nil {
log.Fatal(err)
}
_, err = engine.Insert(user)
if err != nil {
log.Fatal(err)
}
// 查询数据
var u User
has, err := engine.ID(1).Get(&u)
if err != nil {
log.Fatal(err)
}
if has {
var parsedData map[string]string
err = u.Data.Unmarshal(&parsedData)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Parsed Data: %v\n", parsedData)
}
}使用RawMessage处理非空JSON字段
对于不允许为NULL的JSON字段,可以使用`json.RawMessage`作为基础类型。这种方式更简洁,因为`json.RawMessage`本身已经实现了`driver.Valuer`和`sql.Scanner`接口,只需额外提供解析和序列化方法即可。

package main
import (
"encoding/json"
"fmt"
"log"
"xorm.io/xorm"
)
// RawJSON 基于 json.RawMessage 扩展
type RawJSON json.RawMessage
// Scan 实现 sql.Scanner 接口
func (r *RawJSON) Scan(value interface{}) error {
if value == nil {
*r = nil
return nil
}
bytes, ok := value.([]byte)
if !ok {
return fmt.Errorf("expected []byte, got %T", value)
}
*r = append((*r)[0:0], bytes...)
return nil
}
// Value 实现 driver.Valuer 接口
func (r RawJSON) Value() (interface{}, error) {
if len(r) == 0 {
return "{}", nil // 默认返回空对象
}
return string(r), nil
}
// Unmarshal 将 JSON 解析为目标结构体
func (r RawJSON) Unmarshal(v interface{}) error {
return json.Unmarshal([]byte(r), v)
}
// Marshal 将结构体序列化为 JSON
func (r *RawJSON) Marshal(v interface{}) error {
data, err := json.Marshal(v)
if err != nil {
return err
}
*r = append((*r)[0:0], data...)
return nil
}
// Product 示例结构体
type Product struct {
ID int64 `xorm:"id autoincr"`
Name string `xorm:"name"`
Metadata RawJSON `xorm:"metadata json"`
}
func main() {
engine, err := xorm.NewEngine("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
if err != nil {
log.Fatal(err)
}
defer engine.Close()
// 创建表
err = engine.Sync2(new(Product))
if err != nil {
log.Fatal(err)
}
// 插入数据
product := &Product{
Name: "example",
}
metaData := map[string]interface{}{"price": 100, "currency": "USD"}
err = product.Metadata.Marshal(metaData)
if err != nil {
log.Fatal(err)
}
_, err = engine.Insert(product)
if err != nil {
log.Fatal(err)
}
// 查询数据
var p Product
has, err := engine.ID(1).Get(&p)
if err != nil {
log.Fatal(err)
}
if has {
var parsedMeta map[string]interface{}
err = p.Metadata.Unmarshal(&parsedMeta)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Parsed Metadata: %v\n", parsedMeta)
}
}如何处理JSON字段中的嵌套结构体
当JSON字段包含嵌套结构体时,需要确保自定义类型的`Unmarshal`和`Marshal`方法能够正确处理嵌套关系。例如,如果JSON字段是一个包含多个子对象的复杂结构,可以在`Unmarshal`方法中使用递归或嵌套的结构体指针来解析数据。
package main
import (
"encoding/json"
"fmt"
"log"
"xorm.io/xorm"
)
// NestedData 嵌套结构体
type NestedData struct {
Level1 string `json:"level1"`
Level2 interface{} `json:"level2"`
}
// ComplexJSON 用于处理复杂JSON
type ComplexJSON struct {
Data NestedData
}
// Scan 实现 sql.Scanner 接口
func (c *ComplexJSON) Scan(value interface{}) error {
if value == nil {
return nil
}
bytes, ok := value.([]byte)
if !ok {
return fmt.Errorf("expected []byte, got %T", value)
}
return json.Unmarshal(bytes, &c.Data)
}
// Value 实现 driver.Valuer 接口
func (c ComplexJSON) Value() (interface{}, error) {
return json.Marshal(c.Data)
}
// Item 示例结构体
type Item struct {
ID int64 `xorm:"id autoincr"`
Name string `xorm:"name"`
Config ComplexJSON `xorm:"config json"`
}
func main() {
engine, err := xorm.NewEngine("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
if err != nil {
log.Fatal(err)
}
defer engine.Close()
// 创建表
err = engine.Sync2(new(Item))
if err != nil {
log.Fatal(err)
}
// 插入数据
item := &Item{
Name: "complex_item",
}
item.Config.Data.Level1 = "level1_value"
item.Config.Data.Level2 = map[string]string{"key": "value"}
_, err = engine.Insert(item)
if err != nil {
log.Fatal(err)
}
// 查询数据
var i Item
has, err := engine.ID(1).Get(&i)
if err != nil {
log.Fatal(err)
}
if has {
fmt.Printf("Level1: %s\n", i.Config.Data.Level1)
fmt.Printf("Level2: %v\n", i.Config.Data.Level2)
}
}

















