网络编程-socket

前言:学习本章需要先了解网络协议, 详见:网络通讯协议

本章目录

一.什么是socket

二.为什么需要socket

三.socket的发展

四.python中的socket

五.基于TCP的socket

六.基于UDP的socket

六. 粘包问题详解

七.粘包的解决方案

引入:为什么一定要先学习网络协议?

之所以学习网络编程就是为了让我们的程序能够利用网络来传输数据,开发出C/S构架的应用程序

而网络的核心,就是协议,没有协议就没有互联网,我们要开发出C/S结构程序则必须遵循这些协议的标准!

就像上帝说可以帮你完成一个愿望,然而上帝和你对话时,你说的话上帝完全听不懂,所有你必须了解上帝使用的语言,说他能听懂的话!

一.什么是socket

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

socket在OSI模型中的位置

二.为什么需要socket

在标准的OIS模型中并没有规定说必须有socket层,也就是说不使用socket也能完成通讯,是的,的确如此!

那为什么需要socket呢?一个字 懒,程序员都是懒的!

我们发现还没有开始实现应用程序逻辑,就需要花大把时间来实现各种协议,太特么费事儿了,就有人专门把协议中一堆复杂的事情进行了封装,于是socket就诞生了!

有了socket以后,无需自己编写代码实现三次握手,四次挥手,ARP请求,打包数据等等，socket已经封装好了，只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

三.socket的发展

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于大部通讯都是网络通讯，所以大部分时候使用AF_INET)

以下内容代码基于python,后续将补充java实现代码----------------

四.python中的socket

需明确:关于网络协议 和socket相关概念,对于所有编程语言都是一致的,区别仅仅是各编程语言的函数名称不同

# 1.导入socket模块
import socket
# 2.创建socket对象 函数定义如下
socket.socket(socket_family,socket_type,protocal=0)
	#socket_family 可以是 AF_UNIX 或 AF_INET。
	#socket_type 可以是 SOCK_STREAM表示TCP协议 或 SOCK_DGRAM表示UDP协议。
	#protocol 一般不填,默认值为 0。
    
# 2.1获取TCP 套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 或者 后面的参数都有默认值,可以不写,默认创建的是TCP协议socket
tcpSock = socket.socket()

# 2.2获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

#由于 socket 模块中有太多的属性。可以使用'from module import *'语句。使用 'from socket import *',把 socket 模块里的所有属性都导入当前命名空间里了,这样能大幅减短代码。
#例如:tcpSock = socket(AF_INET, SOCK_STREAM)

要明确一点:无论是客户端服务器端都使用的都是socket对象

服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall()         发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

四.1基于TCP的socket

前言:已经明确socket是别人封装好的接口,使用接口就变的简单了

按照通讯流程编写代码即可

1.TCP通讯流程

重点是要先接受通话请求 才能建立连接进行通话

TCP的通讯流程与打电话的过程非常相似

买手机 == socket()
装进手机卡 == bind()
待机 == listen()
电话来了 接受通话 == accept()
听 == read()
说 == write()
挂电话 == close()

2.TCP服务端

import socket
ip_port=('127.0.0.1',9000)  #电话卡
BUFSIZE=1024                #收发消息的尺寸
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5)     #手机待机

conn,addr=s.accept()            #手机接电话

print('接到来自%s的电话' %addr[0])

msg=conn.recv(BUFSIZE)             #听消息,听话
print(msg,type(msg))

conn.send(msg.upper())          #发消息,说话

conn.close()                    #挂电话

s.close()                       #手机关机

服务端

3.TCP客户端

import socket
ip_port=('127.0.0.1',9000)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect(ip_port)           #拨电话

s.send('linhaifeng nb'.encode('utf-8'))         #发消息,说话(只能发送字节类型)

feedback=s.recv(BUFSIZE)                           #收消息,听话
print(feedback.decode('utf-8'))

s.close()                                       #挂电话

注意TCP中必须先启动服务器再启动客户端,否则客户端由于无法链接服务器,直接报错!

如上就完成了一个最基本的TCP通讯,但是建立是为了传输数据,二传输数据很多时候并不是一次性就传输完成了,需要多次收发过程,所以需要给代码加上循环

4.改进版服务器端

import socket
ip_port=('127.0.0.1',8081)#电话卡
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5)     #手机待机

