Go模块回调异常：连接状态无法同步至主程序

我正在学习Go语言，开发了一个Go模块。模块能正常运行，但希望主程序能在模块内状态变化时收到通知——目前只监听设备连接状态，后续还要监听更多设备变更。

现有代码能运行，但主程序无法感知模块内的变化：比如设备连接时，主程序的onHpd1Connected函数会被调用，但输出显示connection为nil（尽管模块的emit函数里能看到connection已经赋值）。代码需要支持多设备连接（比如hpd1、hpd2等）。我试过多种指针用法都没解决问题，请问我哪里错了？这种回调方式合适吗？还是用channel更好？

主程序代码 #

package main

import (
    "fmt"
    "sandbox/hyperdeck"
)

type hdc struct {
    client hyperdeck.Hyperdeck
}

var hpd1 = hdc{
    client: hyperdeck.NewHyperdeck("10.0.20.5", 9993),
}

func (hd hdc) onHpd1Connected() {
    fmt.Println("Connected 1")
    fmt.Println(hd)
}

func main() {
    hpd1.client.On("connected", hpd1.onHpd1Connected)
    hpd1.client.Connect()
}

模块代码 #

package hyperdeck

import (
    "errors"
    "fmt"
    "net"
    "reflect"
    "strconv"
    "time"
)

const (
    Open       ConnectionState = 1
    Connecting ConnectionState = 2
    Closed     ConnectionState = 3
)

type ConnectionState int
type HdCallback func()

type Hyperdeck struct {
    Ip          string
    Port        int
    connection  net.Conn
    state       ConnectionState
    initialized bool
    listeners   map[string][]HdCallback
}

func (hd *Hyperdeck) connect() error {
    if hd.state != Closed {
        return errors.New("already connected to server: " + hd.Ip)
    }
    hd.initialized = false
    hd.state = Connecting
    var err error
    hd.connection, err = net.DialTimeout("tcp", hd.Ip+":"+strconv.Itoa(hd.Port), time.Duration(time.Second*2))
    if err != nil {
        hd.state = Closed
        return err
    } else {
        hd.state = Open
        hd.emit("connected")
    }
    return nil
}

func (hd Hyperdeck) Connect() {
    for {
        if !hd.Connected() {
            err := hd.connect()
            if err != nil {
                fmt.Println(err)
            }
        }
        time.Sleep(time.Second * 1)
    }
}

func (hd *Hyperdeck) Connected() bool {
    return hd.state == Open && hd.connection != nil
}

func (hd Hyperdeck) emit(event string, params ...interface{}) {
    fmt.Println(hd)
    if listeners, exists := hd.listeners[event]; exists {
        in := make([]reflect.Value, len(params))
        for k, param := range params {
            in[k] = reflect.ValueOf(param)
        }
        for _, cb := range listeners {
            reflect.ValueOf(cb).Call(in)
        }
    }
}

func NewHyperdeck(ip string, port int) Hyperdeck {
    hd := Hyperdeck{
        Ip:          ip,
        Port:        port,
        initialized: false,
        connection:  nil,
        listeners:   map[string][]HdCallback{},
        state:       Closed,
    }
    return hd
}

func (hd Hyperdeck) On(event string, callback func()) {
    if _, exists := hd.listeners[event]; !exists {
        hd.listeners[event] = make([]HdCallback, 0)
    }
    hd.listeners[event] = append(hd.listeners[event], callback)
}

问题根源：值传递导致的副本问题 #

你的代码核心问题是大量使用值接收者而非指针接收者，Go语言中值接收者调用方法时会创建结构体的副本，所有修改都只作用在副本上，原实例完全不受影响：

• Connect()用值接收者，调用时复制了原Hyperdeck实例，connect()方法虽然是指针接收者，但修改的是副本的connection和state，主程序中的原实例状态根本没变化。
• On()方法用值接收者，添加的监听器只存于副本的listeners集合中，原实例的监听器列表是空的，导致回调逻辑看似执行，但主程序拿到的状态还是初始值。
• emit()方法同样用值接收者，打印的是副本的状态，所以能看到connection有值，但主程序中的原实例还是nil。

修复步骤 #

1. 把关键方法改为指针接收者 #

修改模块中的以下方法，确保操作的是原实例而非副本：

// 修改Connect为指针接收者
func (hd *Hyperdeck) Connect() {
    for {
        if !hd.Connected() {
            err := hd.connect()
            if err != nil {
                fmt.Println(err)
            }
        }
        time.Sleep(time.Second * 1)
    }
}

// 修改emit为指针接收者
func (hd *Hyperdeck) emit(event string, params ...interface{}) {
    fmt.Println(hd)
    if listeners, exists := hd.listeners[event]; exists {
        in := make([]reflect.Value, len(params))
        for k, param := range params {
            in[k] = reflect.ValueOf(param)
        }
        for _, cb := range listeners {
            reflect.ValueOf(cb).Call(in)
        }
    }
}

// 修改On为指针接收者
func (hd *Hyperdeck) On(event string, callback func()) {
    if _, exists := hd.listeners[event]; !exists {
        hd.listeners[event] = make([]HdCallback, 0)
    }
    hd.listeners[event] = append(hd.listeners[event], callback)
}

2. 调整实例化逻辑为指针模式 #

修改NewHyperdeck返回指针，同时主程序中存储指针类型的Hyperdeck：

// 模块中NewHyperdeck返回指针
func NewHyperdeck(ip string, port int) *Hyperdeck {
    return &Hyperdeck{
        Ip:          ip,
        Port:        port,
        initialized: false,
        connection:  nil,
        listeners:   map[string][]HdCallback{},
        state:       Closed,
    }
}

// 主程序中修改hdc结构体和实例化
type hdc struct {
    client *hyperdeck.Hyperdeck
}

var hpd1 = hdc{
    client: hyperdeck.NewHyperdeck("10.0.20.5", 9993),
}

3. 回调方法用指针接收者 #

主程序的onHpd1Connected改用指针接收者，确保访问最新的实例状态：

func (hd *hdc) onHpd1Connected() {
    fmt.Println("Connected 1")
    fmt.Println(hd.client)
}

回调 vs Channel 选型建议 #

• 回调方式：适合当前简单的事件通知场景，代码直观易维护，扩展多事件逻辑也方便，修复后完全满足你的需求。
• Channel方式：更贴合Go语言并发编程思想，适合复杂异步场景（比如事件排队、批量处理、异步响应）。如果后续需要处理大量设备的多种事件，Channel+goroutine的组合会更灵活。

如果只是基础的状态通知，回调模式足够；若未来有复杂并发需求，再考虑切换到Channel。

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