SpringBootLoki安装简介及实战思路

目录

引子运行命令显示输出

显示到标准输出输出到文件发送到网络保存到内存对象中输出到多个目的地

运行命令，获取输出分别获取标准输出和标准错误标准输入环境变量检查命令是否存在封装总结参考

引子

在工作中，我时不时地会需要在Go中调用外部命令。前段时间我做了一个工具，在钉钉群中添加了一个机器人，@这个机器人可以让它执行一些写好的脚本程序完成指定的任务。机器人倒是不难，照着钉钉开发者文档添加好机器人，然后@这个机器人就会向一个你指定的服务器发送一个POST请求，请求中会附带文本消息。所以我要做的就是搭一个Web服务器，可以用go原生的net/http包，也可以用gin/fasthttp/fiber这些Web框架。收到请求之后，检查附带文本中的关键字去调用对应的程序，然后返回结果。
go标准库中的os/exec包对调用外部程序提供了支持，本文详细介绍os/exec的使用姿势。

运行命令

Linux中有个cal命令，它可以显示指定年、月的日历，如果不指定年、月，默认为当前时间对应的年月。如果使用的是Windows，推荐安装msys2，这个软件包含了绝大多数的Linux常用命令。




那么，在Go代码中怎么调用这个命令呢？其实也很简单：

1. func main() {
2.   cmd := exec.Command("cal")
3.   err := cmd.Run()
4.   if err != nil {
5.     log.Fatalf("cmd.Run() failed: %v\n", err)
6.   }
7. }

复制代码

首先，我们调用exec.Command传入命令名，创建一个命令对象exec.Cmd。接着调用该命令对象的Run()方法运行它。
如果你实际运行了，你会发现什么也没有发生，哈哈。事实上，使用os/exec执行命令，标准输出和标准错误默认会被丢弃。

显示输出

exec.Cmd对象有两个字段Stdout和Stderr，类型皆为io.Writer。我们可以将任意实现了io.Writer接口的类型实例赋给这两个字段，继而实现标准输出和标准错误的重定向。io.Writer接口在 Go 标准库和第三方库中随处可见，例如*os.File、*bytes.Buffer、net.Conn。所以我们可以将命令的输出重定向到文件、内存缓存甚至发送到网络中。

显示到标准输出

将exec.Cmd对象的Stdout和Stderr这两个字段都设置为os.Stdout，那么输出内容都将显示到标准输出：

1. func main() {
2.   cmd := exec.Command("cal")
3.   cmd.Stdout = os.Stdout
4.   cmd.Stderr = os.Stderr
5.   err := cmd.Run()
6.   if err != nil {
7.     log.Fatalf("cmd.Run() failed: %v\n", err)
8.   }
9. }

复制代码

运行程序。我在git bash运行，得到如下结果：


输出了中文，检查一下环境变量LANG的值，果然是zh_CN.UTF-8。如果想输出英文，可以将环境变量LANG设置为en_US.UTF-8：

1. $ echo $LANG
2. zh_CN.UTF-8
3. $ LANG=en_US.UTF-8 go run main.go

复制代码

得到输出：



输出到文件

打开或创建文件，然后将文件句柄赋给exec.Cmd对象的Stdout和Stderr这两个字段即可实现输出到文件的功能。

1. func main() {
2.   f, err := os.OpenFile("out.txt", os.O_WRONLY|os.O_CREATE, os.ModePerm)
3.   if err != nil {
4.     log.Fatalf("os.OpenFile() failed: %v\n", err)
5.   }
6.   cmd := exec.Command("cal")
7.   cmd.Stdout = f
8.   cmd.Stderr = f
9.   err = cmd.Run()
10.   if err != nil {
11.     log.Fatalf("cmd.Run() failed: %v\n", err)
12.   }
13. }

复制代码

os.OpenFile打开一个文件，指定os.O_CREATE标志让操作系统在文件不存在时自动创建一个，返回该文件对象*os.File。*os.File实现了io.Writer接口。
运行程序：

1. $ go run main.go
2. $ cat out.txt
3.     November 2022   
4. Su Mo Tu We Th Fr Sa
5.        1  2  3  4  5
6. 6  7  8  9 10 11 12
7. 13 14 15 16 17 18 19
8. 20 21 22 23 24 25 26
9. 27 28 29 30

复制代码

发送到网络

现在我们来编写一个日历服务，接收年、月信息，返回该月的日历。