while True:                         #新增接收链接循环,可以不停的接电话
    conn,addr=s.accept()            #手机接电话
    # print(conn)
    # print(addr)
    print('接到来自%s的电话' %addr[0])
    while True:                         #新增通信循环,可以不断的通信,收发消息
        msg=conn.recv(BUFSIZE)             #听消息,听话
        print(msg,type(msg))
        conn.send(msg.upper())          #发消息,说话
    conn.close()                    #挂电话
s.close()                       #手机关机

5.改进版客户端

import socket
ip_port=('127.0.0.1',8081)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect_ex(ip_port)           #拨电话

while True:                             #新增通信循环,客户端可以不断发收消息
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    s.send(msg.encode('utf-8'))         #发消息,说话(只能发送字节类型)
    
    feedback=s.recv(BUFSIZE)                           #收消息,听话
    print(feedback.decode('utf-8'))
s.close()                                       #挂电话

6.常见错误:

1.端口占用

在调试过程中,可能会遇见以下错误:

问题发生原因:

1.可能是由于你已经启动了服务器程序,却又再次启动了服务器程序,同一个端口不能被多个进程使用导致!

2.三次握手或四次挥手时,发生了异常导致对方程序已经结束而服务器任然处于time_wait状态导致!

3.在高并发的场景下,由于链接的客户端太多,也会产生大量处于time_wait状态的链接

解决的方案:

​ 第1种原因,很简单关闭之前运行的服务器即可

​ 第2,3中原因导致的问题,有两种解决方案:

1.设置服务器重用端口

#加入一条socket配置，重用ip和端口
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，必须在bind前加
phone.bind(('127.0.0.1',8081))

2.通过调整linux内核参数解决(了解)

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf
编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
然后执行 /sbin/sysctl -p 让参数生效。
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；
net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；
net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。
net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

2.强行关闭链接

(发生错误演示,运行上面的改进版的服务器与客户端,链接成功后直接停止客户端程序)

当客服端与服务器链接成功后,如果一方没有执行close,而是直接强行终止程序(或是遇到异常被迫终止),都会导致另一方发送问题,

在windows下,接收数据的一方在recv函数处将抛出异常

Traceback (most recent call last):
  File "C:/Users/jerry/PycharmProjects/untitled/TCP/server.py", line 9, in <module>
    conn.recv(1024)
ConnectionResetError: [WinError 10054] 远程主机强迫关闭了一个现有的连接。

linux下,不会抛出异常会导致接收数据的一方,recv方法不断的收到空消息,造成死循环

要使应用程序能够在不同平台正常工作,那需要分别处理这两个问题

解决方案如下:

import socket
ip_port=('127.0.0.1',8081)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(ip_port)
s.listen(5)    
while True:                        
    conn,addr=s.accept()           
    while True:                         
        try:
            msg=conn.recv(BUFSIZE)             
            #linux不会抛出异常,会接收到空消息,这里加以判断
            if not msg:
                conn.close()
                break
            print(msg,type(msg))
            conn.send(msg.upper())        
       except ConnectionResetError:
        	#只要异常发生则意味着对方以及关闭了,服务器也相应的关闭该链接
            conn.close()
            break
    conn.close()              
s.close()                       

至此TCP通讯模板程序就完成了,可以不断的接收新的链接,不断的收发消息,并且不会因为客户端强制关闭而异常退出!

五.基于UDP的socket

1.UDP 通讯流程

UDP通讯流程与对讲机非常类似

买传呼机 == socket()
固定对讲频道 == bind()
收信号 == recvfrom()
发信号 == sendto()
由于不需要建立 连接所以省去 TCP的listen()和accept()这两步

2.UDP服务器端

import socket
ip_port=('127.0.0.1',9000) # 固定通讯频道
BUFSIZE=1024
#在TCP中socket的初始化参数可以省略, 因为默认创建的就是TCP协议的socket
#而UDP则必须手动指定相关参数
udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 买对讲机
udp_server_client.bind(ip_port) 
while True:
    msg,addr=udp_server_client.recvfrom(BUFSIZE) #收信息
    print(msg,addr)
    udp_server_client.sendto(msg.upper(),addr) # 发信息

3.UDP客户端

