Go语言GUI开发：基于通道的组件管理与应用解耦策略

package main

import (
    "fmt"
    "log"
    "runtime"
    "sync"
    "time"

    "github.com/mattn/go-gtk/gtk" // 假设已安装go-gtk
    "github.com/mattn/go-gtk/glib" // 用于线程安全的UI更新
)

// AppMessage 定义从GUI发送到应用逻辑的消息
type AppMessage struct {
    Type    string      // 消息类型，例如 "BUTTON_CLICKED"
    Payload interface{} // 消息携带的数据
}

// GUIMessage 定义从应用逻辑发送到GUI的消息
type GUIMessage struct {
    Type    string      // 消息类型，例如 "UPDATE_LABEL"
    Payload interface{} // 消息携带的数据
}

// AppContext 封装了应用的核心逻辑和通信通道
type AppContext struct {
    guiChan chan AppMessage    // GUI发送给应用逻辑
    appChan chan GUIMessage    // 应用逻辑发送给GUI
    quit    chan struct{}      // 退出信号
    wg      sync.WaitGroup     // 等待所有goroutine结束
}

// NewAppContext 创建并初始化App上下文
func NewAppContext() *AppContext {
    return &AppContext{
        guiChan: make(chan AppMessage),
        appChan: make(chan GUIMessage),
        quit:    make(chan struct{}),
    }
}

// runGUILogic 负责管理GUI组件和事件
func (app *AppContext) runGUILogic() {
    defer app.wg.Done()
    // GTK操作通常需要锁定到主OS线程
    runtime.LockOSThread()
    defer runtime.UnlockOSThread()

    gtk.Init(nil) // 初始化GTK库

    // 主窗口
    window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
    window.SetTitle("Go GTK 解耦示例")
    window.SetPosition(gtk.WIN_POS_CENTER)
    window.SetDefaultSize(300, 200)
    window.Connect("destroy", gtk.MainQuit) // 关闭窗口时退出GTK主循环

    // 布局容器
    vbox := gtk.NewVBox(false, 5)
    window.Add(vbox)

    // 标签用于显示应用逻辑的更新
    label := gtk.NewLabel("点击按钮，等待更新...")
    vbox.PackStart(label, false, false, 5)

    // 按钮用于触发应用逻辑
    button := gtk.NewButtonWithLabel("触发业务逻辑")
    button.Connect("clicked", func() {
        // GUI发送消息给应用逻辑
        log.Println("GUI: Button clicked, sending message to app logic.")
        app.guiChan <- AppMessage{Type: "BUTTON_CLICKED", Payload: "User clicked the button"}
    })
    vbox.PackStart(button, false, false, 5)

    // 启动一个Goroutine监听来自应用逻辑的更新消息
    go func() {
        for {
            select {
            case msg := <-app.appChan:
                log.Printf("GUI: Received app message: Type=%s, Payload=%v\n", msg.Type, msg.Payload)
                // 确保在GTK主线程更新UI，使用glib.IdleAdd
                glib.IdleAdd(func() bool {
                    if msg.Type == "UPDATE_LABEL" {
                        if text, ok := msg.Payload.(string); ok {
                            label.SetText(text)
                        }
                    }
                    return false // 返回false表示只执行一次
                })
            case <-app.quit:
                log.Println("GUI Goroutine received quit signal.")
                return
            }
        }
    }()

    window.ShowAll() // 显示所有组件
    gtk.Main()        // 启动GTK主循环，阻塞直到gtk.MainQuit被调用

    // GTK主循环退出后，发送退出信号给其他goroutine
    close(app.quit)
    log.Println("GTK Main loop exited.")
}

// runAppLogic 负责处理核心业务逻辑
func (app *AppContext) runAppLogic() {
    defer app.wg.Done()
    log.Println("Application logic started.")

    for {
        select {
        case msg := <-app.guiChan:
            log.Printf("App Logic: Received GUI message: Type=%s, Payload=%v\n", msg.Type, msg.Payload)
            if msg.Type == "BUTTON_CLICKED" {
                // 模拟耗时业务操作
                log.Println("App Logic: Simulating heavy computation...")
                time.Sleep(2 * time.Second)
                // 业务逻辑处理完毕，发送更新消息给GUI
                app.appChan <- GUIMessage{Type: "UPDATE_LABEL", Payload: "业务逻辑已处理，这是新的文本！"}
                log.Println("App Logic: Sent update message to GUI.")
            }
        case <-app.quit:
            log.Println("App Logic Goroutine received quit signal.")
            return
        }
    }
}

func main() {
    app := NewAppContext()

    // 启动GUI Goroutine
    app.wg.Add(1)
    go app.runGUILogic()

    // 启动业务逻辑 Goroutine
    app.wg.Add(1)
    go app.runAppLogic()

    app.wg.Wait() // 等待所有Goroutine结束
    log.Println("Application exited.")
}