Golang网络编程学习笔记

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

func main() {
    fmt.Println("服务器端开始监听8888端口...")

    host := "localhost"
    port := 8888

    // 服务器端开始监听端口
    listen, err := net.Listen("tcp", fmt.Sprintf("%s:%d", host, port))
    if err != nil {
       fmt.Println("listen err=", err)
       return
    }
    defer listen.Close()
    fmt.Println("listen=", listen)

    // 循环等待客户端的连接
    for {
       fmt.Println("等待客户端连接...")
       conn, err := listen.Accept() // 等待客户端连接
       if err != nil {
          fmt.Println("Accept() err=", err)
       } else {
          fmt.Printf("Accept() suc= %v 客户端ip=%v time=%s\n", conn, conn.RemoteAddr().String(), time.Now().Format("2006-01-02 15:04:05"))
       }
       go process(conn)
    }
}
func process(conn net.Conn) {
    // 循环接收客户端发送的数据
    defer conn.Close() // 关闭conn

    for {
       // 创建新的切片
       buf := make([]byte, 1024)
       fmt.Printf("服务器在等待客户端 %s 发送信息\n", conn.RemoteAddr().String())
       n, err := conn.Read(buf) // 从conn读取，如果客户端没发送任何数据，则一直在此等待
       if err == io.EOF {
          //fmt.Println("服务器端Read err=", err)
          fmt.Println("客户端已关闭，其process服务也将关闭！")
          return // 如果客户端已经关闭了，则本协程也关闭掉
       }
       // 显示客户端发送到服务器端的内容
       fmt.Printf(string(buf[:n])) // 注意，这里只取长度为n的内容，才是实际读到的内容
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

func main() {
    fmt.Println("客户端开始连接...")
    host := "localhost"
    port := 8888

    // 与服务器端建立连接
    conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", host, port))
    if err != nil {
       fmt.Println("client dial err=", err)
       return
    }
    defer conn.Close()
    fmt.Printf("conn 成功=%v time=%s\n", conn, time.Now().Format("2006-01-02 15:04:05"))

    reader := bufio.NewReader(os.Stdin)

    // 客户端可以一直向服务器端写入数据，每次写入一行。当输入exit时，关闭连接。
    for {
       line, err := reader.ReadString('\n')
       if err != nil {
          fmt.Println("readString err=", err)
       }

       if line == "exit\r\n" { // 注意，这里要加上\r\n
          fmt.Println("客户端退出！")
          break
       }
       n, err := conn.Write([]byte(line)) // 通过连接向服务器端写入数据
       if err != nil {
          fmt.Println("conn.Write err=", err)
       }
       fmt.Printf("%s 客户端发送了 %d 字节的数据\n", time.Now().Format("2006-01-02 15:04:05"), n)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

func ConcurrentRW(conn net.Conn) {
    // 循环接收客户端发送的数据
    defer conn.Close() // 关闭conn
    wg := sync.WaitGroup{}
    // 并发地写
    wg.Add(1)
    go Write(conn, &wg)
    // 并发地读
    wg.Add(1)
    go Read(conn, &wg)

    wg.Wait()
}

func Write(conn net.Conn, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
       writeLen, err := conn.Write([]byte("send some data from server\n"))
       if err != nil {
          log.Println(err)
       }
       log.Printf("server write len is %d\n", writeLen)
       time.Sleep(time.Second * 2)
    }
}

func Read(conn net.Conn, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
       buf := make([]byte, 1024)
       readLen, err := conn.Read(buf)
       if err != nil {
          log.Println(err)
       }
       log.Printf("received from client data is: %s", string(buf[:readLen]))
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 定义需要发送的数据
type Message struct {
    ID      uint   `json:"id,omitempty"`
    Code    string `json:"code,omitempty"`
    Content string `json:"content,omitempty"`
}

message := Message{
    ID:      uint(rand.Int()),
    Code:    "SERVER-STANDARD",
    Content: "message from server",
}

encoder := json.NewEncoder(conn)                // 创建编码器
if err := encoder.Encode(message); err != nil { // 利用编码器进行编码，encode成功后，会写入到conn，也就是完成了conn.Write()
    if err == io.EOF {
       fmt.Println("客户端已关闭，服务器端也将停止...")
       break
    }
    log.Println(err)
    continue
}
fmt.Printf("message %d was send!\n", count)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

type Message struct {
    ID      uint   `json:"id,omitempty"`
    Code    string `json:"code,omitempty"`
    Content string `json:"content,omitempty"`
}
message := Message{}

// 接收数据，接收到数据后，先解码
// 1.josn解码
decoder := json.NewDecoder(conn)                 // 创建解码器
if err := decoder.Decode(&message); err != nil { // 解码操作，从conn中读取内容，将解码结果放入message中
    log.Println(err)
    if err == io.EOF {
       fmt.Println("服务器端已关闭，客户端也将停止...")
       break
    }
    continue
}
log.Println(message)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

// 长连接的心跳检测，服务器端发送心跳，客户端响应心跳。
func main() {
    TCPServer()
}

func TCPServer() {
    fmt.Println("服务器端开始监听8888端口...")

    host := "localhost"
    port := 8888

    listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", host, port))
    if err != nil {
       fmt.Println("listener err=", err)
       return
    }
    defer listener.Close()
    for {
       conn, err := listener.Accept()
       if err != nil {
          log.Println(err)
       }
       go HandlerConn(conn) // 进行连接的读写操作
    }
}

func HandlerConn(conn net.Conn) {
    defer func() {
       fmt.Println("connection closed...")
       conn.Close()
    }()
    wg := sync.WaitGroup{}

    // 独立的goroutine，在建立连接后，周期性发送ping
    wg.Add(1)
    go ServerSendPing(conn, &wg)

    wg.Wait()
}

func ServerSendPing(conn net.Conn, wg *sync.WaitGroup) {
    defer wg.Done()
    // ping失败的最大次数
    const maxPingNum = 3
    pingErrCounter := 0

    ctx, cancel := context.WithCancel(context.Background())

    go ServerReceivePong(conn, ctx)  // 使用context来控制ServerReceivePong协程，当ServerSendPing结束时，ServerReceivePong也随之结束

    type Message struct {
       ID   uint      `json:"id,omitempty"`
       Code string    `json:"code,omitempty"`
       Time time.Time `json:"time,omitempty"`
    }

    // 周期性地发送
    ticker := time.NewTicker(2 * time.Second) // 循环定时器，每隔2秒自动写入一个数据到管道中
    for t := range ticker.C {
       pingMsg := Message{
          ID:   uint(rand.Int()),
          Code: "PING-SERVER",
          Time: t,
       }

       log.Println("ping send to", conn.RemoteAddr())
       encoder := gob.NewEncoder(conn)
       if err := encoder.Encode(pingMsg); err != nil {
          log.Println(err)
          pingErrCounter++ // 累加错误计数器
          log.Printf("pingErrCounter:%d\n\n", pingErrCounter)
          if pingErrCounter == maxPingNum { // 判断是否达到次数上限
             cancel()
             log.Println("ping错误达到3次，自动关闭连接！")
             return // 心跳失败，同时，也需要终止pong的处理
          }
       }
    }
}

func ServerReceivePong(conn net.Conn, ctx context.Context) {
    type Message struct {
       ID   uint      `json:"id,omitempty"`
       Code string    `json:"code,omitempty"`
       Time time.Time `json:"time,omitempty"`
    }

    for {
       select {
       case <-ctx.Done():
          return
       default:
          message := Message{}
          decoder := gob.NewDecoder(conn)
          if err := decoder.Decode(&message); err != nil { // 解码操作
              log.Println(err)
              break
          }
          if message.Code == "PONG-CLIENT" {
             log.Println("receive pong from", conn.RemoteAddr())
          }
       }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

func main() {
    TCPClient()
}

func TCPClient() {
    log.Println("客户端开始连接...")
    host := "localhost"
    port := 8888

    // 与服务器端建立连接
    conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", host, port))
    if err != nil {
       log.Println("client dial err=", err)
       return
    }
    defer conn.Close()
    log.Printf("conn 成功=%v time=%s\n", conn, time.Now().Format("2006-01-02 15:04:05"))
    wg := sync.WaitGroup{}
    wg.Add(1)
    go ClientReceivePing(conn, &wg)

    wg.Wait()
}

func ClientReceivePing(conn net.Conn, wg *sync.WaitGroup) {
    defer wg.Done()

    type Message struct {
       ID   uint      `json:"id,omitempty"`
       Code string    `json:"code,omitempty"`
       Time time.Time `json:"time,omitempty"`
    }
    message := Message{}

    for {
       decoder := gob.NewDecoder(conn)
       if err := decoder.Decode(&message); err != nil { // 解码操作
          log.Println(err)
          if errors.Is(err, io.EOF) {
             log.Println("连接已关闭，读取结束！")
             break
          }
       }
       log.Println(message)
       if message.Code == "PING-SERVER" {
          ClientSendPong(conn)
       }
    }
}

func ClientSendPong(conn net.Conn) {

    type Message struct {
       ID   uint      `json:"id,omitempty"`
       Code string    `json:"code,omitempty"`
       Time time.Time `json:"time,omitempty"`
    }
    pongMsg := Message{
       ID:   uint(rand.Int()),
       Code: "PONG-CLIENT",
       Time: time.Now(),
    }

    encoder := gob.NewEncoder(conn)                 // 创建编码器，将前面的json包改为gob包即可
    if err := encoder.Encode(pongMsg); err != nil { // 利用编码器进行编码
       log.Println(err)
       return
    }
    log.Println("pong was send to", conn.RemoteAddr())
    return
}

1
2
3
4
5
6

type Pool interface {
	Get() (net.Conn, error)  //获取连接
	Put(conn net.Conn) error //放回连接
	Release() error          //释放池(全部连接)
	Len() int                //有效连接个数
}

1
2
3
4
5

type ConnFactory interface {
    Factory() (net.Conn, error) // 构造连接
    Close(conn net.Conn) error  // 关闭连接
    Ping(conn net.Conn) error   // 检查连接是否是有效的
}

1
2
3
4
5
6
7

type PoolConfig struct {
	InitConnNum int           // 初始化连接数
	MaxConnNum  int           // 最大连接数
	MaxIdleNum  int           // 最大空闲连接数
	IdleTimeout time.Duration // 空闲连接超时时间
	Factory     ConnFactory   // 连接工厂
}

1
2
3
4
5

// 空闲连接结构
type IdleConn struct {
	conn    net.Conn  //连接本身
	putTime time.Time //放回时间（用于判断是否超过了IdleTimeout）
}

1
2
3
4
5
6
7
8

// 连接池的结构
type TcpPool struct {
    config         *PoolConfig    // 相关配置
    openingConnNum int            // 开放使用的连接数
    idleList       chan *IdleConn // 空闲的连接队列
    addr           string         // 连接地址
    mut            sync.RWMutex   // 并发安全锁
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

type TcpConnFactory struct{}

func (*TcpConnFactory) Factory(addr string) (net.Conn, error) {
    // 校验参数的合理性
    if addr == "" {
       return nil, errors.New("addr is empty")
    }
    // 建立连接
    conn, err := net.DialTimeout("tcp", addr, 5*time.Second)
    if err != nil {
       return nil, err
    }
    // 返回连接对象
    return conn, nil
}
func (*TcpConnFactory) Close(conn net.Conn) error {
    return conn.Close()
}
func (*TcpConnFactory) Ping(net.Conn) error {
    return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func (*TcpPool) Get() (net.Conn, error) {
    return nil, nil
}
func (*TcpPool) Put(conn net.Conn) error {
    return nil
}
func (*TcpPool) Release() error {
    return nil
}
func (*TcpPool) Len() int {
    return 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

host := "localhost"
port := 8888

// 1.建立连接池
pool, err := NewTcpPool(fmt.Sprintf("%s:%d", host, port), PoolConfig{
    InitConnNum: 10,
    MaxIdleNum:  20,
    Factory:     &TcpConnFactory{},
})
if err != nil {
    log.Println(err)
    return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

func (pool *TcpPool) Get() (net.Conn, error) {
    // 1.加锁
    pool.mut.Lock()
    defer pool.mut.Unlock()

    // 2.获取空闲连接，若没有则创建连接
    for {
       select {
       // 获取空闲连接
       case idleConn, ok := <-pool.idleList:
          // 判断channel是否被关闭
          if !ok {
             return nil, errors.New("idle list closed")
          }
          // 判断连接是否超时（需要比较pool.config.IdleTimeout和idleConn.putTime）
          if pool.config.IdleTimeout > 0 { // 设置了超时时间（默认值0表示未设置超时时间）
             // 当前时间减去idleConn.putTime是否大于了超时时间（pool.config.IdleTimeout）
             if time.Now().Sub(idleConn.putTime) > pool.config.IdleTimeout {
                // 关闭连接，继续查找下一个连接
                _ = pool.config.Factory.Close(idleConn.conn)
                continue
             }
          }
          // 判断连接是否可用
          if err := pool.config.Factory.Ping(idleConn.conn); err != nil {
             // ping失败，连接不可用 ---> 关闭连接，继续查找
             _ = pool.config.Factory.Close(idleConn.conn)
             continue
          }
          // 找到了可用的空闲连接 ---> 返回连接
          log.Println("get from idle")
          pool.openingConnNum++
          return idleConn.conn, nil
       // 创建连接
       default:
          // 判断是否还可以继续创建（基于开放的连接数是否已经到达了连接池的最大连接数）
          if pool.openingConnNum >= pool.config.MaxConnNum {
             return nil, errors.New("max opening connection")
             // 另一种方案：
             //continue
          }
          // 创建连接
          conn, err := pool.config.Factory.Factory(pool.addr)
          if err != nil {
             return nil, err
          }

          // 正确地创建了可用连接
          log.Println("get from factory")
          pool.openingConnNum++ // 连接计数
          return conn, nil      // 返回连接
       }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

func (pool *TcpPool) Put(conn net.Conn) error {
    // 1.加锁
    pool.mut.Lock()
    defer pool.mut.Unlock()

    // 2.校验
    if conn == nil { // 传入的连接是否存在
       return errors.New("conn is not exists")
    }
    if pool.idleList == nil { // 空闲连接列表是否存在
       // 关闭连接
       _ = pool.config.Factory.Close(conn)
       return errors.New("idle list is not exists")
    }

    // 3.放回连接
    select {
    case pool.idleList <- &IdleConn{ // 放回连接
       conn:    conn,
       putTime: time.Now(),
    }:
       // 更新开放的连接数量
       pool.openingConnNum--
       return nil // 只要可以发送成功，任务完成

    default: // 空闲连接列表已满，直接关闭该连接
       _ = pool.config.Factory.Close(conn)
       return nil
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

func (pool *TcpPool) Release() error {
    log.Println("release all conn")

    // 1.加锁（防止其他协程继续操作连接池）
    pool.mut.Lock()
    defer pool.mut.Unlock()

    // 2.确定连接池是否被释放
    if pool.idleList == nil {
       return nil
    }

    // 3.关闭IdleList
    close(pool.idleList)

    // 4.释放全部空闲连接
    // 可以继续接收已关闭channel中的元素
    for idleConn := range pool.idleList {
       _ = pool.config.Factory.Close(idleConn.conn)
    }
    return nil
}

1
2
3

func (pool *TcpPool) Len() int {
    return len(pool.idleList)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

func TCPServerSticky() {
    log.Println("服务器端开始监听8888端口...")

    host := "localhost"
    port := 8888

    listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", host, port))
    if err != nil {
       log.Println("listener err=", err)
       return
    }
    defer listener.Close()
    for {
       conn, err := listener.Accept()
       if err != nil {
          log.Println(err)
       }
       go HandleConnSticky(conn)
    }
}

func HandleConnSticky(conn net.Conn) {
    log.Printf("accept conn from %s\n", conn.RemoteAddr())
    defer func() {
       log.Println("conn be closed")
       conn.Close()
    }()

    // 连续发送数据
    data := "package data."
    for i := 0; i < 50; i++ {
       _, err := conn.Write([]byte(data))
       if err != nil {
          log.Println(err)
       }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func TCPClientSticky() {
    host := "localhost"
    port := 8888

    // 与服务器端建立连接
    conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", host, port))
    if err != nil {
       fmt.Println("client dial err=", err)
       return
    }
    defer conn.Close()
    fmt.Printf("conn 成功=%v time=%s\n", conn, time.Now().Format("2006-01-02 15:04:05"))

    buf := make([]byte, 1024)
    for {
       readLen, err := conn.Read(buf)
       if err != nil {
          log.Println(err)
          break
       }
       log.Printf("received data: %s", string(buf[:readLen]))
    }
}

1
2
3
4
5
6
7

func TestTCPServerSticky(t *testing.T) {
    TCPServerSticky()
}

func TestTCPClientSticky(t *testing.T) {
    TCPClientSticky()
}

1
2
3
4
5
6

=== RUN   TestTCPClientSticky
conn 成功=&{{0xc00018c000}} time=2023-11-08 10:07:07
  2023/11/08 10:07:07 received data: package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.package data.
2023/11/08 10:07:07 EOF
--- PASS: TestTCPClientSticky (0.03s)
PASS

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// CusEncoder 定义编码器
type CusEncoder struct {
    w io.Writer
}

// NewEncoder 创建编码器函数
func NewEncoder(w io.Writer) *CusEncoder {
    return &CusEncoder{
       w: w,
    }
}

// Encode 编码，将编码的结果写入到w(io.Writer)
func (encoder CusEncoder) Encode(message string) error {
    // 1.获取message的长度
    l := int32(len(message))   // 假设message的长度不超过4字节

    buf := new(bytes.Buffer) // 构建一个数据包缓冲区

    // 2.在数据包中写入长度
    // 需要二进制的写入操作，需要将数据以bit的形式写入
    if err := binary.Write(buf, binary.LittleEndian, l); err != nil {
       return err
    }

    // 3.将数据主体body写入
    // 方式1：
    // if err := binary.Write(buf, binary.LittleEndian, []byte(message)); err != nil {
    //     return err
    // }
    // 方式2：
    if _, err := buf.Write([]byte(message)); err != nil {
       return err
    }

    // 4. 利用io.Writer发送数据
    if _, err := encoder.w.Write(buf.Bytes()); err != nil {
       return err
    }
    return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// CusDecoder 定义解码器
type CusDecoder struct {
    r io.Reader
}

// NewDecoder 创建Decoder解码器
func NewDecoder(r io.Reader) *CusDecoder {
    return &CusDecoder{
       r: r,
    }
}

// Decode 解码
func (decoder *CusDecoder) Decode(message *string) error {
    // 1.读取前4个字节
    header := make([]byte, 4)
    headerLen, err := decoder.r.Read(header)
    if err != nil {
       return err
    }
    if headerLen != 4 {
       return errors.New("header is not enough")
    }

    // 2.将前4个字节转换为int32类型，确定了body的长度
    var l int32
    headerBuf := bytes.NewBuffer(header)
    if err := binary.Read(headerBuf, binary.LittleEndian, &l); err != nil {
       return err
    }

    // 3.读取body
    body := make([]byte, l)
    bodyLen, err := decoder.r.Read(body)
    if err != nil {
       return err
    }
    if int32(bodyLen) != l {
       return errors.New("body is not enough")
    }

    // 4.设置message
    *message = string(body)
    return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func HandleConnEncoder(conn net.Conn) {
    log.Printf("accept conn from %s\n", conn.RemoteAddr())
    defer func() {
       log.Println("conn be closed")
       conn.Close()
    }()

    // 连续发送数据
    data := []string{
       "package data1: hello",
       "package data2: user name is tom",
       "package data3: password is 123456",
       "package data4: over",
    }
    encoder := NewEncoder(conn) // 创建自定义编码器
    index := 0
    for i := 0; i < 50; i++ {
       if err := encoder.Encode(data[index]); err != nil { // 利用编码器进行编码
          log.Println(err)
       }
       index = (index + 1) % 4
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

data := ""
decoder := NewDecoder(conn) // 创建解码器
count := 0
for {
    if err := decoder.Decode(&data); err != nil { // 解码操作
        log.Println(err)
        break
    }
    log.Println(count, "received data:", data)
    count++
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// Listen
func Listen(network, address string) (Listener, error)
func ListenTcP(network string, laddr *TCPAddr)(*TCPListener,error)

// Accept
func (Listener) Accept()(Conn，error)
func (l *TCPListener) AcceptTCP()(*TCPConn,error)

// Dial
func Dial(network, address string)(Conn,error)
func DialTcP(network string, laddr，raddr *TCPAddr)(*TCPConn，error)

1
2
3

*TCPAddr
*TCPListene
*TCPConn

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 服务器端开始监听端口
laddr, err := net.ResolveTCPAddr("tcp", ":8888")
if err != nil {
    log.Fatalln("listen err=", err)
}
tcpListener, err := net.ListenTCP("tcp", laddr)
if err != nil {
    log.Fatalln("listen err=", err)
}

// 循环等待客户端的连接
for {
    conn, err := tcpListener.AcceptTCP() // 等待客户端连接
    if err != nil {
        log.Println("Accept() err=", err)
    } else {
        log.Printf("Accept() suc= %v 客户端ip=%v time=%s\n", conn, conn.RemoteAddr().String(), time.Now().Format("2006-01-02 15:04:05"))
    }
    go HandleTcpConnSpecial(conn)
}

1
2
3
4
5
6

laddr, err := net.ResolveTCPAddr("tcp", ":8888")
conn, err := net.DialTCP("tcp", laddr, laddr)
if err != nil {
    log.Println("client dial err=", err)
    return
}

1
2
3
4
5
6

// 设置连接属性
tcpConn.SetKeepAlive(true)

// SetKeepAlive sets whether the operating system should send
// keep-alive messages on the connection.
func (c *TCPConn) SetKeepAlive(keepalive bool) error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 设置读写操作的Deadline (截至时间)
func (c *conn) SetDeadline(t time.Time) error
func (c *conn) SetReadDeadline(t time.Time) error
func (c *conn) SetWriteDeadline(t time.Time) error

// 设置读缓冲尺寸
func (c *conn) SetReadBuffer(bytes int) error
// 设置写缓存尺寸
func (c *conn) SetWriteBuffer(bytes int) error

// 设置TCP连接关闭后的逗留时间
func (c *TCPConn) SetLinger(sec int) error
// 设置是否开启KeepAlive，在一定时间段内(7200s，取决于os)，连接上没有数据传输，会发送测试数据以用来探测对方的在线状态
func (c *TCPConn) SetKeepAlive(keepalive bool) error
// 设置KeepAlive的空闲时间
func (c *TCPConn) SetKeepAlivePeriod(d time.Duration) error
// 设置是否不延迟。默认false，表示有延迟，其实就是使用Nagle算法。true为无延迟
func (c *TCPConn) SetNoDelay(noDelay bool) error

1
2
3
4
5
6

// 断言为TCPConn即可
tcpConn, ok := conn.(*net.TCPConn)
if !ok {
    log.PrintIn("not tcp connection")
}
tcpConn.SetNoDelay(true)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 解析UDPAddr
func ResolveUDPAddr(network， address string) (*UDPAddr, error)
// 监听UDP地址
func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)
// 连接UDP服务器
func DialUDP(network string， laddr, raddr *UDPAddr) (*UDPConn, error)
// UDP读
func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)
// UDP写
func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

func UDPServerBasic() {
    // 1.解析地址
    laddr, err := net.ResolveUDPAddr("udp", ":9876")
    if err != nil {
       log.Fatalln(err)
    }

    // 2.监听
    udpConn, err := net.ListenUDP("udp", laddr)
    if err != nil {
       log.Fatalln(err)
    }
    log.Printf("%s server is listening on %s", "UDP", udpConn.LocalAddr().String())
    defer udpConn.Close()

    // 3.读
    buf := make([]byte, 1024)
    readLen, raddr, err := udpConn.ReadFromUDP(buf)
    if err != nil {
       log.Fatalln(err)
    }
    log.Printf("received  %s from %s\n", string(buf[:readLen]), raddr.String())

    // 4.写
    data := []byte("received:" + string(buf[:readLen]))
    writeLen, err := udpConn.WriteToUDP(data, raddr)
    if err != nil {
       log.Fatalln(err)
    }
    log.Printf("send  %s(%d) to %s\n", string(data), writeLen, raddr.String())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

func UDPClientBasic() {
    // 1.建立连接
    raddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:9876")
    if err != nil {
       log.Fatalln(err)
    }
    udpConn, err := net.DialUDP("udp", nil, raddr)
    if err != nil {
       log.Fatalln(err)
    }

    // 2.写
    data := []byte("Go UDP Program")
    writeLen, err := udpConn.Write(data)
    if err != nil {
       log.Fatalln(err)
    }
    log.Printf("send  %s(%d) to %s\n", string(data), writeLen, raddr.String())

    // 3.读
    buf := make([]byte, 1024)
    readLen, raddr, err := udpConn.ReadFromUDP(buf)
    if err != nil {
       log.Fatalln(err)
    }
    log.Printf("received  %s from %s\n", string(buf[:readLen]), raddr.String())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// UDPServerConnect 测试无连接的UDP是否能获取到远程地址
func UDPServerConnect() {
    // 1.解析地址
    laddr, err := net.ResolveUDPAddr("udp", ":9876")
    if err != nil {
       log.Fatalln(err)
    }

    // 2.监听
    udpConn, err := net.ListenUDP("udp", laddr)
    if err != nil {
       log.Fatalln(err)
    }
    log.Printf("%s server is listening on %s", "UDP", udpConn.LocalAddr().String())
    defer udpConn.Close()

    // 测试输出远程地址
    log.Println(udpConn.RemoteAddr())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// UDPClientConnect 测试已连接的UDP是否能获取到远程地址
func UDPClientConnect() {
    // 1.建立连接
    raddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:9876")
    if err != nil {
       log.Fatalln(err)
    }
    udpConn, err := net.DialUDP("udp", nil, raddr)
    if err != nil {
       log.Fatalln(err)
    }

    // 测试输出远程地址
    log.Println(udpConn.RemoteAddr())
}