import socket
ip_port=('127.0.0.1',9000) #确定通讯频道
BUFSIZE=1024
udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 买对讲机
while True:
    msg=input('>>: ').strip()
    if not msg:continue
    udp_server_client.sendto(msg.encode('utf-8'),ip_port) # 发消息
    back_msg,addr=udp_server_client.recvfrom(BUFSIZE) #收消息

udp是无链接的，先启动哪一端都不会报错,即使对方地址根本不存在也不会报错,强制关闭任何一方也没有任何问题

另外,由于无连接的特点,服务器不需要针对摸个客户端进行循环,只要循环的接收即可,谁发来的消息都可以被处理,基于这个特点我们可以编写一个UDP程序,实现多个客户端同时与服务器通讯

4.UDP聊天服务器

import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回复消息: ').strip()
    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

5.UDP聊天客户端

import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={
    '狗哥':('127.0.0.1',8081),
    '天线宝宝':('127.0.0.1',8081),
    '巴拉巴拉小魔女':('127.0.0.1',8081),
    '王尼玛':('127.0.0.1',8081),
}

while True:
    qq_name=input('请选择聊天对象: ').strip()
    while True:
        msg=input('请输入消息,回车发送: ').strip()
        if msg == 'quit':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])
        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
        print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))
udp_client_socket.close()

客户端1

客户端2

服务器:

六. 粘包问题

什么是粘包？

粘包指的是数据与数据之间没有明确的分界线，导致不能正确读取数据！

要理解粘包问题，需要先了解TCP协议传输数据时的具体流程，TCP协议也称之为流式协议(UDP称为数据报协议)

应用程序无法直接操作硬件，应用程序想要发送数据则必须将数据交给操作系统，而操作系统需要需要同时为所有应用程序提供数据传输服务，也就意味着，操作系统不可能立马就能将应用程序的数据发送出去，就需要为应用程序提供一个缓冲区，用于临时存放数据，具体流程如下：

发送方：

当应用程序调用send函数时，应用程序会将数据从应用程序拷贝到操作系统缓存，再由操作系统从缓冲区读取数据并发送出去

接收方：

对方计算机收到数据也是操作系统先收到，至于应用程序何时处理这些数据，操作系统并不清楚，所以同样需要将数据先存储到操作系统的缓冲区中，当应用程序调用recv时，实际上是从操作系统缓冲区中将数据拷贝到应用程序的过程

上述过程对于TCP与UDP都是相同的不同之处在于：

UDP：

UDP在收发数据时是基于数据包的，即一个包一个包的发送，包与包之间有着明确的分界，到达对方操作系统缓冲区后也是一个一个独立的数据包，接收方从操作系统缓冲区中将数据包拷贝到应用程序

这种方式存在的问题：

1.发送方发送的数据长度每个操作系统会有不同的限制，数据超过限制则无法发送

2.接收方接收数据时如果应用程序的提供的缓存容量小于数据包的长度将造成数据丢失，而缓冲区大小不可能无限大

TCP：

当我们需要传输较大的数据，或需要保证数据完整性时，最简单的方式就是使用TCP协议了

与UDP不同的是，TCP增加了一套校验规则来保证数据的完整性，会将超过TCP包最大长度的数据拆分为多个TCP包 并在传输数据时为每一个TCP数据包指定一个顺序号，接收方在收到TCP数据包后按照顺序将数据包进行重组，重组后的数据全都是二进制数据，且每次收到的二进制数据之间没有明显的分界

基于这种工作机制TCP在三种情况下会发送粘包问题

1.当单个数据包较小时接收方可能一次性读取了多个包的数据

2.当整体数据较大时接收方可能一次仅读取了一个包的一部分内容

3.另外TCP协议为了提高效率，增加了一种优化机制，会将数据较小且发送间隔较短的数据合并发送，该机制也会导致发送方将两个数据包粘在一起发送

七.粘包的解决方案

理解了粘包问题后，接下来就是如何来解决它了

1.基础解决方案

首先明确只有TCP会出现粘包问题，之所以粘包是因为接收方不知道一次该接收的数据长度，那如何才能让接收方知道数据的长度呢？

解决方案：

在发送数据前先发送数据长度

客户端：

import socket

