socket简单介绍—套接字编程

什么是Socket
Socket，英文含义是【插座、插孔】，一般称之为套接字，用于描述IP地址和端口。可以实现不同程序间的数据通信。
Socket起源于Unix，而Unix基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现，网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用：Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程。“IP地址+端口号”就对应一个socket。欲建立连接的两个进程各自有一个socket来标识，那么这两个socket组成的socket pair(套接字对)就唯一标识一个连接。因此可以用Socket来描述网络连接的一对一关系。
常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

网络应用程序设计模式

C/S模式
传统的网络应用设计模式，客户机(client)/服务器(server)模式。需要在通讯两端各自部署客户机和服务器来完成数据通信。
B/S模式
浏览器(Browser)/服务器(Server)模式。只需在一端部署服务器，而另外一端使用每台PC都默认配置的浏览器即可完成数据的传输。
优缺点
对于C/S模式来说，其优点明显。客户端位于目标主机上可以保证性能，将数据缓存至客户端本地，从而提高数据传输效率。且，一般来说客户端和服务器程序由一个开发团队创作，所以他们之间所采用的协议相对灵活。可以在标准协议的基础上根据需求裁剪及定制。例如，腾讯所采用的通信协议，即为ftp协议的修改剪裁版。
因此，传统的网络应用程序及较大型的网络应用程序都首选C/S模式进行开发。如，知名的网络游戏魔兽世界。3D画面，数据量庞大，使用C/S模式可以提前在本地进行大量数据的缓存处理，从而提高观感。
C/S模式的缺点也较突出。由于客户端和服务器都需要有一个开发团队来完成开发。工作量将成倍提升，开发周期较长。另外，从用户角度出发，需要将客户端安插至用户主机上，对用户主机的安全性构成威胁。这也是很多用户不愿使用C/S模式应用程序的重要原因。
B/S模式相比C/S模式而言，由于它没有独立的客户端，使用标准浏览器作为客户端，其工作开发量较小。只需开发服务器端即可。另外由于其采用浏览器显示数据，因此移植性非常好，不受平台限制。如早期的偷菜游戏，在各个平台上都可以完美运行。
B/S模式的缺点也较明显。由于使用第三方浏览器，因此网络应用支持受限。另外，没有客户端放到对方主机上，缓存数据不尽如人意，从而传输数据量受到限制。应用的观感大打折扣。第三，必须与浏览器一样，采用标准http协议进行通信，协议选择不灵活。
因此在开发过程中，模式的选择由上述各自的特点决定。根据实际需求选择应用程序设计模式。

TCP的C/S架构

TCP服务器代码编写

package mainimport ("fmt""net"
)func main() {//监听nerwork为tcp和udp，address为ip:端口，本地ip地址可以不写listener, err1 := net.Listen("tcp", "127.0.0.1:8080")if err1 != nil {fmt.Println("err =", err1)return}defer listener.Close() //监听关闭//阻塞等待用户连接conn, err := listener.Accept()if err != nil {fmt.Println("阻塞：err = ", err)return}//接收用户请求buf := make([]byte, 1024) //1024大小的缓冲区n, err2 := conn.Read(buf)if err2 != nil {fmt.Println("接收: err2 = ", err2)return}fmt.Println("buf = ", string(buf[:n])) //指定处理的读多少defer conn.Close() //关闭当前用户连接
}

TCP客户端代码编写

package mainimport ("fmt""net"
)func main() {//主动连接服务器conn, err := net.Dial("tcp", "127.0.0.1:8080")if err != nil {fmt.Println("err = ", err)return}defer conn.Close() //关闭//发送数据conn.Write([]byte("are you ok?"))
}

并发的C/S模型通信

并发Server

