网络编程

目录

• 网络编程
  • 软件开发架构:
    • c/s架构：
    • b/s架构：
    • OSI七层协议
    • 小结：
  • socket概念
    • 理解socket
    • tcp协议和udp协议
    • 套接字socket初使用
  • 黏包
  • struct模块
  • SocketServer模块介绍

网络编程

软件开发架构:

我们了解的设计到两个程序之间通讯的应用大致可以分为两类：

应用类：QQ，微信，优酷等这一类都属于安装在桌面的应用。

web：百度，知乎，博客园等使用浏览器访问就可以直接使用的应用。

这些应用的本质其实都是两个程序之间的通讯，对应了两个软件开发的架构：

c/s架构：

c（Client）：客户端

s（Server）：服务端

b/s架构：

b（Browser）：浏览器

s（Server）：服务端

应用领域：淘宝，京东

服务端：24小时不间断提供服务。

客户端：什么时候想体验服务就去服务端。

OSI七层协议

• 物理链接层：

基于电信号传输0和1的二进制。

• 数据链路层：

规定电信号的分组方式，任何一台接入互联网的计算机都必须有一块网卡。每一块网卡上面都刻有世界上独一无二的编号。（12位16进制数，前6位是厂商编号，后6位是流水线编号。）

以太协议：物理链接层和数据链路层合称为‘以太协议’。以太协议不能跨局域网通信。

• 网络层：

IP协议，规定了只要是接入互联网的计算机都必须有一个IP地址。

IP地址特点：点分十进制

IP地址最小：0.0.0.0

IP地址最大：255.255.255.255

IP地址目前有两个版本：IPV4，IPV6（由于IPV4已经不够表示目前存在的计算机了 所以推出了IPV6版本）

• 传输层：

TCP\UDP都是基于端口工作的协议。

端口（port）：

计算机与计算机之间其实是计算机的应用程序与应用程序之间的通信。用来唯一表示一台计算机上的某个应用。

端口号的范围：0~65535

建议使用：8000之后的端口

MySQL默认端口：3306

Redis默认端口：6379

django默认端口：8000

flask默认端口：5000

注意：0~1024都是操作系统默认使用的端口。端口号是动态分配的：第一次启动QQ分配到的是8989，关闭后再次启动端口号可能就变了。

• 应用层：

HIIP协议，FTP协议

TPC协议：流式协议，可靠协议。基于TCP协议通信，必须先建立双向通道。

三次握手建立连接

四次挥手断连接

小结：

IP地址：用来唯一标识接入互联网的一台计算机。

port端口：用来唯一标识一台计算机上的某个应用程序。

IP + port：唯一标识接入互联网一台计算机上的某个应用程序。

socket概念

socket层

理解socket

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

tcp协议和udp协议

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

套接字socket初使用

• 基于TCP协议的socket

​ tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

# server端
import socket
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()        			 #关闭服务器套接字(可选)

# client端
import socket
sk = socket.socket()           # 创建客户套接字
sk.connect(('127.0.0.1',8898)) # 尝试连接服务器
sk.send(b'hello!')
ret = sk.recv(1024)            # 对话(发送/接收)
print(ret)
sk.close()            		   # 关闭客户套接字

• 基于UDP协议的socket

​ udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接

# server端
import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字
udp_sk.bind(('127.0.0.1',9000))        			 #绑定服务器套接字
msg,addr = udp_sk.recvfrom(1024)
print(msg)
udp_sk.sendto(b'hi',addr)                		 # 对话(接收与发送)
udp_sk.close()                         			 # 关闭服务器套接字

# client端
import socket
ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)

黏包

• 基于tcp协议实现的黏包

# server端

#_*_coding:utf-8_*_
from socket import *
import subprocess

ip_port=('127.0.0.1',8888)
BUFSIZE=1024

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