1. func cal(w http.ResponseWriter, r *http.Request) {
2.   year := r.URL.Query().Get("year")
3.   month := r.URL.Query().Get("month")
4.   cmd := exec.Command("cal", month, year)
5.   cmd.Stdout = w
6.   cmd.Stderr = w
7.   err := cmd.Run()
8.   if err != nil {
9.     log.Fatalf("cmd.Run() failed: %v\n", err)
10.   }
11. }
12. func main() {
13.   http.HandleFunc("/cal", cal)
14.   http.ListenAndServe(":8080", nil)
15. }

复制代码

这里为了简单，错误处理都省略了。正常情况下，year和month参数都需要做合法性校验。exec.Command函数接收一个字符串类型的可变参数作为命令的参数：

1. func Command(name string, arg ...string) *Cmd

复制代码

运行程序，使用浏览器请求localhost:8080/cal?year=2021&month=2得到：



保存到内存对象中

*bytes.Buffer同样也实现了io.Writer接口，故如果我们创建一个*bytes.Buffer对象，并将其赋给exec.Cmd的Stdout和Stderr这两个字段，那么命令执行之后，该*bytes.Buffer对象中保存的就是命令的输出。

1. func main() {
2.   buf := bytes.NewBuffer(nil)
3.   cmd := exec.Command("cal")
4.   cmd.Stdout = buf
5.   cmd.Stderr = buf
6.   err := cmd.Run()
7.   if err != nil {
8.     log.Fatalf("cmd.Run() failed: %v\n", err)
9.   }
10.   fmt.Println(buf.String())
11. }

复制代码

运行：

1. $ go run main.go
2.     November 2022   
3. Su Mo Tu We Th Fr Sa
4.        1  2  3  4  5
5. 6  7  8  9 10 11 12
6. 13 14 15 16 17 18 19
7. 20 21 22 23 24 25 26
8. 27 28 29 30

复制代码

运行命令，然后得到输出的字符串或字节切片这种模式是如此的普遍，并且使用便利，os/exec包提供了一个便捷方法：CombinedOutput。

输出到多个目的地

有时，我们希望能输出到文件和网络，同时保存到内存对象。使用go提供的io.MultiWriter可以很容易实现这个需求。io.MultiWriter很方便地将多个io.Writer转为一个io.Writer。
我们稍微修改上面的web程序：

1. func cal(w http.ResponseWriter, r *http.Request) {
2.   year := r.URL.Query().Get("year")
3.   month := r.URL.Query().Get("month")
4.   f, _ := os.OpenFile("out.txt", os.O_CREATE|os.O_WRONLY, os.ModePerm)
5.   buf := bytes.NewBuffer(nil)
6.   mw := io.MultiWriter(w, f, buf)
7.   cmd := exec.Command("cal", month, year)
8.   cmd.Stdout = mw
9.   cmd.Stderr = mw
10.   err := cmd.Run()
11.   if err != nil {
12.     log.Fatalf("cmd.Run() failed: %v\n", err)
13.   }
14.   fmt.Println(buf.String())
15. }

复制代码

调用io.MultiWriter将多个io.Writer整合成一个io.Writer，然后将cmd对象的Stdout和Stderr都赋值为这个io.Writer。这样，命令运行时产出的输出会分别送往http.ResponseWriter、*os.File以及*bytes.Buffer。

运行命令，获取输出

前面提到，我们常常需要运行命令，返回输出。exec.Cmd对象提供了一个便捷方法：CombinedOutput()。该方法运行命令，将输出内容以一个字节切片返回便于后续处理。所以，上面获取输出的程序可以简化为：

1. func main() {
2.   cmd := exec.Command("cal")
3.   output, err := cmd.CombinedOutput()
4.   if err != nil {
5.     log.Fatalf("cmd.Run() failed: %v\n", err)
6.   }
7.   fmt.Println(string(output))
8. }

复制代码

So easy!
CombinedOutput()方法的实现很简单，先将标准输出和标准错误重定向到*bytes.Buffer对象，然后运行程序，最后返回该对象中的字节切片：

1. func (c *Cmd) CombinedOutput() ([]byte, error) {
2.   if c.Stdout != nil {
3.     return nil, errors.New("exec: Stdout already set")
4.   }
5.   if c.Stderr != nil {
6.     return nil, errors.New("exec: Stderr already set")
7.   }
8.   var b bytes.Buffer
9.   c.Stdout = &b
10.   c.Stderr = &b
11.   err := c.Run()
12.   return b.Bytes(), err
13. }

复制代码

