Socket是BSD UNIX的进程通信机制，通常也称作”套接字”，用于描述IP地址和端口，是一个通信链的句柄。Socket可以理解为TCP/IP网络的API，它定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。电脑上运行的应用程序通常通过”套接字”向网络发出请求或者应答网络请求。

socket图解

Socket是应用层与TCP/IP协议族通信的中间软件抽象层。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket后面，对用户来说只需要调用Socket规定的相关函数，让Socket去组织符合指定的协议数据然后进行通信。

Go语言实现TCP通信

TCP协议

TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。

TCP通信

我们知道通信至少有两端，在编程中我们称之为服务端和客户端，只能有一个服务端，但是可能会有多个客户端，就像全球这么多人在用微信，我们在应用商店下的微信其实就是一个客户端，真正的服务端是在腾讯的机房的。
在Go语言中，因为Go语言并发的特性，我们可以为每个连接都建立一个goroutine，这样可以快速、高效的处理连接。

net包

net包提供了可移植的网络I/O接口，包括TCP/IP、UDP、域名解析和Unix域socket。

虽然本包提供了对网络原语的访问，大部分使用者只需要Dial、Listen和Accept函数提供的基本接口；以及相关的Conn和Listener接口。crypto/tls包提供了相同的接口和类似的Dial和Listen函数。

Dial函数和服务端建立连接：

conn, err := net.Dial("tcp", "127.0.0.1:80")
if err != nil {
    // handle error
}
fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
status, err := bufio.NewReader(conn).ReadString('\n')
// ...

Listen函数创建的服务端：

ln, err := net.Listen("tcp", ":8080")
if err != nil {
    // handle error
}
for {
    conn, err := ln.Accept()
    if err != nil {
        // handle error
        continue
    }
    go handleConnection(conn)
}

TCP服务端

TCP服务端的处理流程为：

监听端口
接受客户端请求建立连接
创建goroutine处理连接

比如服务端示例代码如下：

package main
import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)
// 处理请求函数
func doRequest(conn net.Conn) {
    // 用defer语句关闭连接
    defer conn.Close()
    // 循环处理连接
    inputReader := bufio.NewReader(os.Stdin)
    for {
        reader := bufio.NewReader(conn)
        // 按字节读取数据
        var buf [128]byte
        n, err := reader.Read(buf[:])
        if err != nil {
            fmt.Println("data read failed. err:", err)
            return
        }
        // 输出数据
        fmt.Println("来自客户端：", string(buf[:n]))
        // 发送数据
        fmt.Print("服务端：")
        input, err := inputReader.ReadString('\n')
        if err != nil {
            fmt.Println("服务端写入的数据有误. err:", err)
            return
        }
        inputInfo := strings.Trim(input, "\r\n")
        if strings.ToUpper(inputInfo) == "Q" {
            return
        }
        _, err = conn.Write([]byte(inputInfo))
        if err != nil {
            fmt.Println("send data failed. err:", err)
        }
    }
}
func main() {
    // 监听端口
    listener, err := net.Listen("tcp", "127.0.0.1:8888")
    if err != nil {
        fmt.Println("server port listen failed. err:", err)
        return
    }
    for {
        // 等待连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("client connect failed. err:", err)
            return
        }
        // 处理连接
        go doRequest(conn)
    }
}

TCP客户端

客户端处理流程：

连接服务端
发送数据

客户端示例代码如下：

package main
import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)
func main() {
    // 与服务端建立连接
    conn, err := net.Dial("tcp", "127.0.0.1:8888")
    if err != nil {
        fmt.Println("connect server failed. err:", err)
    }
    // 发送数据
    defer conn.Close()
    // 初始化标准输入的对象
    inputReader := bufio.NewReader(os.Stdin)
    for {
        fmt.Print("客户端：")
        // 读取用户输入,以回车键
        input, _ := inputReader.ReadString('\n')
        // 格式化输入
        inputInfo := strings.Trim(input, "\r\n")
        if strings.ToUpper(inputInfo) == "Q" {
            return
        }
        // 发送数据
        _, err = conn.Write([]byte(inputInfo))
        if err != nil {
            fmt.Println("客户端数据发送失败。err:", err)
            return
        }
        // 接受数据
        buf := [512]byte{}
        n, err := conn.Read(buf[:])
        if err != nil {
            fmt.Println("Recv data failed. err:", err)
            return
        }
        fmt.Print("来自服务端：")
        // 打印接受的数据
        fmt.Println(string(buf[:n]))
    }
}

TCP黏包

黏包示例

服务端代码如下：

// socket_stick/server/main.go
func process(conn net.Conn) {
    defer conn.Close()
    reader := bufio.NewReader(conn)
    var buf [1024]byte
    for {
        n, err := reader.Read(buf[:])
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Println("read from client failed, err:", err)
            break
        }
        recvStr := string(buf[:n])
        fmt.Println("收到client发来的数据：", recvStr)
    }
}
func main() {
    listen, err := net.Listen("tcp", "127.0.0.1:30000")
    if err != nil {
        fmt.Println("listen failed, err:", err)
        return
    }
    defer listen.Close()
    for {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println("accept failed, err:", err)
            continue
        }
        go process(conn)
    }
}

客户端代码如下：

// socket_stick/client/main.go
func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:30000")
    if err != nil {
        fmt.Println("dial failed, err", err)
        return
    }
    defer conn.Close()
    for i := 0; i < 20; i++ {
        msg := `Hello, Hello. How are you?`
        conn.Write([]byte(msg))
    }
}

将上面的代码保存后，分别编译。先启动服务端再启动客户端，可以看到服务端输出结果如下：

收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?

