使用interface化解一场因操作系统不同导致的编译问题

failymao2024-05-23 15:15

场景描述

起因：

因项目需求，需要编写一个agent, 需支持Linux和Windows操作系统。 Agent里面有一个功能需要获取到服务器上所有已经被占用的端口。

**实现方式：**针对不同的操作系统，实现方式有所不同

  • linux: 使用服务器自带的 netstat 指令，然后使用 os/exec 库来调用 shell脚本实现
  • windows: windows系统不同在于，使用 exec.Command指令后，需要调用 syscall.SysProcAttr 和syscall.LoadDLL， 而这两个方法是windows系统下的专用库。

问题： 这里会出出现一个问题，虽然程序在编译的时候可以通过GOOS来区分编译到指定的操作系统的二进制包, 但是在编译过程中，编译器会进行代码检查，也会加载windows的代码逻辑。

编译争端

初始代码如下：

  1. tools.go

    golang 复制代码 
    // get address
func getAddress(addr string) string {
    var address string
    if strings.Contains(addr, "tcp") {
        address = strings.TrimRight(addr, "tcp")
    } else {
        address = strings.TrimRight(addr, "udp")
    }
    return address
}

// CollectServerUsedPorts, collect all of the ports that have been used
func CollectServerUsedPorts(platform string) string {
    var (
        platformLower = strings.ToLower(platform)
        cmd           *exec.Cmd
        err           error
        cmdOutPut     []byte
    )

    if platformLower == "linux" {
        // 执行 shell 指令, 获取tcp协议占用的端口
        getUsedPortsCmd := `netstat -tln | awk '{print $4}' | awk -F: '{print $NF}' | egrep -o '[0-9]+' | sort -n | uniq | paste -s -d ","`
        cmd = exec.Command("bash", "-c", getUsedPortsCmd)

    } else if platformLower == "windows" {
        // 执行 powershell指令获取已经占用的端口号
        getUsedPortsCmd := SelectScriptByWindowsVersion()

        cmd = exec.Command("powershell", "-Command", getUsedPortsCmd)
        cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}

    } else {
        cmd = nil
    }

    if cmd != nil {
        if cmdOutPut, err = cmd.Output(); err != nil {
            log.Errorf("err to execute command %s,  %s", cmd.String(), err.Error())
            return ""
        }
        return strings.Trim(string(cmdOutPut), "\n")
    }
    return ""
}

func SelectScriptByWindowsVersion() string {
    var getUsedPortsCmd string
    version, err := getWindowsVersion()
    if err != nil {
        log.Errorf("无法获取Windows版本信息: %s", err.Error())
        return ""
    }

    // if system version is lower than windows 8
    if version < 6.2 {
        log.Warnf("Windows 版本低于 Windows 8")
        getUsedPortsCmd = `(netstat -an | Select-String 'LISTENING' | ForEach-Object { $_ -replace '\s+', ' ' } | ForEach-Object { ($_ -split ' ')[2] } | Where-Object {$_ -match '\d'} | ForEach-Object {[int]($_ -split ':')[-1]} | Sort-Object | Get-Unique ) -join ",".Replace("r","")`
    } else {
        getUsedPortsCmd = `((Get-NetTCPConnection | Where-Object {$_.State -eq 'Listen'} | Select-Object -ExpandProperty LocalPort) | Sort-Object {[int]$_} | Get-Unique) -join ",".Replace("r","")`
    }

    return getUsedPortsCmd
}

func getWindowsVersion() (float64, error) {

    mod, err := syscall.LoadDLL("kernel32.dll")
    if err != nil {
        return 0, err
    }
    defer func() {
        _ = mod.Release()
    }()

    proc, err := mod.FindProc("GetVersion")
    if err != nil {
        return 0, err
    }

    version, _, _ := proc.Call()
    majorVersion := byte(version)
    minorVersion := byte(version >> 8)

    return float64(majorVersion) + float64(minorVersion)/10, nil
}

  2. 上面代码编译成windows没问题，但是编译linux二进制文件时，会提示：

    sh 复制代码 
    # 编译linux二进制文件
go build -ldflags "-linkmode external -extldflags '-static'" -tags musl -o  main main.go

# 错误输出如下
windows.go:31:22: undefined: syscall.LoadDLL
windows.go:56:41: unknown field 'HideWindow' in struct literal of type syscall.SysProcAttr

# 错误原因
- 内置库syscall，在linux编译时，其syscall.SysProcAttr 结构体并没有`HideWindow`字段；
- linux 下也没有 syscall.LoadDLL方法
- 编译和代码执行逻辑不一样，虽然代码有检查系统服务器类型的逻辑，但是编译时需要加载代码中的每一行代码逻辑，
- 将其编译成汇编，然后再交给计算机执行，所以会出现编译错误

矛盾化解

Go语言在编译时除了有对整个项目编译的 参数控制 , 如 参数GOOS=windows表示编译成widnwos系统下的二进制文件。 但是这个参数只能控制项目级别的， 对于上面这种情况，需要控制文件级别的编译， 当然 Go也是支持的，在提取出 windows 逻辑的代码为独立文件，在文件开头使用 // + build windows 语法。修改如下：

  1. used_ports/windows.go如下：

    golang 复制代码 
      //  +build windows
