Socket

    使用 net 的 函数就可轻松建立一个 Socket 连接。Socket 创建成功后，我们可以对其进行 I/O 操作，最后不要记得对其进行关闭操作。

    本章将从 TCP， UDP， Unix 入手，带领大家全面了解 Socket 在 Go 中的应用。

    Socket 连接又分为客户端和服务端，如图：

    核心步骤包括：

    • 创建连接:

    注意, 这里的 network 可以为:

    1. "tcp", "tcp4", "tcp6"
    2. "udp", "udp4", "udp6"
    3. "ip", "ip4", "ip6"
    4. "unix", "unixgram", "unixpacket"
    • 通过连接发送数据:
    1. conn.Write([]byte("GET / HTTP/1.0\r\n\r\n"))
    • 通过连接读取数据：
    1. buf := make([]byte, 256)
    2. conn.Read(buf)
    • 关闭连接：
    1. conn.Close()
    1. package main
    3. import (
    4.     "fmt"
    5.     "io/ioutil"
    6.     "log"
    7.     "net"
    8. )
    10. func main() {
    11.     // 尝试与 google.com:80 建立 tcp 连接
    12.     conn, err := net.Dial("tcp", "google.com:80")
    13.     if err != nil {
    14.         log.Fatal(err)
    15.     }
    17.     defer conn.Close() // 退出关闭连接
    19.     // 通过连接发送 GET 请求，访问首页
    20.     _, err = fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
    21.     if err != nil {
    22.         log.Fatal(err)
    23.     }
    25.     dat, err := ioutil.ReadAll(conn)
    26.     if err != nil {
    27.         log.Fatal(err)
    28.     }
    30.     fmt.Println(string(dat))
    31. }
    1. HTTP/1.0 200 OK
    2. Date: Tue, 05 Jun 2018 14:45:30 GMT
    3. Expires: -1
    4. Cache-Control: private, max-age=0
    5. Content-Type: text/html; charset=ISO-8859-1
    6. P3P: CP="This is not a P3P policy! See g.co/p3phelp for more info."
    7. Server: gws
    8. X-XSS-Protection: 1; mode=block
    9. X-Frame-Options: SAMEORIGIN
    10. Set-Cookie: 1P_JAR=2018-06-05-14; expires=Thu, 05-Jul-2018 14:45:30 GMT; path=/; domain=.google.com
    11. Set-Cookie: NID=131=mqkJocXSsDCD6zdcMyc12DCUqt3X19HIoS0HGTsAzsiuvFx56rBsliga5Uj22QyA8p2IZ6E7lkMGzchqam0RQ58PT6WV5Csllv80MO0uauY9P-FvzCLdYYY9tT0KYtVv; expires=Wed, 05-Dec-2018 14:45:30 GMT; path=/; domain=.google.com; HttpOnly
    12. Accept-Ranges: none
    13. Vary: Accept-Encoding
    14. ....

    说明：google.com 网站后端是一个 HTTP server, 因为 HTTP 建立在 TCP 协议基础上，所以我们这里可以使用 TCP 协议来进行访问。

    在这个例子中，我们先使用 net 包创建一个 TCP Server ，然后尝试连接 Server, 最后再通过客户端发送 hello 到 Server，同时 Server 响应 word。

    我们来看完整例子：

    • server/main.go
    1. package main
    3. import (
    4.     "bufio"
    5.     "fmt"
    6.     "log"
    7.     "net"
    8. )
    10. func main() {
    11.     l, err := net.Listen("tcp", "127.0.0.1:8888")
    12.     if err != nil {
    13.         log.Fatal(err)
    14.     }
    15.     log.Printf("Start server with: %s", l.Addr())
    17.     defer l.Close()
    19.     for {
    20.         conn, err := l.Accept()
    21.         if err != nil {
    22.             log.Fatal(err)
    23.         }
    25.         go handleConnection(conn)
    26.     }
    27. }
    29. func handleConnection(conn net.Conn) {
    30.     reader := bufio.NewReader(conn)
    32.     for {
    33.         dat, _, err := reader.ReadLine()
    34.         if err != nil {
    35.             log.Println(err)
    36.             return
    37.         }
    39.         fmt.Println("client:", string(dat))
    41.         _, err = conn.Write([]byte("word\n"))
    42.         if err != nil {
    43.             log.Println(err)
    44.             return
    45.         }
    46.     }
    47. }

    注意：

    • client/main.go
    2. package main
    4. import (
    5.     "bufio"
    6.     "fmt"
    8.     "time"
    9. )
    11. func main() {
    12.     conn, err := net.Dial("tcp", "127.0.0.1:8888")
    13.     if err != nil {
    14.         log.Fatal(err)
    15.     }
    17.     defer conn.Close()
    19.     reader := bufio.NewReader(conn)
    20.     for {
    21.         _, err := conn.Write([]byte("hello\n"))
    22.         if err != nil {
    23.             log.Fatal(err)
    24.         }
    26.         dat, _, err := reader.ReadLine()
    27.         if err != nil {
    28.             log.Fatal(err)
    29.         }
    30.         fmt.Println("sever:", string(dat))
    32.         time.Sleep(5 * time.Second)
    33.     }
    34. }

    注意： 

    1. 1. 通过 `net.DialTCP("tcp", nil, addr)` 尝试创建到 TCP Sever 的连接。
    2. 2. 通过 `conn.Write([]byte("hello\n"))` 向服务端发送数据。
    3. 3. 通过 `reader.ReadLine()` 读取服务端响应数据。

    当我们运行代码的时候，可以在终端看到如下输入：

    1. go run server/main.go
    3. 2018/06/08 08:12:23 Start server with: 127.0.0.1:8888
    4. client: hello
    5. client: hello
    1. go run client/main.go
    3. 2018/06/08 08:12:23 Start server with: 127.0.0.1:8888
    4. sever: word
    5. sever: word

    UDP 相较于 TCP 简单的多，它具有以下特点：

    • 无连接的
    • 要求系统资源较少
    • UDP 程序结构较简单
    • 基于数据报模式(UDP)
    • UDP 可能丢包
    • UDP 不保证数据顺序性
    • server/main.go
    1. package main
    3. import (
    4.     "log"
    5.     "net"
    6.     "time"
    7. )
    9. func main() {
    10.     // listen to incoming udp packets
    11.     pc, err := net.ListenPacket("udp", "127.0.0.1:8888")
    12.     if err != nil {
    13.         log.Fatal(err)
    14.     }
    16.     log.Printf("Start server with: %s", pc.LocalAddr())
    18.     defer pc.Close()
    20.     clients := make([]net.Addr, 0)
    22.     go func() {
    23.         for {
    24.             for _, addr := range clients {
    25.                 _, err := pc.WriteTo([]byte("pong\n"), addr)
    26.                 if err != nil {
    27.                     log.Println(err)
    28.                 }
    29.             }
    31.             time.Sleep(5 * time.Second)
    32.         }
    33.     }()
    35.     for {
    36.         buf := make([]byte, 256)
    37.         n, addr, err := pc.ReadFrom(buf)
    38.         if err != nil {
    39.             log.Println(err)
    40.             continue
    41.         }
    43.         clients = append(clients, addr)
    45.         log.Println(string(buf[0:n]))
    46.         log.Println(addr.String(), "connecting...", len(clients), "connected")
    47.     }
    48. }

    注意：

    1. 1. 监听本地 UDP `127.0.0.1:8888`。
    2. 2. 使用 `pc.ReadFrom(buf)` 方法读取客户端发送的消息。
    3. 3. 使用 `clients` 来保存所有连上的客户端连接。
    4. 4. 通过 `pc.WriteTo([]byte("pong\n"), addr)` 向所有客户端发送消息。
    • client/main.go
    1. package main
    3. import (
    4.     "bufio"
    5.     "log"
    6.     "net"
    7. )
    9. func main() {
    10.     conn, err := net.Dial("udp", "127.0.0.1:8888")
    11.     if err != nil {
    12.         log.Fatal(err)
    13.     }
    15.     defer conn.Close()
    17.     if err != nil {
    18.         log.Fatal(err)
    21.     reader := bufio.NewReader(conn)
    22.     for {
    23.         dat, _, err := reader.ReadLine()
    24.         if err != nil {
    25.             log.Fatal(err)
    26.         }
    28.         log.Println(string(dat))
    29.     }
    30. }

    当我运行代码可以得到如下输出：

    1. # 启动 client1
    2. go run client/main.go
    4. # 输出
    5. 2018/06/08 14:36:18 pong
    6. 2018/06/08 14:36:23 pong
    1. # 启动 client2
    2. go run client/main.go
    4. # 输出
    5. 2018/06/08 14:37:58 pong
    6. 2018/06/08 14:38:03 pong

    Unix 和 TCP 很相似，只不过监听的地址是一个 Socket 文件，例如：

    1. l, err := net.Listen("unix", "/tmp/echo.sock")

    下面我们就通过一个实际的例子来练习：

    • server/main.go
    1. package main
    3. import (
    4.     "log"
    5.     "net"
    6. )
    8. func main() {
    9.     l, err := net.Listen("unix", "/tmp/unix.sock")
    10.     if err != nil {
    11.         log.Fatal("listen error:", err)
    12.     }
    14.     for {
    15.         conn, err := l.Accept()
    16.         if err != nil {
    17.             log.Fatal("accept error:", err)
    18.         }
    20.         go helloServer(conn)
    21.     }
    22. }
    24. func helloServer(c net.Conn) {
    25.     for {
    26.         buf := make([]byte, 512)
    27.         nr, err := c.Read(buf)
    28.         if err != nil {
    29.             return
    30.         }
    32.         data := buf[0:nr]
    33.         log.Println(string(data))
    35.         _, err = c.Write([]byte("hello"))
    36.         if err != nil {
    37.             log.Fatal("Write: ", err)
    38.         }
    39.     }
    40. }

    说明： 

    1. - 使用 `net.Listen("unix", "/tmp/unix.sock")` 启动一个 Server。
    2. - 使用 `conn, err := l.Accept()` 来接受客户端的连接。
    3. - 使用 `go helloServer(conn)` 来处理客户端连接，并读取客户端发送的数据 `hi` 并返回 `hello`。
    • client/main.go
    1. package main
    3. import (
    4.     "io"
    5.     "log"
    6.     "net"
    7.     "time"
    8. )
    10. func reader(r io.Reader) {
    11.     buf := make([]byte, 512)
    12.     for {
    13.         n, err := r.Read(buf[:])
    14.         if err != nil {
    15.             return
    16.         }
    17.         log.Println(string(buf[0:n]))
    18.     }
    19. }
    21. func main() {
    22.     c, err := net.Dial("unix", "/tmp/unix.sock")
    23.     if err != nil {
    24.         log.Fatal(err)
    25.     }
    26.     defer c.Close()
    28.     go reader(c)
    29.     for {
    30.         _, err := c.Write([]byte("hi"))
    31.         if err != nil {
    32.             log.Fatal("write error:", err)
    33.             break
    34.         }
    35.         time.Sleep(3 * time.Second)
    36.     }
    37. }

    注意： 

    1. - 使用 `c, err := net.Dial("unix", "/tmp/unix.sock")`  来连接服务端。
    2. - 使用 `c.Write([]byte("hi"))` 向服务端发送 `hi` 消息。
    3. - 使用 `r.Read(buf)` 读取客户端发送的消息。

    当运行代码可以得到如下输出：

    1. # go run client/main.go
    3. 2018/06/09 20:41:47 hello
    4. 2018/06/09 20:41:50 hello