go语言基础操作---七
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 main
import (
"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 main
import (
"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 main
import (
"fmt"
"net"
"strings"
)
// 处理用户请求
func HandleConn(conn net.Conn) {
//函数调用完毕，自动关闭conn
defer 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 main
import (
"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) //从键盘读取内容,放在str
if 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 main
import (
"fmt"
"os"
)
func main() {
list := os.Args
fmt.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_昨日回顾.mp4
fmt.Println("size = ", info.Size()) //size = 67010611
}
传输文件：发送方
package main
import (
"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 main
import (
"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)
}