Go语言中子进程标准输出的实时重定向

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("/path/to/my/child/program") // 替换为你的子程序路径
    out, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Printf("创建Stdout管道失败: %v\n", err)
        return
    }

    err = cmd.Start()
    if err != nil {
        fmt.Printf("启动子进程失败: %v\n", err)
        return
    }

    // 此时，out 是一个 io.ReadCloser，直接打印它并无实际意义
    // fmt.Println(out) // 这只会打印其内存地址或类型信息

    // 如果要读取管道内容，需要额外的逻辑，例如使用 goroutine 和 io.Copy
    // go func() {
    //     defer out.Close()
    //     // io.Copy(os.Stdout, out) // 将子进程输出复制到父进程的stdout
    // }()

    err = cmd.Wait() // 等待子进程完成
    if err != nil {
        fmt.Printf("子进程执行失败: %v\n", err)
    }
}

package main

import (
    "fmt"
    "os"
    "os/exec"
    "time"
)

func main() {
    // 示例：执行一个每秒打印一次的子进程，模拟长时间运行的服务
    // 在Unix/Linux系统上，可以使用 "sh", "-c", "for i in $(seq 1 5); do echo \"Child output: $i\"; sleep 1; done"
    // 在Windows系统上，可能需要使用 "cmd", "/C", "for /L %i in (1,1,5) do @echo Child output: %i && timeout /T 1 /NOBREAK"
    // 这里使用一个简单的Go程序作为子进程示例，确保跨平台兼容性

    // 创建一个模拟子进程的命令，该子进程会打印一些内容并暂停
    // 注意：在实际应用中，这里应替换为你的实际子程序路径
    childCmd := `
        package main
        import (
            "fmt"
            "time"
            "os"
        )
        func main() {
            for i := 1; i <= 5; i++ {
                fmt.Printf("子进程实时输出: 第 %d 条日志\n", i)
                fmt.Fprintf(os.Stderr, "子进程错误输出: 警告 %d\n", i) // 同时输出到stderr
                time.Sleep(1 * time.Second)
            }
            fmt.Println("子进程执行完毕。")
        }
    `
    // 将模拟子进程代码写入临时文件
    tmpFile, err := os.CreateTemp("", "child_process_*.go")
    if err != nil {
        fmt.Printf("创建临时文件失败: %v\n", err)
        return
    }
    defer os.Remove(tmpFile.Name()) // 确保程序退出时删除临时文件
    tmpFile.WriteString(childCmd)
    tmpFile.Close()

    // 编译临时子程序
    childExecPath := tmpFile.Name()[:len(tmpFile.Name())-3] // 去掉.go后缀
    buildCmd := exec.Command("go", "build", "-o", childExecPath, tmpFile.Name())
    buildOutput, err := buildCmd.CombinedOutput()
    if err != nil {
        fmt.Printf("编译子程序失败: %v\n%s\n", err, buildOutput)
        return
    }
    defer os.Remove(childExecPath) // 确保程序退出时删除编译后的子程序

    // 配置父进程执行子程序
    cmd := exec.Command(childExecPath)

    // *** 关键步骤 ***
    // 将子进程的标准输出重定向到父进程的标准输出
    cmd.Stdout = os.Stdout
    // 将子进程的标准错误输出重定向到父进程的标准错误输出
    cmd.Stderr = os.Stderr

    fmt.Println("父进程：启动子进程...")
    err = cmd.Start() // 启动子进程
    if err != nil {
        fmt.Printf("父进程：启动子进程失败: %v\n", err)
        return
    }

    err = cmd.Wait() // 等待子进程完成
    if err != nil {
        fmt.Printf("父进程：子进程执行失败: %v\n", err)
    }
    fmt.Println("父进程：子进程已退出。")
}