客户端分10次发送的数据，在服务端并没有成功的输出10次，而是多条数据“粘”到了一起。

为什么会出现粘包

主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。
“粘包”可发生在发送端也可发生在接收端：

由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP并不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，若有则会一次把这两段数据发送出去。

接收端接收不及时造成的接收端粘包：TCP会把接收到的数据存在自己的缓冲区中，然后通知应用层取数据。当应用层由于某些原因不能及时的把TCP的数据取出来，就会造成TCP缓冲区中存放了几段数据。

解决办法

出现”粘包”的关键在于接收方不确定将要传输的数据包的大小，因此我们可以对数据包进行封包和拆包的操作。
封包：封包就是给一段数据加上包头，这样一来数据包就分为包头和包体两部分内容了(过滤非法包时封包会加入”包尾”内容)。包头部分的长度是固定的，并且它存储了包体的长度，根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出一个完整的数据包。
我们可以自己定义一个协议，比如数据包的前4个字节为包头，里面存储的是发送的数据的长度。

// socket_stick/proto/proto.go
package proto
import (
 "bufio"
 "bytes"
 "encoding/binary"
)
// Encode 将消息编码
func Encode(message string) ([]byte, error) {
 // 读取消息的长度，转换成int32类型（占4个字节）
 var length = int32(len(message))
 var pkg = new(bytes.Buffer)
 // 写入消息头
 err := binary.Write(pkg, binary.LittleEndian, length)
 if err != nil {
     return nil, err
 }
 // 写入消息实体
 err = binary.Write(pkg, binary.LittleEndian, []byte(message))
 if err != nil {
     return nil, err
 }
 return pkg.Bytes(), nil
}
// Decode 解码消息
func Decode(reader *bufio.Reader) (string, error) {
 // 读取消息的长度
 lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
 lengthBuff := bytes.NewBuffer(lengthByte)
 var length int32
 err := binary.Read(lengthBuff, binary.LittleEndian, &length)
 if err != nil {
     return "", err
 }
 // Buffered返回缓冲中现有的可读取的字节数。
 if int32(reader.Buffered()) < length+4 {
     return "", err
 }
 // 读取真正的消息数据
 pack := make([]byte, int(4+length))
 _, err = reader.Read(pack)
 if err != nil {
     return "", err
 }
 return string(pack[4:]), nil
}

接下来在服务端和客户端分别使用上面定义的proto包的Decode和Encode函数处理数据。
服务端代码如下：

// socket_stick/server2/main.go
func process(conn net.Conn) {
 defer conn.Close()
 reader := bufio.NewReader(conn)
 for {
     msg, err := proto.Decode(reader)
     if err == io.EOF {
         return
     }
     if err != nil {
         fmt.Println("decode msg failed, err:", err)
         return
     }
     fmt.Println("收到client发来的数据：", msg)
 }
}
func main() {
 listen, err := net.Listen("tcp", "127.0.0.1:30000")
 if err != nil {
     fmt.Println("listen failed, err:", err)
     return
 }
 defer listen.Close()
 for {
     conn, err := listen.Accept()
     if err != nil {
         fmt.Println("accept failed, err:", err)
         continue
     }
     go process(conn)
 }
}

客户端代码如下：

// socket_stick/client2/main.go
func main() {
 conn, err := net.Dial("tcp", "127.0.0.1:30000")
 if err != nil {
     fmt.Println("dial failed, err", err)
     return
 }
 defer conn.Close()
 for i := 0; i < 20; i++ {
     msg := `Hello, Hello. How are you?`
     data, err := proto.Encode(msg)
     if err != nil {
         fmt.Println("encode msg failed, err:", err)
         return
     }
     conn.Write(data)
 }
}

Go语言实现UDP通信

UDP协议

UDP协议（User Datagram Protocol）中文名称是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联）参考模型中一种无连接的传输层协议，不需要建立连接就能直接进行数据发送和接收，属于不可靠的、没有时序的通信，但是UDP协议的实时性比较好，通常用于视频直播相关领域。

UDP服务端

使用Go语言的net包实现的UDP服务端代码如下：

// UDP/server/main.go
// UDP server端
func main() {
    listen, err := net.ListenUDP("udp", &net.UDPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 30000,
    })
    if err != nil {
        fmt.Println("listen failed, err:", err)
        return
    }
    defer listen.Close()
    for {
        var data [1024]byte
        n, addr, err := listen.ReadFromUDP(data[:]) // 接收数据
        if err != nil {
            fmt.Println("read udp failed, err:", err)
            continue
        }
        fmt.Printf("data:%v addr:%v count:%v\n", string(data[:n]), addr, n)
        _, err = listen.WriteToUDP(data[:n], addr) // 发送数据
        if err != nil {
            fmt.Println("write to udp failed, err:", err)
            continue
        }
    }
}

UDP客户端

使用Go语言的net包实现的UDP客户端代码如下：

// UDP 客户端
func main() {
    socket, err := net.DialUDP("udp", nil, &net.UDPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 30000,
    })
    if err != nil {
        fmt.Println("连接服务端失败，err:", err)
        return
    }
    defer socket.Close()
    sendData := []byte("Hello server")
    _, err = socket.Write(sendData) // 发送数据
    if err != nil {
        fmt.Println("发送数据失败，err:", err)
        return
    }
    data := make([]byte, 4096)
    n, remoteAddr, err := socket.ReadFromUDP(data) // 接收数据
    if err != nil {
        fmt.Println("接收数据失败，err:", err)
        return
    }
    fmt.Printf("recv:%v addr:%v count:%v\n", string(data[:n]), remoteAddr, n)
}

Golang 基础知识学习笔记

17.1、socket