Go结构体中interface类型字段如何映射PostgreSQL数据库列类型

针对你场景里Sai结构体的Task接口类型字段，无法直接映射为数据库原生类型，需要先做序列化处理，可选方案如下：

可选列类型 #

优先选择PostgreSQL的jsonb类型，优势是支持对序列化内容做索引、SQL层级的字段查询，灵活性最高；如果不需要查询字段内部值，也可选择bytea或text类型。

核心实现逻辑 #

Go的database/sql包提供了driver.Valuer（序列化写入数据库）和sql.Scanner（从数据库反序列化读取）两个接口，只要实现这两个接口，就能完成自定义类型和数据库字段的映射。

你场景里如果有多个实现Test接口的类型，序列化时需要额外存储类型标识，避免反序列化时无法判断实际结构体类型。

示例代码实现 #

package main

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"
)

// 原有业务代码保持不变
type Sai struct {
	Name string `gorm:"type:varchar(128)"`
	Task Test   `gorm:"type:jsonb"`
}
type Test interface {
	Print()
}
type dummyStruct1 struct {
	Name StringStruct
}
type StringStruct struct {
	Name string
}
type dummyStruct2 struct {
	Name StringStruct
}

// 新增：序列化存储用的中间结构
type testSerial struct {
	Type  string          `json:"t"`
	Value json.RawMessage `json:"v"`
}

// 实现 driver.Valuer 接口，写入数据库时自动调用
func (t Test) Value() (driver.Value, error) {
	if t == nil {
		return nil, nil
	}
	// 1. 标记实际类型
	var typ string
	switch t.(type) {
	case StringStruct:
		typ = "StringStruct"
	// 后续新增Test接口实现类，在这里补充对应类型分支
	default:
		return nil, fmt.Errorf("unsupported Test type: %T", t)
	}
	// 2. 序列化实际值
	valBytes, err := json.Marshal(t)
	if err != nil {
		return nil, err
	}
	// 3. 拼接类型标识和值后序列化返回
	return json.Marshal(testSerial{
		Type:  typ,
		Value: valBytes,
	})
}

// 实现 sql.Scanner 接口，读取数据库时自动调用
func (t *Test) Scan(src interface{}) error {
	if src == nil {
		*t = nil
		return nil
	}
	// 1. 读取数据库原始内容
	var b []byte
	switch v := src.(type) {
	case []byte:
		b = v
	case string:
		b = []byte(v)
	default:
		return fmt.Errorf("unsupported scan type for Test: %T", src)
	}
	// 2. 反序列化为中间结构
	var serial testSerial
	if err := json.Unmarshal(b, &serial); err != nil {
		return err
	}
	// 3. 根据类型标识反序列化为对应结构体
	switch serial.Type {
	case "StringStruct":
		var ss StringStruct
		if err := json.Unmarshal(serial.Value, &ss); err != nil {
			return err
		}
		*t = ss
	// 后续新增Test接口实现类，在这里补充对应反序列化分支
	default:
		return fmt.Errorf("unknown Test type: %s", serial.Type)
	}
	return nil
}

// 原有业务方法保持不变
func main() {
	fmt.Println("Hello, playground")
	s1 := dummyStruct1{Name: StringStruct{"jon"}}
	s2 := dummyStruct1{Name: StringStruct{"smith"}}
	a := Sai{Name: "task1", Task: s1.Hello()}
	b := Sai{Name: "task1", Task: s2.Hello()}
	a.Task.Print()
	b.Task.Print()
}
func (s StringStruct) Print() {
	fmt.Println(s.Name)
}
func (d dummyStruct1) Hello() StringStruct {
	return d.Name
}
func (d dummyStruct2) Hello() StringStruct {
	return d.Name
}

简化方案（仅适用于只有一种Test实现类的场景） #

如果你确定后续不会新增其他Test接口的实现类，可以省略类型标识存储，直接序列化结构体值即可，列类型依然选jsonb，实现逻辑会更简单。

内容的提问来源于stack exchange，提问作者sai