c = socket.socket()
c.connect(("127.0.0.1",8888))
while True:
    cmd = input(">>>:").strip()
    c.send(cmd.encode("utf-8"))

    data = c.recv(1024)
    length = int(data.decode("utf-8"))
    print(length)
    size = 0
    res = b""
    while size < length:
        temp = c.recv(1024)
        size += len(temp)
        res += temp
    print(res.decode("gbk"))

服务器：

import socket
import subprocess
server = socket.socket()
server.bind(("127.0.0.1",8888))
server.listen()

while True:
    client, addr = server.accept()
    while True:
        cmd = client.recv(1024).decode("utf-8")
        p = subprocess.Popen(cmd,shell=True,stdout=-1,stderr=-1)
        data = p.stdout.read()+p.stderr.read()
        length = str(len(data))
        client.send(length.encode("utf-8"))
        print(length)
        client.sendall(data)

上述方案 看起来解决了粘包问题

但是由于negle优化机制的存在，长度信息和数据还是有可能会粘包，而接受方并不知道长度信息具体几个字节，所以现在的问题是如何能够长度信息做成一个固定长度的bytes数据

我们可以将字符串拼接为一个固定长度的字符 但是这样太麻烦，struct模块为我们提供了一个功能，可以将整数类型转换为固定长度的bytes，此时就派上用场了

# struct模块使用
import  struct
# 整型转bytes
res =  struct.pack("i",100)
print(res)
print(len(res))

# bytes转整型
res2 = struct.unpack("i",res) # 返回一个元组
print(res2)
print(res2[0])

解决方案修正

客户端：

import socket
import struct
c = socket.socket()
c.connect(("127.0.0.1",8888))
while True:
    cmd = input(">>>:").strip()
    c.send(cmd.encode("utf-8"))

    data = c.recv(4)
    length = struct.unpack("i",data)[0]
    
    print(length)
    size = 0
    res = b""
    while size < length:
        temp = c.recv(1024)
        size += len(temp)
        res += temp
    print(res.decode("gbk"))

服务器：

import socket
import subprocess
import struct
server = socket.socket()
server.bind(("127.0.0.1",8888))
server.listen()

while True:
    client, addr = server.accept()
    while True:
        cmd = client.recv(1024).decode("utf-8")
        p = subprocess.Popen(cmd,shell=True,stdout=-1,stderr=-1)
        data = p.stdout.read()+p.stderr.read()
        length = len(data)
        len_data = struct.pack("i",length)
        client.send(len_data)

        print(length)
        client.send(data)

2.自定义报头解决粘包

上述方案已经完美解决了粘包问题，但是扩展性不高，例如我们要实现文件上传下载，不光要传输文件数据，还需要传输文件名字，md5值等等，如何能实现呢？

具体思路：

发送端：

1.先将所有的额外信息打包到一个头中

2.然后先发送头部数据

3.最后发送真实数据

接收端：

1.接收固定长度的头部长度数据

2.根据长度数据获取头部数据

3.根据头部数据获取真实数据

CMD程序自定义报头：

客户端：

import socket
import struct
import json
c = socket.socket()
c.connect(("127.0.0.1",8888))
while True:
    cmd = input(">>>:").strip()
    c.send(cmd.encode("utf-8"))
	
    # 头部数据
    data = c.recv(4)
    head_length = struct.unpack("i",data)[0]
    head_data = c.recv(head_length).decode("utf-8")
    head = json.loads(head_data)
    print(head)

    # 真实数据长度
    data_length = head["data_size"]

    #接收真实数据
    size = 0
    res = b""
    while size < data_length:
        temp = c.recv(1024)
        size += len(temp)
        res += temp

    print(res.decode("gbk"))

服务器：

import socket
import subprocess
import struct
import json
server = socket.socket()
server.bind(("127.0.0.1",8888))
server.listen()

while True:
    client, addr = server.accept()
    while True:
        cmd = client.recv(1024).decode("utf-8")
        p = subprocess.Popen(cmd,shell=True,stdout=-1,stderr=-1)
		
        # 真实数据
        data = p.stdout.read() + p.stderr.read()
        
        # 头部数据
        head = {"data_size":len(data),"额外信息":"额外的值"}
        head_data = json.dumps(head).encode("utf-8")
        #头部长度
        head_len = struct.pack("i",len(head_data))

        #逐个发送
        client.send(head_len)
        client.send(head_data)
        client.send(data)

至此粘包问题就完美解决了