在 GORM 中，序列化通常指的是将结构体（Go 对象）转换为某种格式（如 JSON、XML）以便存储到数据库或传输到网络端点（如 API 响应）。GORM 本身并不直接处理序列化和反序列化，但它与 Go 的标准库、JSON 序列化（encoding/json）以及数据库相关的序列化（如使用 json 类型存储结构体字段）有很好的集成。
下面是一些 GORM 中与序列化相关的常见操作。
1. Go 的标准序列化：JSON 和 GORM
GORM 支持 Go 的标准 encoding/json 库来进行结构体的序列化和反序列化。通过 GORM 操作的模型（结构体）通常可以通过 json 标签来映射成 JSON 格式，适用于 API 响应、请求等场景。
1.1 序列化为 JSON
import (
"encoding/json"
"fmt"
)
type User struct {
ID uint `gorm:"primaryKey"`
Name string `json:"name"` // JSON 字段名为 "name"
Age int `json:"age"`
}
func main() {
user := User{ID: 1, Name: "Alice", Age: 25}
// 使用 json 序列化
jsonData, err := json.Marshal(user)
if err != nil {
fmt.Println("Error marshaling JSON:", err)
} else {
fmt.Println(string(jsonData)) // 输出 {"name":"Alice","age":25}
}
}在这个例子中，json:"name" 标签指定了 JSON 输出的字段名。通过 json.Marshal 函数将结构体序列化为 JSON 格式。
1.2 反序列化 JSON
func main() {
jsonData := `{"name":"Alice","age":25}`
var user User
// 使用 json 反序列化
err := json.Unmarshal([]byte(jsonData), &user)
if err != nil {
fmt.Println("Error unmarshaling JSON:", err)
} else {
fmt.Printf("User: %+v\n", user) // 输出 User: {ID:0 Name:Alice Age:25}
}
}json.Unmarshal 用于将 JSON 数据解析为 Go 结构体。
2. GORM 支持的 JSON 类型字段
GORM 支持直接将结构体嵌套在数据库表的字段中，尤其是在 JSON 类型的字段上。这对于存储动态结构数据非常有用，比如配置、日志信息、权限设置等。
2.1 使用 JSON 类型存储数据
假设我们有一个存储用户配置的表，包含一个 Preferences 字段，使用 JSON 格式存储用户的设置。
type User struct {
ID uint `gorm:"primaryKey"`
Name string
Preferences datatypes.JSON `gorm:"type:json"` // GORM 的 JSON 类型
}
func main() {
// 初始化数据库连接
db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
if err != nil {
fmt.Println("failed to connect database:", err)
return
}
// 自动迁移
db.AutoMigrate(&User{})
// 创建用户，并存储 JSON 数据
preferences := map[string]interface{}{
"theme": "dark",
"notifications": true,
}
preferencesJSON, _ := json.Marshal(preferences)
user := User{Name: "Alice", Preferences: preferencesJSON}
db.Create(&user)
// 查询并打印 JSON 字段
var fetchedUser User
db.First(&fetchedUser, 1)
fmt.Println("User Preferences:", string(fetchedUser.Preferences))
}在这个例子中，Preferences 字段被定义为 datatypes.JSON 类型，它是 GORM 提供的一个用于处理 JSON 数据的特殊类型。你可以通过 json.Marshal 序列化一个 Go 的结构体或字典，然后将它存储到数据库中的 JSON 字段。
2.2 解析 JSON 数据
当你从数据库中读取 JSON 数据时，GORM 会自动将 JSON 字符串解析成 Go 结构体或 map。以下是如何处理从数据库中读取 JSON 数据并进行反序列化：
type Preferences struct {
Theme string `json:"theme"`
Notifications bool `json:"notifications"`
}
func main() {
var user User
db.First(&user, 1)
// 反序列化 JSON 字段
var preferences Preferences
json.Unmarshal(user.Preferences, &preferences)
fmt.Printf("User Preferences: %+v\n", preferences)
}在这里，我们通过 json.Unmarshal 将 Preferences 字段反序列化成 Go 结构体 Preferences，这样我们就可以方便地访问存储在 JSON 中的数据。
3. GORM 和其他序列化格式
3.1 XML 序列化
除了 JSON，Go 标准库也支持将结构体序列化为 XML 格式。在与 GORM 配合使用时，XML 处理方式类似于 JSON。
import (
"encoding/xml"
"fmt"
)
type User struct {
ID uint `gorm:"primaryKey"`
Name string `xml:"name"`
Age int `xml:"age"`
}
func main() {
user := User{ID: 1, Name: "Bob", Age: 30}
// XML 序列化
xmlData, err := xml.Marshal(user)
if err != nil {
fmt.Println("Error marshaling XML:", err)
} else {
fmt.Println(string(xmlData)) // 输出 <User><name>Bob</name><age>30</age></User>
}
}XML 序列化与 JSON 相似，使用 encoding/xml 包即可进行 XML 数据的处理。
3.2 使用 GORM 和自定义序列化结构体
如果你需要自定义某个字段的序列化或反序列化过程，可以使用 MarshalJSON 和 UnmarshalJSON 方法来自定义。
type User struct {
ID uint
Name string
Birthdate MyDate
}
type MyDate struct {
time.Time
}
// 自定义 JSON 序列化方法
func (d MyDate) MarshalJSON() ([]byte, error) {
return json.Marshal(d.Format("2006-01-02"))
}
// 自定义 JSON 反序列化方法
func (d *MyDate) UnmarshalJSON(data []byte) error {
var dateStr string
if err := json.Unmarshal(data, &dateStr); err != nil {
return err
}
t, err := time.Parse("2006-01-02", dateStr)
if err != nil {
return err
}
d.Time = t
return nil
}
func main() {
user := User{
ID: 1,
Name: "Alice",
Birthdate: MyDate{
Time: time.Now(),
},
}
// 使用自定义序列化
jsonData, _ := json.Marshal(user)
fmt.Println(string(jsonData))
}在这个例子中，MyDate 类型通过自定义的 MarshalJSON 和 UnmarshalJSON 方法来控制序列化和反序列化的格式。
4. 序列化常见问题
字段忽略：如果不想将某个字段序列化为 JSON 或 XML，可以通过
json:"-"或xml:"-"标签来忽略该字段。type User struct { ID uint `gorm:"primaryKey"` Name string `json:"name"` Age int `json:"-"` // 忽略 Age 字段 }空值处理：如果某个字段的值是空值（如
nil或空字符串），在序列化时可以通过omitempty标签来控制是否忽略该字段。type User struct { ID uint `gorm:"primaryKey"` Name string `json:"name,omitempty"` // 如果 Name 为空，JSON 中不会出现该字段 }
总结
GORM 本身不直接处理序列化和反序列化，但它可以与 Go 的标准库很好地集成，支持 JSON 和 XML 等格式的序列化。通过使用 datatypes.JSON 类型，GORM 允许直接在数据库中存储 JSON 格式的数据。同时，Go 提供的自定义序列化接口（如 MarshalJSON 和 UnmarshalJSON）使得可以根据需求定制序列化过程，增强了数据存储和传输的灵活性。
