一、软件开发的架构
1: C/S架构
Client与Server 客户端与服务器端,这里的客户端一般泛指客户端应用EXE,程序需要先安装后,才能运行在用户的电脑上,对用户的电脑操作系统环境依赖较大。
2: B/S架构
Browser与Server 浏览器端与服务器端。
Browser浏览器,其实也是一种Client客户端,只是这个客户端不需要去安装什么应用程序,只需在浏览器上通过HTTP请求服务器端相关的资源。
二、网络基础
IP地址:指互联网协议地址。
IP地址是IP协会提供的一种统一的地址格式,它为互联网上的每一个网络和每一台主机分配一个逻辑地址,以此来屏蔽物理地址的差异。
IP地址是一个32位的二进制数,通常被分割为4个‘8位二进制数’。
IP地址通常用“点分十进制”表示(a,b,c,d)的形式,其中,a,b,c,d都是0~255之间的十进制整数。
端口可以认为是设备与外界通讯交流的出口。
因此IP地址可以精确到具体的一台电脑,而端口精确到具体的程序。
通过子网掩码,我们就能判断,任意两个IP地址是否处在同一个子网络。方法是将两个IP地址与子网掩码分别进行AND运算(两个位数都是1,则结果1,反之0),然后比较结果是否相同,如果是的话,就表示它们在同一个子网络中,否则就不是。
总结一下,IP协议的作用主要有两个:一个是为每一台计算机分配IP地址,另一个是确定哪些地址在同一个子网络。
TCP协议
TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户与服务器彼此交换数据前,必须先在双方之间建立一个TCP连接,之后才能传输数据。TCP提供超时重发,丢弃重复数据,检验数据,流量控制等功能,保证数据能从一端传输到另一端。
可靠的、面向连接的协议(eg:打电话)、传输效率低全双工通信(发送缓存&接收缓存)、面向字节流。使用TCP的应用:Web浏览器;电子邮件、文件传输程序。
TCP是因特网中的传输层协议,使用三次握手协议建立连接。当主动方发出SYN连接请求后,等待对方回答SYN+ACK[1],并最终对对方的 SYN 执行 ACK 确认。这种建立连接的方法可以防止产生错误的连接。[1]
TCP三次握手的过程如下:
客户端发送SYN(SEQ=x)报文给服务器端,进入SYN_SEND状态。
服务器端收到SYN报文,回应一个SYN (SEQ=y)ACK(ACK=x+1)报文,进入SYN_RECV状态。
客户端收到服务器端的SYN报文,回应一个ACK(ACK=y+1)报文,进入Established状态。
三次握手完成,TCP客户端和服务器端成功地建立连接,可以开始传输数据了。
tcp的三次握手
建立一个连接需要三次握手,而终止一个连接要经过四次握手,这是由TCP的半关闭(half-close)造成的。
(1) 某个应用进程首先调用close,称该端执行“主动关闭”(active close)。该端的TCP于是发送一个FIN分节,表示数据发送完毕。
(2) 接收到这个FIN的对端执行 “被动关闭”(passive close),这个FIN由TCP确认。
注意:FIN的接收也作为一个文件结束符(end-of-file)传递给接收端应用进程,放在已排队等候该应用进程接收的任何其他数据之后,因为,FIN的接收意味着接收端应用进程在相应连接上再无额外数据可接收。
(3) 一段时间后,接收到这个文件结束符的应用进程将调用close关闭它的套接字。这导致它的TCP也发送一个FIN。
(4) 接收这个最终FIN的原发送端TCP(即执行主动关闭的那一端)确认这个FIN。[1]
既然每个方向都需要一个FIN和一个ACK,因此通常需要4个分节。
注意:
(1) “通常”是指,某些情况下,步骤1的FIN随数据一起发送,另外,步骤2和步骤3发送的分节都出自执行被动关闭那一端,有可能被合并成一个分节。[2]
(2) 在步骤2与步骤3之间,从执行被动关闭一端到执行主动关闭一端流动数据是可能的,这称为“半关闭”(half-close)。
(3) 当一个Unix进程无论自愿地(调用exit或从main函数返回)还是非自愿地(收到一个终止本进程的信号)终止时,所有打开的描述符都被关闭,这也导致仍然打开的任何TCP连接上也发出一个FIN。
无论是客户还是服务器,任何一端都可以执行主动关闭。通常情况是,客户执行主动关闭,但是某些协议,例如,HTTP/1.0却由服务器执行主动关闭。[2]
tcp的四次挥手
UDP协议
UDP---用户数据报协议,是一个简单的面向数据报的运输层协议。UDP不提供可靠性,它只是把应用程序传给IP层的数据报发送出去,但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接,且没有超时重发等机制,故而传输速度很快。
不可靠的、无连接的服务,传输效率高(发送前时延小),一对一、一对多、多对一、多对多、面向报文,尽最大努力服务,无拥塞控制。使用UDP的应用:域名系统 (DNS);视频流;IP语音(VoIP)。
互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层
每层运行常见的物理设备
传输层——> 四层交换机、四层的路由器
网络层——>路由器、三层交换机
数据链路层——>网桥、以太网交换机、网卡
物理层——>中继器、集线器、双绞线
每层运行常见的协议
应用层——>。。。
传输层——>TCP与UDP协议
网络层——>ip协议
数据链路层——>arp协议 (通过ip找mac地址)
物理层——>。。。
交换机:广播 单播 组播
ip协议:ip地址的格式
# ip地址 一台机器在一个网络内唯一的标识
# 子网掩码 ip地址与子网掩码做按位与运算,得到的结果是网段
# 网关ip 局域网内的机器访问公网ip,就通过网关访问
三、socket
Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。
socket和file的区别:
1:file模块是针对某个指定文件进行打开、读写、关闭
2:socket模块是针对服务器端和客户端socket进行打开、读写、关闭
基于文件类型的套接字家族
套接字家族的名字:AF_UNIX
unix一切皆文件,基于文件的套接字调用的就是底层的文件系统来取数据,两个套接字进程运行在同一机器,可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族
套接字家族的名字:AF_INET
(还有AF_INET6被用于ipv6,还有一些其他的地址家族,不过,他们要么是只用于某个平台,要么就是已经被废弃,或者是很少被使用,或者是根本没有实现,所有地址家族中,AF_INET是使用最广泛的一个,python支持很多种地址家族,但是由于我们只关心网络编程,所以大部分时候我么只使用AF_INET)
基于TCP协议的socket
tcp是基于链接的,必须先启动服务端,然后再启动客户端去链接服务端
importsocket
sk=socket.socket()
sk.bind(('127.0.0.1',8898)) #把地址绑定到套接字
sk.listen() #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024) #接收客户端信息
print(ret) #打印客户端信息
conn.send(b'hi') #向客户端发送信息
conn.close() #关闭客户端套接字
sk.close() #关闭服务器套接字(可选)
服务端
importsocket
sk= socket.socket() #创建客户套接字
sk.connect(('127.0.0.1',8898)) #尝试连接服务器
sk.send(b'hello!')
ret= sk.recv(1024) #对话(发送/接收)
print(ret)
sk.close()#关闭客户套接字
客户端
tcp实现与多个客户端通信,必须结束一个客户端,才能到下一个客户端。
#服务器端
importsocket#tcp协议
sk = socket.socket() #创建一个socket对象
sk.bind(('127.0.0.1',8080)) #给server端绑定一个ip和端口
sk.listen()whileTrue:
conn,addr=sk.accept()whileTrue:
msg= conn.recv(1024).decode('utf-8') #阻塞,直到收到一个客户端发来的消息
print(msg)if msg == 'bye':breakinfo= input('>>>')if info == 'bye':
conn.send(b'bye')breakconn.send(info.encode('utf-8')) #发消息
conn.close() #关闭连接
sk.close() #关闭socket对象,如果不关闭,还能继续接收
#客户端1
importsocket
sk=socket.socket()
sk.connect(('127.0.0.1',8080))whileTrue:
msg= input('>>>')if msg == 'bye':
sk.send(b'bye')breaksk.send(msg.encode('utf-8'))
ret= sk.recv(1024).decode('utf-8')if ret == 'bye':break
print(ret)
sk.close()#客户端2
importsocket
sk=socket.socket()
sk.connect(('127.0.0.1',8080))whileTrue:
msg= input('client2:>>>')if msg == 'bye':
sk.send(b'bye')breaksk.send(('client2 :'+msg).encode('utf-8'))
ret= sk.recv(1024).decode('utf-8')if ret == 'bye':break
print(ret)
sk.close()
tcp服务器与多个客户端通信
基于udp协议的socket
#服务器端
importsocket
sk= socket.socket(type=socket.SOCK_DGRAM) #DGRAM datagram
sk.bind(('127.0.0.1',8080)) #只有服务端有的
msg,addr= sk.recvfrom(1024)print(msg.decode('utf-8'))
sk.sendto(b'bye',addr)
sk.close()#udp的server 不需要进行监听也不需要建立连接#在启动服务之后只能被动的等待客户端发送消息过来#客户端发送消息的同时还会 自带地址信息#消息回复的时候 不仅需要发送消息,还需要把对方的地址填写上
#客户端
importsocket
sk= socket.socket(type=socket.SOCK_DGRAM)
ip_port= ('127.0.0.1',8080)
sk.sendto(b'hello',ip_port)
ret,addr= sk.recvfrom(1024)print(ret.decode('utf-8'))
sk.close()#client端不需要connect 因为UDP协议是不需要建立连接的#直接了解到对方的ip和端口信息就发送数据就行了#sendto和recvfrom的使用方法是完全和server端一致的
#client端不需要connect 因为UDP协议是不需要建立连接的#直接了解到对方的ip和端口信息就发送数据就行了#sendto和recvfrom的使用方法是完全和server端一致的
基于udp协议的socket
#服务器端
importsocket
sk= socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8080))whileTrue:
msg,addr= sk.recvfrom(1024)print(addr)print(msg.decode('utf-8'))
info= input('>>>').encode('utf-8')
sk.sendto(info,addr)
sk.close()#客户端1
importsocket
sk= socket.socket(type=socket.SOCK_DGRAM)
ip_port= ('127.0.0.1',8080)whileTrue:
info= input('tiger :')
info= ('\033[34m来自tiger的消息 :%s\033[0m'%info).encode('utf-8')
sk.sendto(info,ip_port)
msg,addr= sk.recvfrom(1024)print(msg.decode('utf-8'))
sk.close()#客户端2
importsocket
sk= socket.socket(type=socket.SOCK_DGRAM)
ip_port= ('127.0.0.1',8080)whileTrue:
info= input('二哥 :')
info= ('\033[32m来自二哥的消息 :%s\033[0m'%info).encode('utf-8')
sk.sendto(info,ip_port)
msg,addr= sk.recvfrom(1024)print(msg.decode('utf-8'))
sk.close()
QQ聊天
#服务器端
importtimeimportsocket
sk= socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8090))whileTrue:
strf,addr= sk.recvfrom(1024)
strf= strf.decode('utf-8')
res= time.strftime(strf).encode('utf-8')
sk.sendto(res,addr)
sk.close()#客户端
importsocket
sk= socket.socket(type=socket.SOCK_DGRAM)
addr= ('127.0.0.1',8090)
info= input('>>>').encode('utf-8')
sk.sendto(info,addr)
ret,addr= sk.recvfrom(1024)print(ret.decode('utf-8'))
sk.close()
格式化时间
服务端套接字函数
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() 得到阻塞套接字操作的超时时间
面向文件的套接字的函数
s.fileno() 套接字的文件描述符
s.makefile() 创建一个与该套接字相关的文件
四、黏包
黏包:同时执行多条命令之后,得到的结果很可能只有一部分,在执行其他命令的时候又接收到之前执行的另外一部分结果,这种显现就是黏包。
只有TCP有黏包现象,UDP永远不会黏包:
1.从表面上看,黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
2.实际上,主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少个字节的数据所造成的。
用UDP协议发送时,用sendto函数最大能发送数据的长度为:65535- IP头(20) – UDP头(8)=65507字节。用sendto函数发送数据时,如果发送数据长度大于该值,则函数会返回错误。(丢弃这个包,不进行发送)
用TCP协议发送时,由于TCP是数据流协议,因此不存在包大小的限制(暂不考虑缓冲区的大小),这是指在用send函数时,数据长度参数不受限制。而实际上,所指定的这段数据并不一定会一次性发送出去,如果这段数据比较长,会被分段发送,如果比较短,可能会等待和下一次数据一起发送。发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去,这样接收方就收到了粘包数据。
会发生黏包的两种情况:
1、发送方的缓存机制
发送端需要等缓冲区满才发送出去,造成黏包(发送数据时间间隔很短,数据量很小,会合到一起,产生黏包)
importsocket
ip_port=('127.0.0.1',8080)
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen()
conn,addr=tcp_socket_server.accept()
data1=conn.recv(10)
data2=conn.recv(10)print('----->',data1.decode('utf-8'))print('----->',data2.decode('utf-8'))
conn.close()
服务端
importsocket
BUFSIZE=1024ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)
s.send('hello'.encode('utf-8'))
s.send('egg'.encode('utf-8'))
客户端
2、接收方的缓存机制
接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生黏包)
importsocket
ip_port=('127.0.0.1',8080)
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
conn,addr=tcp_socket_server.accept()
data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的
print('----->',data1.decode('utf-8'))print('----->',data2.decode('utf-8'))
conn.close()
服务端
importsocket
BUFSIZE=1024ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)
s.send('hello egg'.encode('utf-8'))
客户端
黏包的解决方案
方案一
importsocket
sk=socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr=sk.accept()whileTrue:
cmd= input('>>>')if cmd == 'q':
conn.send(b'q')breakconn.send(cmd.encode('gbk'))
num= conn.recv(1024).decode('utf-8') #2048
conn.send(b'ok')
res= conn.recv(int(num)).decode('gbk')print(res)
conn.close()
sk.close()
服务端
importsocketimportsubprocess
sk=socket.socket()
sk.connect(('127.0.0.1',8080))whileTrue:
cmd= sk.recv(1024).decode('gbk')if cmd == 'q':breakres= subprocess.Popen(cmd,shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
std_out=res.stdout.read()
std_err=res.stderr.read()
sk.send(str(len(std_out)+len(std_err)).encode('utf-8')) #2000
sk.recv(1024) #ok
sk.send(std_out)
sk.send(std_err)
sk.close()#好处:确定了我到底要接收多大的数据
#要在文件中配置一个配置项 : 就是每一次recv的大小 buffer = 4096
#当我们要发送大数据的时候 ,要明确的告诉接收方要发送多大的数据,以便接收方能够准确的接收到所有数据
#多用在文件传输的过程中
#大文件的传输 一定是按照字节读 每一次读固定的字节
#传输的过程中 一边读一边传 接收端 一边收一边写
#不好的地方:多了一次交互#send sendto 在超过一定范围的时候 都会报错#程序的内存管理
客户端
方案二
借用struct模块,该模块可以把一个类型,如数字,转成固定长度的bytes。我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。
发送时:
先发送struct转换好的数据长度4字节;再发送数据。
接收时:
先接受4个字节使用struct转换成数字来获取要接收的数据长度;再按照长度接收数据。
importsocket,struct,jsonimportsubprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它,在bind前加
phone.bind(('127.0.0.1',8080))
phone.listen(5)whileTrue:
conn,addr=phone.accept()whileTrue:
cmd=conn.recv(1024)if not cmd:break
print('cmd: %s' %cmd)
res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
err=res.stderr.read()print(err)iferr:
back_msg=errelse:
back_msg=res.stdout.read()
conn.send(struct.pack('i',len(back_msg))) #先发back_msg的长度
conn.sendall(back_msg) #在发真实的内容
conn.close()
服务端(自定制报头)
importsocket,time,struct
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))whileTrue:
msg=input('>>:').strip()if len(msg) == 0:continue
if msg == 'quit':breaks.send(msg.encode('utf-8'))
l=s.recv(4)
x=struct.unpack('i',l)[0]print(type(x),x)#print(struct.unpack('I',l))
r_s=0
data=b''
while r_s
r_d=s.recv(1024)
data+=r_d
r_s+=len(r_d)#print(data.decode('utf-8'))
print(data.decode('gbk')) #windows默认gbk编码
客户端(自定制报头)
也可以把报头坐车字典,字典里包含将要发送的真实数据的详细信息,然后json序列化,再用struct将序列化后的数据长度打包成4个字节。
发送时:
先发报头长度;再编码报头内容然后发送;最后发真实内容。
接收时:
先接收报头长度,用struct取出来;根据取出的长度收取报头内容,然后解码,反序列化;最后从反序列化的结果中取出待取数据的详细信息,最后去取真实的数据内容。
importsocket,struct,jsonimportsubprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它,在bind前加
phone.bind(('127.0.0.1',8080))
phone.listen()whileTrue:
conn,addr=phone.accept()whileTrue:
cmd=conn.recv(1024)if not cmd:break
print('cmd: %s' %cmd)
res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
err=res.stderr.read()print(err)iferr:
back_msg=errelse:
back_msg=res.stdout.read()
headers={'data_size':len(back_msg)}
head_json=json.dumps(headers)
head_json_bytes=bytes(head_json,encoding='utf-8')
conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度
conn.send(head_json_bytes) #再发报头
conn.sendall(back_msg) #在发真实的内容
conn.close()
服务端
importsocketimportstruct,json
ip_port=('127.0.0.1',8080)
client=socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)whileTrue:
cmd=input('>>:')if not cmd:continueclient.send(bytes(cmd,encoding='utf-8'))
head=client.recv(4)
head_json_len=struct.unpack('i',head)[0]
head_json=json.loads(client.recv(head_json_len).decode('utf-8'))
data_len=head_json['data_size']
recv_size=0
recv_data=b''
while recv_size
recv_data+=client.recv(1024)
recv_size+=len(recv_data)print(recv_data.decode('utf-8'))#print(recv_data.decode('gbk')) #windows默认gbk编码
客户端