如何在Go语言SMTP处理器中传递外部配置参数？

你可以通过以下几种方式让mailHandler访问到Configurationx：

方案一：使用闭包（推荐，简单直接） #

在Execute函数内部定义一个闭包函数，捕获外部的Configurationx变量，然后将这个闭包作为handler传给smtpd.ListenAndServe。闭包可以直接访问外层函数的变量：

func (m *myservice) Execute(args []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (ssec bool, errno uint32) {
    Configurationx := loadConfiguration();
    log.Println("test : Foo is : "+Configurationx.foo)

    // 定义闭包，捕获Configurationx
    handler := func(origin net.Addr, from string, to []string, data []byte) error {
        // 这里可以直接使用Configurationx
        log.Println("Using config foo:", Configurationx.foo)
        // 原来mailHandler的逻辑放到这里
        // ...处理邮件逻辑
        return nil
    }

    go func() {
        smtpd.ListenAndServe("127.0.0.1:25", handler, "myServer", "")
    }();

    changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
loop:
    // 服务循环逻辑
}

方案二：将处理器定义为结构体方法 #

如果你的配置比较复杂，或者需要后续扩展，可以定义一个包含配置的结构体，把邮件处理器作为该结构体的方法：

// 定义包含配置的结构体
type MailHandler struct {
    Config Configuration // 假设你的配置类型是Configuration
}

// 结构体方法，实现smtpd需要的handler签名
func (h *MailHandler) Handle(origin net.Addr, from string, to []string, data []byte) error {
    // 直接访问h.Config
    log.Println("Using config foo:", h.Config.foo)
    // 处理邮件逻辑
    return nil
}

// 在Execute中使用
func (m *myservice) Execute(args []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (ssec bool, errno uint32) {
    Configurationx := loadConfiguration();
    log.Println("test : Foo is : "+Configurationx.foo)

    // 创建handler实例，传入配置
    mailHandler := &MailHandler{Config: Configurationx}

    go func() {
        // 把结构体方法作为handler传入
        smtpd.ListenAndServe("127.0.0.1:25", mailHandler.Handle, "myServer", "")
    }();

    changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
loop:
    // 服务循环逻辑
}

方案三：使用全局变量（不推荐，谨慎使用） #

如果你的配置是全局唯一且不会被修改的，可以把Configurationx设为全局变量，但这种方式会降低代码的可维护性和可测试性，尽量避免：

// 全局配置变量
var globalConfig Configuration

func (m *myservice) Execute(args []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (ssec bool, errno uint32) {
    globalConfig = loadConfiguration();
    log.Println("test : Foo is : "+globalConfig.foo)

    go func() {
        smtpd.ListenAndServe("127.0.0.1:25", mailHandler, "myServer", "")
    }();

    changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
loop:
    // 服务循环逻辑
}

func mailHandler(origin net.Addr, from string, to []string, data []byte) error {
    // 直接访问全局变量
    log.Println("Using config foo:", globalConfig.foo)
    // 处理邮件逻辑
    return nil
}

总结 #

• 优先用闭包，代码简洁且不需要额外结构；
• 如果配置需要和其他逻辑绑定，用结构体方法，更符合结构化设计；
• 全局变量尽量不用，除非是非常简单且确定不会变化的场景。

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