CombinedOutput方法前几行判断表明，Stdout和Stderr必须是未设置状态。这其实很好理解，一般情况下，如果已经打算使用CombinedOutput方法获取输出内容，不会再自找麻烦地再去设置Stdout和Stderr字段了。
与CombinedOutput类似的还有Output方法，区别是Output只会返回运行命令产出的标准输出内容。

分别获取标准输出和标准错误

创建两个*bytes.Buffer对象，分别赋给exec.Cmd对象的Stdout和Stderr这两个字段，然后运行命令即可分别获取标准输出和标准错误。

1. func main() {
2.   cmd := exec.Command("cal", "15", "2012")
3.   var stdout, stderr bytes.Buffer
4.   cmd.Stdout = &stdout
5.   cmd.Stderr = &stderr
6.   err := cmd.Run()
7.   if err != nil {
8.     log.Fatalf("cmd.Run() failed: %v\n", err)
9.   }
10.   fmt.Printf("output:\n%s\nerror:\n%s\n", stdout.String(), stderr.String())
11. }

复制代码

标准输入

exec.Cmd对象有一个类型为io.Reader的字段Stdin。命令运行时会从这个io.Reader读取输入。先来看一个最简单的例子：

1. func main() {
2.   cmd := exec.Command("cat")
3.   cmd.Stdin = bytes.NewBufferString("hello\nworld")
4.   cmd.Stdout = os.Stdout
5.   err := cmd.Run()
6.   if err != nil {
7.     log.Fatalf("cmd.Run() failed: %v\n", err)
8.   }
9. }

复制代码

如果不带参数运行cat命令，则进入交互模式，cat按行读取输入，并且原样发送到输出。
再来看一个复杂点的例子。Go标准库中compress/bzip2包只提供解压方法，并没有压缩方法。我们可以利用Linux命令bzip2实现压缩。bzip2从标准输入中读取数据，将其压缩，并发送到标准输出。

1. func bzipCompress(d []byte) ([]byte, error) {
2.   var out bytes.Buffer
3.   cmd := exec.Command("bzip2", "-c", "-9")
4.   cmd.Stdin = bytes.NewBuffer(d)
5.   cmd.Stdout = &out
6.   err := cmd.Run()
7.   if err != nil {
8.     log.Fatalf("cmd.Run() failed: %v\n", err)
9.   }
10.   return out.Bytes(), nil
11. }

复制代码

参数-c表示压缩，-9表示压缩等级，9为最高。为了验证函数的正确性，写个简单的程序，先压缩"hello world"字符串，然后解压，看看是否能得到原来的字符串：

1. func main() {
2.   data := []byte("hello world")
3.   compressed, _ := bzipCompress(data)
4.   r := bzip2.NewReader(bytes.NewBuffer(compressed))
5.   decompressed, _ := ioutil.ReadAll(r)
6.   fmt.Println(string(decompressed))
7. }

复制代码

运行程序，输出"hello world"。

环境变量

环境变量可以在一定程度上微调程序的行为，当然这需要程序的支持。例如，设置ENV=production会抑制调试日志的输出。每个环境变量都是一个键值对。exec.Cmd对象中有一个类型为[]string的字段Env。我们可以通过修改它来达到控制命令运行时的环境变量的目的。

1. package main
2. import (
3.   "fmt"
4.   "log"
5.   "os"
6.   "os/exec"
7. )
8. func main() {
9.   cmd := exec.Command("bash", "-c", "./test.sh")
10.   nameEnv := "NAME=darjun"
11.   ageEnv := "AGE=18"
12.   newEnv := append(os.Environ(), nameEnv, ageEnv)
13.   cmd.Env = newEnv
14.   out, err := cmd.CombinedOutput()
15.   if err != nil {
16.     log.Fatalf("cmd.Run() failed: %v\n", err)
17.   }
18.   fmt.Println(string(out))
19. }

复制代码

上面代码获取系统的环境变量，然后又添加了两个环境变量NAME和AGE。最后使用bash运行脚本test.sh：

1. #!/bin/bash
2. echo $NAME
3. echo $AGE
4. echo $GOPATH

复制代码

程序运行结果：

1. $ go run main.go
2. darjun
3. 18
4. D:\workspace\code\go

复制代码

检查命令是否存在

一般在运行命令之前，我们通过希望能检查要运行的命令是否存在，如果存在则直接运行，否则提示用户安装此命令。os/exec包提供了函数LookPath可以获取命令所在目录，如果命令不存在，则返回一个error。

