Question

这个看似简单的示例无法按预期运行，我很难问，但是可以这样：

有一个客户端重试连接到服务器，发送消息，然后等待响应：

func client() {
    var conn net.Conn
    var err error

    // retry server until it is up
    for {
        conn, err = net.Dial("tcp", ":8081")
        if err == nil {
            break
        }
        log.Println(err)
        time.Sleep(time.Second)
    }

    // write to server
    _, err = conn.Write([]byte("request"))
    if err != nil {
        log.Println(err)
        return
    }

    // block & read from server
    var buf []byte
    n, err := conn.Read(buf)
    if err != nil {
        log.Println(err)
        return
    }
    log.Printf("From server: %s\n", buf[:n])
}

它连接到服务器，该服务器针对每个连接读取并解释已发送的数据，并在需要时发送响应：

func server() {
    ln, _ := net.Listen("tcp", ":8081")
    for {
        conn, _ := ln.Accept()
        go handleConn(conn)
    }
}

func handleConn(conn net.Conn) {
    var buf []byte
    n, err := conn.Read(buf)
    if err != nil {
        return
    }
    log.Printf("Server got: %s\n", buf)

    if string(buf[:n]) == "request" {
        _, _ = conn.Write([]byte("response"))
    }
}

全部由主要功能驱动：

func main() {
    go client()
    server()
}

为简洁起见，省略了错误处理。预期的行为是客户端将连接到服务器并发送消息“ request”，然后在读取时阻止。服务器接收“请求”，并将消息“响应”发送回相同的连接。客户端取消阻止，打印收到的消息并退出。而是，在程序运行时，将显示以下内容：

2019/09/01 22:24:02 From server: 
2019/09/01 22:24:02 Server got:

建议没有数据交换，并且客户端没有阻塞。

Answer 1

客户端中的循环很奇怪！如果没有读/写，则循环没有意义。但是错误只是这样：

  //var buf []byte <--- this read 0 bytes
  buf := make([]byte, 1024) 
  n, err := conn.Read(buf)

为您准备的提案：

package main

import (
    "log"
    "net"
    "time"
)

func client() {
    var conn net.Conn
    var err error

    // retry server until it is up
    for {
        log.Printf("Connecting...")
        conn, err = net.Dial("tcp", ":8082")
        if err != nil {
            log.Println(err)
            break
        }
        time.Sleep(time.Second)
        // write to server
        log.Printf("Writing...")
        _, err = conn.Write([]byte("request"))
        if err != nil {
            log.Println(err)
            return
        }
        // block & read from server
        log.Printf("Reading...")
        var buf []byte
        n, err := conn.Read(buf)
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("From server: %s\n", buf[:n])
    }
}

func server() {
    ln, _ := net.Listen("tcp", ":8082")
    for {
        conn, _ := ln.Accept()
        go handleConn(conn)
    }
}

func handleConn(conn net.Conn) {
    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        return
    }
    log.Printf("Server got: [%d bytes] %s\n", n, buf)

    if string(buf[:n]) == "request" {
        _, _ = conn.Write([]byte("response"))
    }
    conn.Close()
}

func main() {
    go client()
    server()
}

简单的服务器客户端通信不起作用

1 个答案: