开发者

Golang pipe在不同场景下远程交互

开发者 https://www.devze.com 2023-03-08 11:09 出处：网络 作者： 梦想画家
目录Pipe介绍Go pipe简单示例Go cmd StdoutPipehttp请求处理中使用管道利用管道提交post请求json数据通过管道读标准输入Go Stat总结本文介绍golang pipe,以及在不同场景下的应用。
相关专题：Golangpipe远程交互Gopipe远程交互Go远程交互
目录
  • Pipe介绍
  • Go pipe简单示例
  • Go cmd StdoutPipe
  • http请求处理中使用管道
  • 利用管道提交post请求json数据
  • 通过管道读标准输入
  • Go Stat
  • 总结

本文介绍golang pipe,以及在不同场景下的应用。

Pipe介绍

pipe实现从一个进程重定向至另一个进程，它是双向数据通道，用于实现进行间通信。

io.Pipe函数创建内存同步通道，用于连接io.Reader和io.Writer. 本文示例使用环境为：

go version

go version go1.19.3 linux/amd64

Go pipe简单示例

在实现远程交互之前，先看下面简单示例，演示如何使用io.Pipe函数：

package main
import (
    "fmt"
    "io"
    "log"
    "os"
)
func main() {
    r, w := io.Pipe()
    go func() {
        fmt.Fprint(w, "Hello there\n")
        w.Close()
    }()
    _, err := io.Copy(os.Stdout, r)
    if err != nil {
        log.Fatal(err)
    }
}

首先创建pipe，然后在协程中给管道的writer写数据，然后使用io.Copy函数从管道Reader中拷贝数据至标准输出:

go func() {
    fmt.Fprint(w, "Hello there\n")
    w.Close()
}()

在协程中写数据是因为每次写PipeWriter都阻塞直到PipeReader完全消费了数据。

运行程序：

go run main.go 

Hello there

通过这个简单示例，展示了管道重定向能力，了解这个基本原理后，下面先看Shell命令的管道，最终我们的目标是通过WEB方式实现远程命令行交互。

Go cmd StdoutPipe

当命令启动时，Cmd的StdoutPipe返回管道连接命令的标准输出:

package main
import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
)
func main() {
    cmd := exec.Command("ping", "www.baidu.com")
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        log.Fatal(err)
    }
    cmd.Start()
    buf := bufio.NewReader(stdout) 
    num := 0
    for {
        line, _, _ := buf.ReadLine()
        if num > 3 {
            os.Exit(0)
        }
        num += 1
        fmt.Println(string(line))
    }
}

上面代码启动ping命令，然后从其输出中读取4行. 这行代码启动ping命令：

    cmd := exec.Command("ping", "www.baidu.com")

    stdout, err := cmd.StdoutPipe()

    buf := bufio.NewReader(stdout) 

接着获取命令的标准输出，并保存输出之buf中。下面从缓冲中读取4行：

for {
    line, _, _ := buf.ReadLine()
    if num > 3 {
        os.Exit(0)
    }
    num += 1
    fmt.Println(string(line))
}

读取4行并输出到控制台，运行程序，输出结果如下：

go run main.go

PING www.a.shifen.com (180.101.50.188) 56(84) bytes of data.

64 bytes from 180.101.50.188 (180.101.50.188): icmp_seq=1 ttl=53 time=12.0 ms

64 bytes from 180.101.50.188 (180.101.50.188): icmp_seq=2 ttl=53 time=11.2 ms

64 bytes from 180.101.50.188 (180.101.50.188): icmp_seq=3 ttl=53 time=10.5 ms

通过这个示例，成功地把命令的执行结果捕获到buffer中，并能够增加处理逻辑再输出到控制台。

http请求处理中使用管道

下面示例展示在http请求处理中使用管道。运行date命令，通过HTTP输出结果，可以实现元从查看命令执行结果。

package main
import (
    "fmt"
    "io"
    "net/http"
    "os/exec"
)
func handler(w www.devze.comhttp.ResponseWriter, r *http.Request) {
    cmd := exec.Command("date")
    pr, pw := io.Pipe()
    defer pw.Close()
    cmd.Stdout = pw
    cmd.Stderr = pw
    go io.Copy(w, pr)
    cmd.Run()
}
func main() {
    http.HandleFunc("/", handler)
    fmt.Println("server started on port 8080")
    http.ListenAndServe(":8080", nil)
}

关键代码为创建管道，并把PipeWriter赋给命令的标准输出和标准错误。

cmd := exec.Command("date")

pr, pw := io.Pipe()

defer pw.Close()

cmd.Stdout = pw

cmd.Stderr = pw

go io.Copy(w, pr)

然后在协程中拷贝PipeReader至http.ResponseWriter.最后运行程序查看结果：

$ go run handler.go 

server started on port 8080

使用curl或浏览器访问地址:localhost:8080,可以看到：

2023年 02月 22日 星期三 17:06:11 CST

修改上面程序，把命令作为参数，即可实现远程交互。下面我们看看如何利用管道给输入端写入数据，包括http请求和命令的标准输入。

利用管道提交post请求json数据

下面示例给https://httpbin.org/post请求地址提交json数据作为请求体。