1. func main() {
2.   path, err := exec.LookPath("ls")
3.   if err != nil {
4.     fmt.Printf("no cmd ls: %v\n", err)
5.   } else {
6.     fmt.Printf("find ls in path:%s\n", path)
7.   }
8.   path, err = exec.LookPath("not-exist")
9.   if err != nil {
10.     fmt.Printf("no cmd not-exist: %v\n", err)
11.   } else {
12.     fmt.Printf("find not-exist in path:%s\n", path)
13.   }
14. }

复制代码

运行：

1. $ go run main.go
2. find ls in path:C:\Program Files\Git\usr\bin\ls.exe
3. no cmd not-exist: exec: "not-exist": executable file not found in %PATH%

复制代码

封装

执行外部命令的流程比较固定：

调用exec.Command()创建命令对象；调用Cmd.Run()执行命令

如果要获取输出，需要调用CombinedOutput/Output之类的方法，或者手动创建bytes.Buffer对象并赋值给exec.Cmd的Stdout和Stderr字段。为了使用方便，我编写了一个包goexec。
接口如下：

1. // 执行命令，丢弃标准输出和标准错误
2. func RunCommand(cmd string, arg []string, opts ...Option) error
3. // 执行命令，以[]byte类型返回输出
4. func CombinedOutput(cmd string, arg []string, opts ...Option) ([]byte, error)
5. // 执行命令，以string类型返回输出
6. func CombinedOutputString(cmd string, arg []string, opts ...Option) (string, error)
7. // 执行命令，以[]byte类型返回标准输出
8. func Output(cmd string, arg []string, opts ...Option) ([]byte, error)
9. // 执行命令，以string类型返回标准输出
10. func OutputString(cmd string, arg []string, opts ...Option) (string, error)
11. // 执行命令，以[]byte类型分别返回标准输出和标准错误
12. func SeparateOutput(cmd string, arg []string, opts ...Option) ([]byte, []byte, error)
13. // 执行命令，以string类型分别返回标准输出和标准错误
14. func SeparateOutputString(cmd string, arg []string, opts ...Option) (string, string, error)

复制代码

相较于直接使用os/exec包，我倾向于一次函数调用就能获得结果。对输入、设置环境变量这些功能，我通过Option模式来提供支持。

1. type Option func(*exec.Cmd)
2. func WithStdin(stdin io.Reader) Option {
3.   return func(c *exec.Cmd) {
4.     c.Stdin = stdin
5.   }
6. }
7. func Without(stdout io.Writer) Option {
8.   return func(c *exec.Cmd) {
9.     c.Stdout = stdout
10.   }
11. }
12. func WithStderr(stderr io.Writer) Option {
13.   return func(c *exec.Cmd) {
14.     c.Stderr = stderr
15.   }
16. }
17. func WithOutWriter(out io.Writer) Option {
18.   return func(c *exec.Cmd) {
19.     c.Stdout = out
20.     c.Stderr = out
21.   }
22. }
23. func WithEnv(key, value string) Option {
24.   return func(c *exec.Cmd) {
25.     c.Env = append(os.Environ(), fmt.Sprintf("%s=%s", key, value))
26.   }
27. }
28. func applyOptions(cmd *exec.Cmd, opts []Option) {
29.   for _, opt := range opts {
30.     opt(cmd)
31.   }
32. }

复制代码

使用非常简单：

1. func main() {
2.   fmt.Println(goexec.CombinedOutputString("cal", nil, goexec.WithEnv("LANG", "en_US.UTF-8")))
3. }

复制代码

有一点我不太满意，为了使用Option模式，本来可以用可变参数来传递命令参数，现在只能用切片了，即使不需要指定参数，也必须要传入一个nil。暂时还没有想到比较优雅的解决方法。

总结

本文介绍了使用os/exec这个标准库调用外部命令的各种姿势。同时为了便于使用，我编写了一个goexec包封装对os/exec的调用。这个包目前for我自己使用是没有问题的，大家有其他需求可以提issue或者自己魔改。
大家如果发现好玩、好用的 Go 语言库，欢迎到 Go 每日一库 GitHub 上提交 issue

参考

Advanced command execution in go with os/exec: blog.kowalczyk.info/article/wOY…goexec: github.com/darjun/goex…Go 每日一库 GitHub：github.com/darjun/go-d…

以上就是Go中调用外部命令的几种方式详解的详细内容，更多关于Go 调用外部命令的资料请关注中国红客联盟其它相关文章！