现在已经完成了客户端与服务端的通信，但是服务端只能接收一个用户发送过来的数据，怎样接收多个客户端发送过来的数据，实现一个高效的并发服务器呢？
Accept()函数的作用是等待客户端的链接，如果客户端没有链接，该方法会阻塞。如果有客户端链接，那么该方法返回一个Socket负责与客户端进行通信。所以，每来一个客户端，该方法就应该返回一个Socket与其通信，因此，可以使用一个死循环，将Accept()调用过程包裹起来。
需要注意的是，实现并发处理多个客户端数据的服务器，就需要针对每一个客户端连接，单独产生一个Socket，并创建一个单独的goroutine与之完成通信。

简单版并发服务器

package mainimport ("fmt""net""strings"
)// 处理用户请求
func HandleConn(conn net.Conn) {//函数调用完毕，自动关闭conndefer conn.Close()//获取客户端的网络地址信息addr := conn.RemoteAddr().String()fmt.Println(addr, "addr conncet sucessful") //连接成功//读取用户数据buf := make([]byte, 2048)for true {//读取用户数据read, err := conn.Read(buf)if err != nil {//read tcp 127.0.0.1:8080->127.0.0.1:56933://wsarecv: An existing connection was forcibly closed by the remote host.fmt.Println("err = ", err)return}fmt.Printf("[%s]: = %s\n", addr, string(buf[:read])) //read为读取数据的个数fmt.Println("len = ", len(string(buf[:read])))if "exit" == string(buf[:read-1]) {fmt.Println(addr, "exit")return}//把数据转化为大写，再给用户发送conn.Write([]byte(strings.ToUpper(string(buf[:read]))))}
}func main() {//监听nerwork为tcp和udp，address为ip:端口，本地ip地址可以不写listener, err1 := net.Listen("tcp", "127.0.0.1:8080")if err1 != nil {fmt.Println("err =", err1)return}defer listener.Close() //监听关闭//接收多个用户for true {conn, err := listener.Accept() //等待客户端的链接，如果客户端没有链接，该方法会阻塞if err != nil {fmt.Println("err = ", err)return}//处理用户请求，新建一个协程，每来一个就单独为它获取go HandleConn(conn)}
}

并发Client

客户端不仅需要持续的向服务端发送数据，同时也要接收从服务端返回的数据。因此可将发送和接收放到不同的协程中。
主协程循环接收服务器回发的数据（该数据应已转换为大写），并打印至屏幕；子协程循环从键盘读取用户输入数据，写给服务器。读取键盘输入可使用 os.Stdin.Read(str)。定义切片str，将读到的数据保存至str中。
这样，客户端也实现了多任务。

客户端即可输入也可接收服务器回复

package mainimport ("fmt""net""os"
)func main() {//主动连接服务器conn, err := net.Dial("tcp", "127.0.0.1:8080")if err != nil {fmt.Println("net Dial err = ", err)return}//main调用完毕，关闭连接defer conn.Close() //关闭//接收服务器回复的数据，新任务go func() {//从键盘输入内容，给服务器发送内容str := make([]byte, 1024)for true {n, err2 := os.Stdin.Read(str) //从键盘读取内容,放在strif err2 != nil {fmt.Println("os.Stdin.err = ", err)return}//把输入的内容给服务器发送conn.Write(str[:n])}}()//切片缓存buf := make([]byte, 1024)//不停地接收for true {n, err := conn.Read(buf) //接收服务器的请求if err != nil {fmt.Println("conn.Read err = ", err)return}fmt.Println(string(buf[:n])) //打印接收到的内容，转换为字符串再打印}
}

TCP通信

下图是一次TCP通讯的时序图。TCP连接建立断开。包含大家熟知的三次握手和四次握手。

