Write pipe reading into http response in golang

huangapple
go评论103阅读模式
英文:

Write pipe reading into http response in golang

问题

以下是翻译好的内容：

这是架构：

客户端发送一个POST请求给服务器A

服务器A处理请求并发送一个GET请求给服务器B

服务器B通过服务器A将响应发送给客户端

我认为最好的方法是创建一个管道，读取GET请求的响应，并将其写入POST请求的响应中，但是我遇到了很多类型问题。

  1. func main() {
  2.     r := mux.NewRouter()
  3.     r.HandleFunc("/test/{hash}", testHandler)
  5.     log.Fatal(http.ListenAndServe(":9095", r))
  6. }
  8. func handleErr(err error) {
  9.     if err != nil {
  10.         log.Fatalf("%s\n", err)
  11.     }
  12. }
  14. func testHandler(w http.ResponseWriter, r *http.Request){
  15.     fmt.Println("FIRST REQUEST RECEIVED")
  16.     vars := mux.Vars(r)
  17.     hash := vars["hash"]
  18.     read, write := io.Pipe()
  20.     // 在没有读取器的情况下进行写入会导致死锁，因此在goroutine中进行写入
  21.     go func() {
  22.         write, _ = http.Get("http://localhost:9090/test/" + hash)
  23.         defer write.Close()
  24.     }()
  26.     w.Write(read)
  27. }

当我运行这段代码时，我得到以下错误：

./ReverseProxy.go:61: cannot use read (type *io.PipeReader) as type []byte in argument to w.Write

有没有办法将io.PipeReader格式正确地插入到http响应中？
或者我完全错了吗？

英文:

Here is the schema :

Client sends a POST request to server A

server A process this and sends a GET to server B

server B sends a response through A to the client

I though the best idea was to make a pipe which would read the response of the GET, and write into the response of the POST, but I got many types problems.

  1. func main() {
  2.     r := mux.NewRouter()
  3.     r.HandleFunc("/test/{hash}", testHandler)
  5.     log.Fatal(http.ListenAndServe(":9095", r))
  6. }
  8. func handleErr(err error) {
  9.     if err != nil {
  10. 	    log.Fatalf("%s\n", err)
  11.     }
  12. }
  15. func testHandler(w http.ResponseWriter, r *http.Request){
  17.     fmt.Println("FIRST REQUEST RECEIVED")
  18.     vars := mux.Vars(r)
  19.     hash := vars["hash"]
  20.     read, write := io.Pipe()
  22.     // writing without a reader will deadlock so write in a goroutine
  23.     go func() {
  24. 	    write, _ = http.Get("http://localhost:9090/test/" + hash)
  25. 	    defer write.Close()
  26.     }()
  28.     w.Write(read)
  29. }

When I run this I get the following error:

./ReverseProxy.go:61: cannot use read (type *io.PipeReader) as type []byte in argument to w.Write

Is there a way, to properly insert a io.PipeReader format into an http response?
Or am I doing this in a totally wrong way?

答案1

得分: 8

你实际上并没有写入它，而是替换了管道的写入部分。

大致如下：

  1. func testHandler(w http.ResponseWriter, r *http.Request) {
  3.     fmt.Println("FIRST REQUEST RECEIVED")
  5.     vars := mux.Vars(r)
  6.     hash := vars["hash"]
  8.     read, write := io.Pipe()
  10.     // 在没有读取器的情况下进行写入会导致死锁，因此在 goroutine 中进行写入
  11.     go func() {
  12.         defer write.Close()
  13.         resp, err := http.Get("http://localhost:9090/test/" + hash)
  14.         if err != nil {
  15.             return
  16.         }
  17.         defer resp.Body.Close()
  18.         io.Copy(write, resp.Body)
  20.     }()
  22.     io.Copy(w, read)
  24. }
  26. 虽然如此，我同意 @JimB 的观点，对于这种情况，甚至不需要使用管道，像这样的代码应该更高效：
  28. ```go
  29. func testHandler(w http.ResponseWriter, r *http.Request) {
  30.     vars := mux.Vars(r)
  31.     hash := vars["hash"]
  33.     resp, err := http.Get("http://localhost:9090/test/" + hash)
  34.     if err != nil {
  35.         // 处理错误
  36.         return
  37.     }
  38.     defer resp.Body.Close()
  40.     io.Copy(w, resp.Body)
  41. }
英文:

You are not actually writing to it, you're replacing the pipe's write.

Something along the lines of:

  1. func testHandler(w http.ResponseWriter, r *http.Request) {
  3. 	fmt.Println("FIRST REQUEST RECEIVED")
  5. 	vars := mux.Vars(r)
  6. 	hash := vars["hash"]
  8. 	read, write := io.Pipe()
  10. 	// writing without a reader will deadlock so write in a goroutine
  11. 	go func() {
  12. 		defer write.Close()
  13. 		resp, err := http.Get("http://localhost:9090/test/" + hash)
  14. 		if err != nil {
  15. 			return
  16. 		}
  17. 		defer resp.Body.Close()
  18. 		io.Copy(write, resp.Body)
  20. 	}()
  22. 	io.Copy(w, read)
  24. }

Although, I agree with @JimB, for this instance, the pipe isn't even needed, something like this should be more efficient:

  1. func testHandler(w http.ResponseWriter, r *http.Request) {
  2. 	vars := mux.Vars(r)
  3. 	hash := vars["hash"]
  5. 	resp, err := http.Get("http://localhost:9090/test/" + hash)
  6. 	if err != nil {
  7. 		// handle error
  8. 		return
  9. 	}
  10. 	defer resp.Body.Close()
  12. 	io.Copy(w, resp.Body)
  13. }

huangapple
  • 本文由 发表于 2016年11月23日 00:38:39
  • 转载请务必保留本文链接：https://go.coder-hub.com/40747152.html
  • go
  • http
  • mux
  • pipe
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定