import “net”

net包提供了可移植的网络I/O接口，包括TCP/IP、UDP、域名解析和Unix域socket。
虽然本包提供了对网络原语的访问，大部分使用者只需要Dial、Listen和Accept函数提供的基本接口；以及相关的Conn和Listener接口。crypto/tls包提供了相同的接口和类似的Dial和Listen函数。
Dial函数和服务端建立连接：

  1. conn, err := net.Dial("tcp", "google.com:80")
  2. if err != nil {
  3.     // handle error
  4. }
  5. fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
  6. status, err := bufio.NewReader(conn).ReadString('\n')
  7. // ...

Listen函数创建的服务端：

  1. ln, err := net.Listen("tcp", ":8080")
  2. if err != nil {
  3.     // handle error
  4. }
  5. for {
  6.     conn, err := ln.Accept()
  7.     if err != nil {
  8.         // handle error
  9.         continue
  10.     }
  11.     go handleConnection(conn)
  12. }
  1. type Listener interface {
  2.     // Addr返回该接口的网络地址
  3.     Addr() Addr
  4.     // Accept等待并返回下一个连接到该接口的连接
  5.     Accept() (c Conn, err error)
  6.     // Close关闭该接口，并使任何阻塞的Accept操作都会不再阻塞并返回错误。
  7.     Close() error
  8. }
  1. type Conn interface {
  2.     // Read从连接中读取数据
  3.     // Read方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
  4.     Read(b []byte) (n int, err error)
  5.     // Write从连接中写入数据
  6.     // Write方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
  7.     Write(b []byte) (n int, err error)
  8.     // Close方法关闭该连接
  9.     // 并会导致任何阻塞中的Read或Write方法不再阻塞并返回错误
  10.     Close() error
  11.     // 返回本地网络地址
  12.     LocalAddr() Addr
  13.     // 返回远端网络地址
  14.     RemoteAddr() Addr
  15.     // 设定该连接的读写deadline，等价于同时调用SetReadDeadline和SetWriteDeadline
  16.     // deadline是一个绝对时间，超过该时间后I/O操作就会直接因超时失败返回而不会阻塞
  17.     // deadline对之后的所有I/O操作都起效，而不仅仅是下一次的读或写操作
  18.     // 参数t为零值表示不设置期限
  19.     SetDeadline(t time.Time) error
  20.     // 设定该连接的读操作deadline，参数t为零值表示不设置期限
  21.     SetReadDeadline(t time.Time) error
  22.     // 设定该连接的写操作deadline，参数t为零值表示不设置期限
  23.     // 即使写入超时，返回值n也可能>0，说明成功写入了部分数据
  24.     SetWriteDeadline(t time.Time) error
  25. }
  1. type Addr interface {
  2.     Network() string // 网络名
  3.     String() string  // 字符串格式的地址
  4. }

终端的命令都是落到文件里，然后再读文件（不是再内存里）
tcp编程初识 - 图1

代码体验

tcpdemo/server/server.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6. )
  8. func main() {
  9.     fmt.Println("服务器开始监听...")
  10.     ln, err := net.Listen("tcp", "0.0.0.0:8888")
  11.     if err != nil {
  12.         fmt.Println("监听失败")
  13.         return
  14.     } else {
  15.         fmt.Printf("监听成功, ln类型： %T, 值： %v \n", ln, ln)
  16.         // ln类型： *net.TCPListener, 值： &{0xc00008ea00 {<nil> 0}}
  17.     }
  18.     defer ln.Close()
  20.     // 等待客户端连接
  21.     for {
  22.         conn, err := ln.Accept()
  23.         if err != nil {
  24.             // handle error
  25.             fmt.Println("n.Accept() err = ", err)
  26.             continue
  27.         } else {
  28.             fmt.Printf("🔊  n.Accept() suc  conn: %v, 连接的客户端ip: %v \n", conn, conn.RemoteAddr().String())
  29.             // n.Accept() suc  conn: &{{0xc00010ec80}}, 连接的客户端ip: 172.15.37.225:63367
  30.         }
  31.         // 这里准备一个协程，与客户端交互
  32.         go handleConnection(conn)
  33.     }
  34. }
  36. func handleConnection(conn net.Conn) {
  37.     // 循环接收客户端连接
  38.     defer conn.Close()
  39.     for {
  40.         // 创建切片
  41.         buf := make([]byte, 1024)
  42.         // 1.等待客户端通过 conn 发送信息
  43.         // 2.如果客户端没有 发送信息 ，那么就阻塞
  44.         // fmt.Printf("👀  服务端在等待客户端： %v 输入信息 \n", conn.RemoteAddr().String())
  45.         n, err := conn.Read(buf)
  46.         /* if err == io.EOF {
  47.             fmt.Printf("客户端： %v 退出\n", conn.RemoteAddr().String())
  48.             return
  49.         } */
  50.         if err != nil {
  51.             fmt.Println("客户端退出： ", err)
  52.             return
  53.         }
  54.         // 3.显示服务端接收到的客户端信息
  55.         fmt.Printf("👉  接收到客户端： %v 发来的信息：", conn.RemoteAddr().String())
  56.         fmt.Print(string(buf[:n])) // 这里需要对切片截取，只取有效字符，避免出现未知错误
  57.         fmt.Println()
  58.     }
  59. }
  61. /*
  62. go run server.go
  64. 服务器开始监听...
  65. 监听成功, ln类型： *net.TCPListener, 值： &{0xc00010ea00 {<nil> 0}}
  66. 🔊  n.Accept() suc  conn: &{{0xc00010ec80}}, 连接的客户端ip: 172.15.37.225:61240
  67. 👉  接收到客户端： 172.15.37.225:61240 发来的信息：11
  68. 👉  接收到客户端： 172.15.37.225:61240 发来的信息：hello
  69. 🔊  n.Accept() suc  conn: &{{0xc00009a000}}, 连接的客户端ip: 172.15.37.225:52461
  70. 👉  接收到客户端： 172.15.37.225:52461 发来的信息：xixi
  71. 👉  接收到客户端： 172.15.37.225:61240 发来的信息：haha
  73. */

tcpdemo/client/client.go
可以多开几个终端测试连接的 goroutine 处理机制 

  1. package main
  3. import (
  4.     "bufio"
  5.     "fmt"
  6.     "net"
  7.     "os"
  8.     "strings"
  9. )
  11. func main() {
  12.     conn, err := net.Dial("tcp", "172.15.37.225:8888")
  13.     if err != nil {
  14.         // handle error
  15.         fmt.Println("client connect err", err)
  16.         return
  17.     }
  18.     fmt.Println("连接成功", conn)
  20.     // 客户端发送数据给服务端
  21.     reader := bufio.NewReader(os.Stdin) // 从标准输入【终端】拿到信息
  22.     for {
  23.         line, err := reader.ReadString('\n')
  24.         if err != nil {
  25.             fmt.Println("文件读取错误", err)
  26.             return
  27.         }
  28.         line = strings.Trim(line, "\r\n")
  29.         if line == "exit" {
  30.             fmt.Println("客户端退出")
  31.             break
  32.         }
  33.         fmt.Println("line = ", line)
  34.         n, err := conn.Write([]byte(line))
  35.         if err != nil {
  36.             fmt.Println("conn.Write() err = ", err)
  37.             return
  38.         }
  39.         fmt.Printf("客户端发送 %v 个字节 \n", n)
  40.     }
  41. }
  43. /*
  44. go run client.go
  46. 连接成功 &{{0xc00008ea00}}
  47. xixi
  48. line =  xixi
  49. 客户端发送 4 个字节
  50. */