package main
import (
    "encoding/json"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "net/http"
)
type PayLoad struct {
    Content string
}
func main() {
    r, w := io.Pipe()
    go func() http://www.devze.com{
        defer w.Close()
        err := json.NewEncoder(w).Encode(&PayLoad{Content: "Hello there!"})
        if err != nil {
            log.Fatal(err)
        }
    }()
    resp, err := http.Post("https://httpbin.org/post", "application/json", r)
    if err != nil {
        log.Fatal(err)
    }
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(body))
}

上面示例实现给post请求提交json数据，并读取响应内容。

首先定义管道，然后在协程中给管道Writer写入json数据：

go func() {
    defer w.Close()
    err := json.NewEncoder(w).Encode(&PayLoad{Content: "Hello there!"})
    if err != nil {
        log.Fatal(err)
    }
}()

然后把管道Reader作为参数传入请求：

resp, err := http.Post("https://httpbin.org/post", "application/json", r)

最后读取响应内容：

body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(body))

运行程序输出结果:

go run main.go

{

  "args": {}, 

  "data": "{\"Content\":\"Hello there!\"}\n", 

  "files": {}, 

  "form": {}, 

  "headers": {

    "Accept-Encoding": "gzip", 

    "Content-Type": "application/json", 

    "Host": "httpbin.org", 

    "Transfer-Encoding": "chunked", 

    "User-Agent": "Go-http-client/2.0", 

    "X-Amzn-Trace-Id": "Root=1-63f5c8c6-4a14ee9a2dc14e352f234fae"

  }, 

  // 省略...

}

通过管道读标准输入

下面示例利用管道从标准输入读取数据，并打印数据及数据字节数、块数:

package main
import (
    "bufio"
    "fmt"
    "io"
    "log"
    "os"
)
func main() {
    nBytes, nChunks := int64(0), int64(0)
    r := bufio.NewReader(os.Stdin)
    buf := make([]byte, 0, 4*1024)
    for {
        n, err := r.Read(buf[:cap(buf)])
        buf = buf[:n]
        if n == 0 {
            if err == nil {
                continue
            }
            if err == io.EOF {
                break
            }
            log.Fatal(err)
        }
        nChunks++
        nBytes += int64(len(buf))
        fmt.Println(string(buf)js)
        if err != nil && err != io.EOF {
            log.Fatal(err)
        }
    }
    fmt.Println("Bytes:", nBytes, "Chunks:", nChunks)
}

首先定义包装标准输入Reader:

r := bufio.NewReader(os.Stdin)
buf := make([]byte, 0, 4*1024)
n, err := r.Read(buf[:cap(buf)])
buf = buf[:n]
nChunks++
nBytes += int64(len(buf))
fmt.Println(string(buf))

然后创建4kb缓冲区，从标准输入读数据至缓冲区。然后计算块数和字节数，最后答应缓冲区内容。

date | go run main.go

2023年 02月 22日 星期三 16:08:17 CST

Bytes: 43 Chunks: 1

这里通过|操作传递date命令的输出结果，显示内容与预期一致。

Go Stat

Stat函数返回FileInfo结构体，描述文件信息。我们可以利用其检查数据是否来自终端。

package main
import (
    "bufio"
    "fmt"
    "log"
    "os"
)
func main() {
    stat, _ := os.Stdin.Stat()
    if (stat.Mode() & os.ModeCharDevice) == 0 {
        var buf []byte
        scanner := bufio.NewScanner(os.Stdin)
        for scanner.Scan() {
            buf = append(buf, scanner.Bytes()...)
        }
        if err := scanner.Err(); err != nil {
            log.Fatal(err)
  编程客栈      }
        fmt.Printf("Hello %s!开发者_自学开发\n", buf)
    } else {
        fmt.Print("Enter your name: ")
        var name string
        fmt.Scanf("%s", &name)
        fmt.Printf("Hello %s!\n", name)
    }
}

这个示例数据可能来自终端或管道。为了判断，通过下面代码获取stat：

stat, _ := os.Stdin.Stat()

获取到标准输入的FileInfo结构体后进行判断:

if (stat.Mode() & os.ModeCharDevice) == 0 {

这行判断数据来自管道，反之则为终端。即如果没有管道提供数据，则提示用户输入数据。运行程序：

$ echo "golang" | go run main.go

Hello golang!

$go run main.go

Enter your name: Java

Hello java!

总结

本文介绍了Golang管道的使用，除了实现远程命令交互，还介绍了获取标http://www.devze.com准输入内容、判断标准输入数据来源。读者组合这些简单示例，一定能够编写出炫酷的应用。

到此这篇关于Golang pipe在不同场景下远程交互的文章就介绍到这了,更多相关Golang pipe远程交互内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

0

上一篇:

:下一篇

更多 开发 相关资讯：

精彩评论

暂无评论...
登录 注册
Qedev.com
验证码 换一张
取 消

关注公众号

热门标签

图文推荐

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题
解决Feign异步调用丢失上下文问题

解决Feign异步调用丢失上下文问题
一文教会你使用Python来下一场雪

一文教会你使用Python来下一场雪
利用python调整Excel行高和列宽的操作示例

利用python调整Excel行高和列宽的操作示例
Python字符串检索方式

Python字符串检索方式
Android中常见内存泄漏的场景和解决方案详解

Android中常见内存泄漏的场景和解决方案详解
python解析网页上的json数据并保存到EXCEL

python解析网页上的json数据并保存到EXCEL
使用wxPython创建一个文件夹结构生成器

使用wxPython创建一个文件夹结构生成器

开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9