三次握手：
所谓三次握手（Three-Way Handshake）即建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。好比两个人在打电话：
Client:“喂，你听得到吗？”
Server:“我听得到，你听得到我吗？”
Client:“我能听到你，今天balabala…”
建立连接（三次握手）的过程：
1.客户端发送一个带SYN标志的TCP报文到服务器。这是上图中三次握手过程中的段1。客户端发出SYN位表示连接请求。序号是1000，这个序号在网络通讯中用作临时的地址，每发一个数据字节，这个序号要加1，这样在接收端可以根据序号排出数据包的正确顺序，也可以发现丢包的情况。
另外，规定SYN位和FIN位也要占一个序号，这次虽然没发数据，但是由于发了SYN位，因此下次再发送应该用序号1001。
mss表示最大段尺寸，如果一个段太大，封装成帧后超过了链路层的最大长度，就必须在IP层分片，为了避免这种情况，客户端声明自己的最大段尺寸，建议服务器端发来的段不要超过这个长度。
2.服务器端回应客户端，是三次握手中的第2个报文段，同时带ACK标志和SYN标志。表示对刚才客户端SYN的回应；同时又发送SYN给客户端，询问客户端是否准备好进行数据通讯。
服务器发出段2，也带有SYN位，同时置ACK位表示确认，确认序号是1001，表示“我接收到序号1000及其以前所有的段，请你下次发送序号为1001的段”，也就是应答了客户端的连接请求，同时也给客户端发出一个连接请求，同时声明最大尺寸为1024。
3.客户必须再次回应服务器端一个ACK报文，这是报文段3。
客户端发出段3，对服务器的连接请求进行应答，确认序号是8001。在这个过程中，客户端和服务器分别给对方发了连接请求，也应答了对方的连接请求，其中服务器的请求和应答在一个段中发出。
因此一共有三个段用于建立连接，称为“三方握手”。在建立连接的同时，双方协商了一些信息，例如，双方发送序号的初始值、最大段尺寸等。
数据传输的过程：
1.客户端发出段4，包含从序号1001开始的20个字节数据。
2.服务器发出段5，确认序号为1021，对序号为1001-1020的数据表示确认收到，同时请求发送序号1021开始的数据，服务器在应答的同时也向客户端发送从序号8001开始的10个字节数据。
3.客户端发出段6，对服务器发来的序号为8001-8010的数据表示确认收到，请求发送序号8011开始的数据。
在数据传输过程中，ACK和确认序号是非常重要的，应用程序交给TCP协议发送的数据会暂存在TCP层的发送缓冲区中，发出数据包给对方之后，只有收到对方应答的ACK段才知道该数据包确实发到了对方，可以从发送缓冲区中释放掉了，如果因为网络故障丢失了数据包或者丢失了对方发回的ACK段，经过等待超时后TCP协议自动将发送缓冲区中的数据包重发。
四次挥手：
所谓四次挥手（Four-Way-Wavehand）即终止TCP连接，就是指断开一个TCP连接时，需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中，这一过程由客户端或服务器任一方执行close来触发。好比两个人打完电话要挂断：
Client:“我要说的事情都说完了，我没事了。挂啦？”
Server:“等下，我还有一个事儿。Balabala…”
Server:“好了，我没事儿了。挂了啊。”
Client:“ok！拜拜”
关闭连接（四次握手）的过程：
由于TCP连接是全双工的，因此每个方向都必须单独进行关闭。这原则是当一方完成它的数据发送任务后就能发送一个FIN来终止这个方向的连接。收到一个 FIN只意味着这一方向上没有数据流动，一个TCP连接在收到一个FIN后仍能发送数据。首先进行关闭的一方将执行主动关闭，而另一方执行被动关闭。
1.客户端发出段7，FIN位表示关闭连接的请求。
2.服务器发出段8，应答客户端的关闭连接请求。
3.服务器发出段9，其中也包含FIN位，向客户端发送关闭连接请求。
4.客户端发出段10，应答服务器的关闭连接请求。
建立连接的过程是三次握手，而关闭连接通常需要4个段，服务器的应答和关闭连接请求通常不合并在一个段中，因为有连接半关闭的情况，这种情况下客户端关闭连接之后就不能再发送数据给服务器了，但是服务器还可以发送数据给客户端，直到服务器也关闭连接为止。

UDP通信