func SelectScriptByWindowsVersion() string {
    var getUsedPortsCmd string
    version, err := getWindowsVersion()
    if err != nil {
        log.Errorf("无法获取Windows版本信息: %s", err.Error())
        return ""
    }

    // if system version is lower than windows 8
    if version < 6.2 {
        log.Warnf("Windows 版本低于 Windows 8")
        getUsedPortsCmd = `(netstat -an | Select-String 'LISTENING' | ForEach-Object { $_ -replace '\s+', ' ' } | ForEach-Object { ($_ -split ' ')[2] } | Where-Object {$_ -match '\d'} | ForEach-Object {[int]($_ -split ':')[-1]} | Sort-Object | Get-Unique ) -join ",".Replace("r","")`
    } else {
        getUsedPortsCmd = `((Get-NetTCPConnection | Where-Object {$_.State -eq 'Listen'} | Select-Object -ExpandProperty LocalPort) | Sort-Object {[int]$_} | Get-Unique) -join ",".Replace("r","")`
    }

    return getUsedPortsCmd
}

func getWindowsVersion() (float64, error) {

    mod, err := syscall.LoadDLL("kernel32.dll")
    if err != nil {
        return 0, err
    }
    defer func() {
        _ = mod.Release()
    }()

    proc, err := mod.FindProc("GetVersion")
    if err != nil {
        return 0, err
    }

    version, _, _ := proc.Call()
    majorVersion := byte(version)
    minorVersion := byte(version >> 8)

    return float64(majorVersion) + float64(minorVersion)/10, nil
}

  2. 将原来逻辑改成如下：

    • windows.go

      golang 复制代码 
      // CollectServerUsedPorts, collect all of the ports that have been used
func CollectServerUsedPorts(platform string) string {
    var (
        platformLower = strings.ToLower(platform)
        cmd           *exec.Cmd
        err           error
        cmdOutPut     []byte
    )

    if platformLower == "linux" {
        // 执行 shell 指令, 获取tcp协议占用的端口
        getUsedPortsCmd := `netstat -tln | awk '{print $4}' | awk -F: '{print $NF}' | egrep -o '[0-9]+' | sort -n | uniq | paste -s -d ","`
        cmd = exec.Command("bash", "-c", getUsedPortsCmd)
    
    } else if platformLower == "windows" {
        // todo: 需要优化，通过接口映射避免编译的问题
        // Linux 编译时需要隐藏下面代码,
        getUsedPortsCmd := used_ports.CollectWindowsUsedPorts()
        cmd = exec.Command("powershell", "-Command", getUsedPortsCmd)
        cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}

    } else {
        cmd = nil
    }

    if cmd != nil {
        if cmdOutPut, err = cmd.Output(); err != nil {
            log.Errorf("err to execute command %s,  %s", cmd.String(), err.Error())
            return ""
        }
        return strings.Trim(string(cmdOutPut), "\n")
    }
    return ""
}

  3. 光修改了上面的逻辑也不行，因为编译的时候代码依然会执行，此时会报如下错误

    sh 复制代码 
    tools.go:121:15: undefined: used_ports.CollectWindowsUsedPorts

# 这是因为虽然linux编译时，不会编译 windows.go的文件，同时会导致 模块下的
#CollectWindowsUsedPorts 方法不存在

  4. 最终修复方式如下

    • 编译时考虑使用 定义接口的方式, 针对不同操作系统使用不同的 结构体，然后通过结构实现接口的方式来使其两种操作系统方法来指向同一个接口

    • 使用 接口字典的方式，实现策略模式，不再使用显示的 if 判断语法来做显示判断，这样可以避免编译时显示加载因操作系统带来的编译冲突

    • 使用init() 方式初始化 接口实现

    • 最终代码如下

      golang 复制代码 
      /* 实现接口目录如下
├── used_ports
│   ├── linux.go
│   ├── used_ports.go
│   └── windows.go
*/

    • used_ports.go

      golang 复制代码 
      package used_ports

import "os/exec"

type UsedPortCollector interface {
    CollectHaveUsedPorts() *exec.Cmd
}

var UsedPortCollectorMap = make(map[string]UsedPortCollector, 2)

func Register(platformOS string, collector UsedPortCollector) {
    if _, ok := Find(platformOS); ok {
        return
    }

    UsedPortCollectorMap[platformOS] = collector
}

func Find(platformOS string) (UsedPortCollector, bool) {

    c, ok := UsedPortCollectorMap[platformOS]
    return c, ok
}

    • linux.go

      golang 复制代码 
      package used_ports
  
import (
    "os/exec"
)
  
func init() {
    Register("linux", newLinuxUsedPorts())
}
  
type linuxPortCollectorImpl struct{}
  
func (w linuxPortCollectorImpl) CollectHaveUsedPorts() *exec.Cmd {
    // 执行 shell 指令, 获取tcp协议占用的端口
    getUsedPortsCmd := `netstat -tln | awk '{print $4}' | awk -F: '{print $NF}' | egrep -o '[0-9]+' | sort -n | uniq | paste -s -d ","`
    cmd := exec.Command("bash", "-c", getUsedPortsCmd)
    return cmd
}
  
   // newLinuxUsedPorts 返回Windows系统下的端口收集器实例
