GO处理MySQL JSON的三种方案该选哪个

CREATE TABLE`writers` (
`id`INT AUTO_INCREMENT PRIMARY KEY,
`name`VARCHAR(100) NOTNULL,
`milestones`JSONDEFAULTNULLCOMMENT'创作年表',
`metadata`JSONDEFAULTNULLCOMMENT'元数据',
`created_at` DATETIME DEFAULTCURRENT_TIMESTAMP
);

type WriterA struct {
    ID         int    `gorm:"primaryKey"`
    Name       string `gorm:"not null"`
    
    // 直接用 string，完全把 JSON 当字符串处理
    Milestones string `gorm:"column:milestones;type:json"`
    Metadata   string `gorm:"column:metadata;type:json"`
}

// 写入时：需要手动序列化，并强制转换为 string
milestones := []map[string]interface{}{
    {"year": 2006, "work": "三体"},
}
jsonBytes, _ := json.Marshal(milestones)
writer.Milestones = string(jsonBytes) //会发生内存拷贝

// 读取时：需要将 string 转回 []byte 再反序列化
var result []map[string]interface{}
json.Unmarshal([]byte(writer.Milestones), &result)

import "gorm.io/datatypes"

type WriterB struct {
    ID         int            `gorm:"primaryKey"`
    Name       string         `gorm:"not null"`
    
    // 使用官方类型
    Milestones datatypes.JSON `gorm:"column:milestones"` 
    Metadata   datatypes.JSON `gorm:"column:metadata"` 
}

// 写入时：依然需要序列化，但直接赋值 []byte
milestones := []map[string]interface{}{
    {"year": 2006, "work": "三体"},
}
jsonBytes, _ := json.Marshal(milestones)
writer.Milestones = datatypes.JSON(jsonBytes) // 零拷贝

// 读取时：直接反序列化
var result []map[string]interface{}
json.Unmarshal(writer.Milestones, &result)

// 查找 metadata 中 tags 包含 "Sci-Fi" 的记录
db.Where(datatypes.JSONQuery("metadata").HasKey("tags", "Sci-Fi")).Find(&writers)

// 1. 定义具体业务结构
type Milestone struct {
    Year int    `json:"year"`
    Work string`json:"work"`
}
type Milestones []Milestone

// 2. 实现 sql.Scanner (读库：JSON -> Struct)
func (m *Milestones) Scan(value interface{}) error {
    return json.Unmarshal(value.([]byte), m)
}

// 3. 实现 driver.Valuer (写库：Struct -> JSON)
func (m Milestones) Value() (driver.Value, error) {
    return json.Marshal(m)
}

// 4. Model 使用
type WriterC struct {
    ID         int        `gorm:"primaryKey"`
    // 直接使用强类型，无需再做 json 转换
    Milestones Milestones `gorm:"column:milestones;type:json"`
    // 假设 Metadata 也用结构体（如果结构固定的话）
    // Metadata MetadataStruct `gorm:"column:metadata;type:json"`
}

// 写入：直接赋值结构体！
writer.Milestones = Milestones{
    {Year: 2006, Work: "《三体》"},
}
db.Create(&writer)

// 读取：直接使用结构体！
var w WriterC
db.First(&w, 1)
fmt.Println(w.Milestones[0].Work) // 直接点出属性

package model

import (
    "database/sql/driver"
    "encoding/json"
    "gorm.io/datatypes"
    "time"
)

// === 1. 固定结构定义 (对应方案 C) ===
type Milestone struct {
    Year  int    `json:"year"`
    Work  string`json:"work"`
    Award string`json:"award,omitempty"`
}
type Milestones []Milestone

// 实现 Scanner 接口
func (m *Milestones) Scan(value interface{}) error {
    bytes, ok := value.([]byte)
    if !ok {
        returnnil
    }
    return json.Unmarshal(bytes, m)
}

// 实现 Valuer 接口
func (m Milestones) Value() (driver.Value, error) {
    return json.Marshal(m)
}

// === 2. 混合 Model 定义 ===
type Writer struct {
    ID   int    `gorm:"primaryKey"`
    Name string`gorm:"not null"`
    
    // 强类型：创作年表 (方案 C)
    // 优势：代码自动提示，编译期检查，无需手动转换
    Milestones Milestones `gorm:"column:milestones;type:json"`
    
    // 灵活类型：元数据 (方案 B)
    // 优势：什么都能存，支持 GORM 的 JSON 查询语法
    Metadata   datatypes.JSON `gorm:"column:metadata;type:json"`
    
    CreatedAt  time.Time
}

// === 3. 实际使用体验 ===
func main() {
    // 创建
    writer := Writer{
        Name: "刘慈欣",
        
        // 方案 C 爽点：直接写结构体，不用 Marshal
        Milestones: Milestones{
            {Year: 2006, Work: "《三体》"},
            {Year: 2015, Work: "《三体》", Award: "雨果奖"},
        },
    }
    
    // 方案 B：处理杂项，还是需要手动 Marshal 一下
    meta := map[string]interface{}{
        "tags": []string{"硬科幻", "宏大叙事"}, 
        "fans": "磁铁",
    }
    jsonBytes, _ := json.Marshal(meta)
    writer.Metadata = datatypes.JSON(jsonBytes) // 零拷贝赋值
    
    db.Create(&writer)
    
    // --- 查询与使用 ---
    var result Writer
    db.First(&result, writer.ID)
    
    // 方案 C 爽点：直接读取，自带类型
    println(result.Milestones[1].Award) // 输出：雨果奖
    
    // 方案 B 爽点：复杂查询
    // 查找 metadata 中 tags 包含 "硬科幻" 的记录
    var list []Writer
    db.Where(datatypes.JSONQuery("metadata").HasKey("tags", "硬科幻")).Find(&list)
}