while True:
    conn,addr=tcp_socket_server.accept()
    print('客户端',addr)

    while True:
        cmd=conn.recv(BUFSIZE)
        if len(cmd) == 0:break

        res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                         stdout=subprocess.PIPE,
                         stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE)

        stderr=res.stderr.read()
        stdout=res.stdout.read()
        conn.send(stderr)
        conn.send(stdout)

# client端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8888)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    act_res=s.recv(BUFSIZE)

    print(act_res.decode('utf-8'),end='')

• 黏包的成因

'''	
    TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。
	收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
	这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
	可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
'''

• UDP不会发生黏包

'''
	UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。 
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。 
	对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
	不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。
'''

• 黏包解决方案

  解决方案一：

  问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

存在问题：
	程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗。

​ 解决方案进阶：

​ 我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。

struct模块

​ 该模块可以把一个类型，如数字，转成固定长度的bytes

import struct
obj = struct.pack('i',123456)
print(len(obj))  
# 4
obj = struct.pack('i',898898789)
print(len(obj))  
# 4
# 无论数字多大，打包后长度恒为4

• 使用 struct 解决黏包

  借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

发送时	接收时
先发送struct转换好的数据长度4字节	先接受4个字节使用struct转换成数字来获取要接收的数据长度
再发送数据	再按照长度接收数据

# server端
				obj=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            stdout=obj.stdout.read()
            stderr=obj.stderr.read()
            # 1. 先制作固定长度的报头
            header=struct.pack('i',len(stdout) + len(stderr))
            # 2. 再发送报头
            conn.send(header)
            # 3. 最后发送真实的数据
            conn.send(stdout)
            conn.send(stderr)
            
# client端
	#1. 先收报头,从报头里解出数据的长度
    header=client.recv(4)
    total_size=struct.unpack('i',header)[0]
    #2. 接收真正的数据
    cmd_res=b''
    recv_size=0
    while recv_size < total_size:
        data=client.recv(1024)
        recv_size+=len(data)
        cmd_res+=data
    print(cmd_res.decode('gbk'))

​ 我们还可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

发送时	接收时
先发报头长度	先收报头长度，用struct取出来
再编码报头内容然后发送	根据取出的长度收取报头内容，然后解码，反序列化
最后发真实内容	从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

# server端
		 # 1. 先制作报头
     header_dic = {
         'filename': 'a.txt',
         'md5': 'asdfasdf123123x1',
         'total_size': len(stdout) + len(stderr)
     }
     header_json = json.dumps(header_dic)
     header_bytes = header_json.encode('utf-8')
     # 2. 先发送4个bytes(包含报头的长度)
     conn.send(struct.pack('i', len(header_bytes)))
     # 3  再发送报头
     conn.send(header_bytes)
     # 4. 最后发送真实的数据
     conn.send(stdout)
     conn.send(stderr)
     
# client端
		#1. 先收4bytes,解出报头的长度
    header_size=struct.unpack('i',client.recv(4))[0]
    #2. 再接收报头,拿到header_dic
    header_bytes=client.recv(header_size)
    header_json=header_bytes.decode('utf-8')
    header_dic=json.loads(header_json)
    print(header_dic)
    total_size=header_dic['total_size']
    #3. 接收真正的数据
    cmd_res=b''
    recv_size=0
    while recv_size < total_size:
        data=client.recv(1024)
        recv_size+=len(data)
        cmd_res+=data
    print(cmd_res.decode('gbk'))

​ 总结：

​ 先发字典报头，再发字典数据，最后发真实数据

SocketServer模块介绍

# TCP socketserver使用
import socketserver

class MyTcpServer(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                data = self.request.recv(1024)  # 对于tcp，self.request相当于conn对象
                if len(data) == 0:break
                print(data)
                self.request.send(data.upper())
            except ConnectionResetError:
                break
                
if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8081),MyTcpServer)
    server.serve_forever()

# UDP socketserver使用
import socketserver

class MyUdpServer(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            data, sock = self.request
            print(data)
            sock.sendto(data.upper(), self.client_address)

if __name__ == '__main__':
    server = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), MyUdpServer)
    server.serve_forever()