在之前的案例中，我们一直使用的是TCP协议来编写Socket的客户端与服务端。其实也可以使用UDP协议来编写Socket的客户端与服务端。
UDP服务器
由于UDP是“无连接”的，所以，服务器端不需要额外创建监听套接字，只需要指定好IP和port，然后监听该地址，等待客户端与之建立连接，即可通信。
创建监听地址：
func ResolveUDPAddr(network, address string) (*UDPAddr, error)
创建监听连接：
func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)
接收udp数据：
func (c *UDPConn) ReadFromUDP(b []byte) (int, *UDPAddr, error)
写出数据到udp：
func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

文件传输原理

UDP与TCP的差异

os.Stat的使用

package mainimport ("fmt""os"
)func main() {list := os.Argsfmt.Println(len(list))if len(list) != 2 {fmt.Println("useage :xxx file")return}for i, s := range list {fmt.Println(i, s)}fileName := list[1]fmt.Printf("fileName = %s\n", fileName)//Stat返回一个描述name指定的文件对象的FileInfo。如果指定的文件对象是一个符号链接，//返回的FileInfo描述该符号链接指向的文件的信息，本函数会尝试跳转该链接。如果出错，返回的错误值为*PathError类型。//过滤路径info, err := os.Stat(fileName)if err != nil {fmt.Println("err = ", err)}fmt.Println("name = ", info.Name()) //name =  01_昨日回顾.mp4fmt.Println("size = ", info.Size()) //size =  67010611
}

传输文件：发送方

package mainimport ("fmt""io""net""os"
)func sendFile(path string, conn net.Conn) {//以只读方式打开文件file, err := os.Open(path)if err != nil {fmt.Println("send Open err = ", err)return}defer file.Close()//读文件内容,读多少发多少，一点不差buf := make([]byte, 1024*4)for true {read, err := file.Read(buf) //从文件读取内容if err != nil {if err == io.EOF {fmt.Println("文件发送完毕")} else {fmt.Println("send Rend err = ", err)}return}//发送内容conn.Write(buf[:read]) //给服务器发送内容}
}func main() {//提示输入文件fmt.Println("请输入需要传输的文件: ")var path string_, err := fmt.Scan(&path)if err != nil {fmt.Println("Scan open err = ", err)return}//获取文件名fileInfo, err := os.Stat(path)if err != nil {fmt.Println("os.Stat err = ", err)return}//主动连接服务器conn, err := net.Dial("tcp", "127.0.0.1:8000")if err != nil {fmt.Println("net.Dial err = ", err)return}defer conn.Close()//给接收方，先发送文件名_, err = conn.Write([]byte(fileInfo.Name()))if err != nil {fmt.Println("conn.write err = ", err)return}//接收对方的回复，如果回复ok，说明对方准备好，可以发文件buf := make([]byte, 1024)readSize, err := conn.Read(buf)if err != nil {fmt.Println("conn.Read err = ", err)return}if "ok" == string(buf[:readSize]) {//发送文件内容sendFile(path, conn)}
}

传输文件:接收方

package mainimport ("fmt""io""net""os"
)// RecvFile 接收文件内容
func RecvFile(fileName string, conn net.Conn) {//新建文件file, err := os.Create(fileName)if err != nil {fmt.Println("os create err =", err)return}buf := make([]byte, 1024*4)//接收多少，写多少，一点不差for true {readSize, err := conn.Read(buf) //接收对方发过来的文件内容if err != nil {if err == io.EOF {fmt.Println("文件接收完毕")} else {fmt.Println("conn read err =", err)}return}if readSize == 0 {fmt.Println("n == 0 文件接收完毕")return}file.Write(buf[:readSize])}
}func main() {//监听listener, err := net.Listen("tcp", "127.0.0.1:8000")if err != nil {fmt.Println("net listener err = ", err)return}defer listener.Close()//阻塞等待用户连接conn, err := listener.Accept()if err != nil {fmt.Println("listener accept err =", err)return}defer conn.Close()buf := make([]byte, 1024)//读取对方发送的文件名readSize, err := conn.Read(buf)if err != nil {fmt.Println("conn read err =", err)return}fileName := string(buf[:readSize])//回复"ok"_, err1 := conn.Write([]byte("ok"))if err1 != nil {return}//接收文件内容RecvFile(fileName, conn)
}