如何在Go接口与函数参数中使用泛型？消息类型适配求解

我有两种消息类型：string 和 slice（也就是[]string）。想通过接口把它们整合起来，让下面的函数（可按需修改）正常运行，但不确定该指定什么类型。

type Message interface {
    GetMessage() ?
}

type StringMessage struct {
    message string
}

func (m *StringMessage) GetMessage() ? {
    return m.message
}

type SliceMessage struct {
    message []string
}

func (m *SliceMessage) GetMessage() ? {
    return m.message
}

type Sender interface {
    Send(m []Message)
}

type StringSender struct{}

func (s *StringSender) Send(m []Message) {
    var res [][]byte = make([][]byte, 0, len(m))
    for _, message := range m {
        res = append(res, []byte(message.GetMessage()))
    }
    //do something
}

type SliceSender struct{}

func (s *SliceSender) Send(m []Message) {
    var res = make([]string, 0)
    for _, message := range m {
        res = append(res, message.GetMessage()...)
    }
    //do something
}

// There is always only one type of message in a slice.
func PrepareMessages(m []Message) []string {
    var res = make([]string, 0)
    for _, message := range m {
        switch mes := message.(type) {
        case StringMessage:
            res = append(res, mes.GetMessage())
        case SliceMessage:
            res = append(res, mes.GetMessage()...)
        }
    }
    return res
}

我尝试用接口实现，但需要做类型断言，比如res = append(res, []byte(message.GetMessage().(string)))，感觉这不是合理方案。该怎么解决？这里适合用泛型，还是接口仍是最佳选择？

方案一：优化接口设计（消除类型断言） #

原接口只返回原始数据的思路行不通，因为两种消息返回的类型不一致。可以给接口定义贴合业务需求的方法，让具体消息类型自己实现转换逻辑，调用方无需关心底层类型：

import "strings"

type Message interface {
    // 转成字节数组，供StringSender使用
    ToBytes() []byte
    // 展开为字符串切片，供SliceSender和PrepareMessages使用
    Flatten() []string
}

type StringMessage struct {
    message string
}

func (m *StringMessage) ToBytes() []byte {
    return []byte(m.message)
}

func (m *StringMessage) Flatten() []string {
    return []string{m.message}
}

type SliceMessage struct {
    message []string
}

func (m *SliceMessage) ToBytes() []byte {
    // 可根据业务需求定义切片转字节数组的规则，比如用逗号拼接
    return []byte(strings.Join(m.message, ","))
}

func (m *SliceMessage) Flatten() []string {
    return m.message
}

type Sender interface {
    Send(m []Message)
}

type StringSender struct{}

func (s *StringSender) Send(m []Message) {
    var res [][]byte = make([][]byte, 0, len(m))
    for _, message := range m {
        res = append(res, message.ToBytes())
    }
    // do something
}

type SliceSender struct{}

func (s *SliceSender) Send(m []Message) {
    var res = make([]string, 0)
    for _, message := range m {
        res = append(res, message.Flatten()...)
    }
    // do something
}

func PrepareMessages(m []Message) []string {
    var res = make([]string, 0)
    for _, message := range m {
        res = append(res, message.Flatten()...)
    }
    return res
}

这种设计符合Go的接口思想，把类型相关的逻辑封装到具体实现中，调用方只需要依赖接口方法，不需要做任何类型断言。

方案二：使用泛型（类型安全且直接） #

既然你明确说明切片中始终只有一种消息类型，泛型会是更简洁的选择，编译期就能约束类型，避免运行时断言错误：

// 定义消息类型约束，包含两种消息指针类型
type MessageType interface {
    *StringMessage | *SliceMessage
}

type StringMessage struct {
    message string
}

func (m *StringMessage) GetMessage() string {
    return m.message
}

type SliceMessage struct {
    message []string
}

func (m *SliceMessage) GetMessage() []string {
    return m.message
}

// 泛型Sender接口
type Sender[T MessageType] interface {
    Send(m []T)
}

type StringSender struct{}

func (s *StringSender) Send(m []*StringMessage) {
    var res [][]byte = make([][]byte, 0, len(m))
    for _, message := range m {
        res = append(res, []byte(message.GetMessage()))
    }
    // do something
}

type SliceSender struct{}

func (s *SliceSender) Send(m []*SliceMessage) {
    var res = make([]string, 0)
    for _, message := range m {
        res = append(res, message.GetMessage()...)
    }
    // do something
}

// 泛型版PrepareMessages，确保输入为单一消息类型
func PrepareMessages[T MessageType](m []T) []string {
    var res = make([]string, 0)
    for _, message := range m {
        switch msg := any(message).(type) {
        case *StringMessage:
            res = append(res, msg.GetMessage())
        case *SliceMessage:
            res = append(res, msg.GetMessage()...)
        }
    }
    return res
}

泛型方案的优势在于类型安全，调用时必须传入单一类型的切片，代码逻辑更直接，不需要额外的接口方法。

方案选择建议 #

• 如果需要处理混合类型的消息切片，或者希望通过接口抽象不同消息的行为，优先选优化后的接口方案，符合Go的面向接口编程理念。
• 如果场景确实保证消息切片是单一类型，泛型方案更简洁高效，能在编译期规避类型错误。

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