func newLinuxUsedPorts() UsedPortCollector {
    return linuxPortCollectorImpl{}
}
      • windows.go
      golang 复制代码 
      //  +build windows

package used_ports

import (
    "os/exec"
    "syscall"
)

func init() {
    Register("windows", newWindowsCollector())
}

// 结构体
type windowsPortCollectorImpl struct{}

// 实现接口方法
func (w windowsPortCollectorImpl) CollectHaveUsedPorts() *exec.Cmd {
    // 执行 powershell指令获取已经占用的端口号
    getUsedPortsCmd := selectScriptByWindowsVersion()

    cmd := exec.Command("powershell", "-Command", getUsedPortsCmd)
    cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}

    return cmd
}

// newWindowsCollector 返回Windows系统下的端口收集器实例，算是工厂方法
func newWindowsCollector() UsedPortCollector {
    return windowsPortCollectorImpl{}
}

func selectScriptByWindowsVersion() string {
    var getUsedPortsCmd string
    version, err := getWindowsVersion()
    if err != nil {
        return ""
    }

    // if system version is lower than windows 8
    if version < 6.2 {
        getUsedPortsCmd = `(netstat -an | Select-String 'LISTENING' | ForEach-Object { $_ -replace '\s+', ' ' } | ForEach-Object { ($_ -split ' ')[2] } | Where-Object {$_ -match '\d'} | ForEach-Object {[int]($_ -split ':')[-1]} | Sort-Object | Get-Unique ) -join ",".Replace("r","")`
    } else {
        getUsedPortsCmd = `((Get-NetTCPConnection | Where-Object {$_.State -eq 'Listen'} | Select-Object -ExpandProperty LocalPort) | Sort-Object {[int]$_} | Get-Unique) -join ",".Replace("r","")`
    }

    return getUsedPortsCmd
}

func getWindowsVersion() (float64, error) {

    mod, err := syscall.LoadDLL("kernel32.dll")
    if err != nil {
        return 0, err
    }
    defer func() {
        _ = mod.Release()
    }()

    proc, err := mod.FindProc("GetVersion")
    if err != nil {
        return 0, err
    }

    version, _, _ := proc.Call()
    majorVersion := byte(version)
    minorVersion := byte(version >> 8)

    return float64(majorVersion) + float64(minorVersion)/10, nil
}

    • tools.go

      golang 复制代码 
      ...

// CollectServerUsedPorts, collect all of the ports that have been used
func CollectServerUsedPorts(platform string) string {
    var (
        platformLower = strings.ToLower(platform)
        cmd           *exec.Cmd
        err           error
        cmdOutPut     []byte
    )
   
   // 策略方法，获取操作系统对应的实例(接口)  
    if portCollector, ok := used_ports.Find(platformLower); ok {
        cmd = portCollector.CollectHaveUsedPorts()
    }

    if cmd != nil {
        if cmdOutPut, err = cmd.Output(); err != nil {
            log.Errorf("err to execute command %s,  %s", cmd.String(), err.Error())
            return ""
        }
        return strings.Trim(string(cmdOutPut), "\n")
    }

    return ""
}

总结

  1. 程序级别的控制可以在 编译时使用 GOOS=windows 来区分编译成对应操作系统的二进制文件
  2. 文件级别的控制可以在文件头上使用 // + build windows进行控制
  3. 代码级别的控制，可以是使用 结构体映射接口的方式进行区分
  4. init()初始化方法的使用
  5. 不同结构体只要实现了同一个接口的所有方法，那么可以使用 字典接口来实现代码层面的控制
相关推荐
harder32114 小时前
Swift 面向协议编程的 RMP 模式
开发语言·ios·mvc·swift·策略模式
skywalk81631 天前
esxi8 虚拟机中怎么安装mac os（纯AI回答，未实践）
策略模式·esxi
廖圣平2 天前
从零开始，福袋直播间脚本研究【八】《策略模式》
开发语言·python·bash·策略模式
爱学习 爱分享5 天前
简单工厂模式和策略模式的区别
简单工厂模式·策略模式
xcntime8 天前
Python中print函数如何实现不换行输出？
策略模式
青春易逝丶9 天前
策略模式
java·开发语言·策略模式
sg_knight9 天前
设计模式实战：策略模式（Strategy）
java·开发语言·python·设计模式·重构·架构·策略模式
liangshanbo12159 天前
[特殊字符] macOS 上的 zoxide：智能目录跳转终极指南
macos·策略模式
Rabbit_QL11 天前
【Warp+Claude】任务完成自动通知（macOS + Warp 版）
macos·策略模式
Sahadev_13 天前
macOS 解决 AirDrop 传输应用“已损坏“问题，以sublime为例
macos·策略模式·sublime text
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03围棋-html版本04纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！05班级宠物园部署指南06“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）07小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）08UV安装并设置国内源09OpenClaw 使用和管理 MCP 完全指南10中国象棋-html版本