标签：个数   文件类型   英语   body   tst   files   架构   接收   缓存机制   

网络编程

软件开发的架构

• 应用类：QQ 微信 钉钉 FTP 网盘等等，这一类属于需要安装的应用类
• WEB类：比如百度，知乎，微博等使用浏览器访问就可以直接使用的应用

C/S架构

C/S 既（Client与Server），中文意思：客户端与服务器端架构，这种架构也是从用户层面（物理层面）来划分的

这里的客户端一般泛指客户端应用程序exe，程序需要先安装后，才能运行在用户的的计算机上，对用户的电脑操作系统环境依赖较大

B/S架构

B/S既：Browser与Server的意思，中文意思：浏览器端与服务器端架构，这种架构是从用户层面划分的。

Browser浏览器，其实也是一种client客户端，只是这个客户端不需要大家安装什么应用程序，只需要用户在浏览器上通过HTTP请求服务器端相关的资源(网页资源)，客户端Browser就能镜像增删改查

网络基础

网络基础

1.一个程序如何在网络上找到另一个程序

首先程序必须要启动，其次，必须有这台机器的地址，而在互联网中，一台计算机的地址，就是使用一串数字表示，比如 78.5.6.29

因此ip地址精确到具体的一台电脑，而端口精确到具体的程序。

2.理解Socket

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

3.套接字(Socket)的发展史

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

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

套接字家族的名字：AF_UNIX

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

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

套接字家族的名字：AF_INET

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

4.TCP协议和UDP协议

• TCP：（Transmisson Control Protocol）可靠的，面向连接的协议（打电话）传输效率低全双工通信（发送缓存&&接受缓存），面向字节流。使用TCP的应用：WEB浏览器；电子邮件；文件传输程序
• UDP：（User Data Protocol）不可靠的，无连接的服务，传输效率高（发送前延时小），一对一，一对多，多对一，面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统；视频流；IP语音(VoIP)。

套接字（Socket）初使用：

基于TCP协议的Socket

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

Server端

import socket

sk = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)   # 买手机
# family = socket.AF_INET 当前基于网络通信的
# type = socket.SOCK_STREAM 默认是tcp协议
sk.bind(('127.0.0.1',9000))    # 装上电话卡
sk.listen()                     # 开机
while True:
    conn,addr = sk.accept() # 等电话,等待客户端来链接我
        # conn 就是server和客户端建立起来的一个连接
    while  True:
        msg_send = input('>>>')
        conn.send(msg_send.encode('utf-8')) # 向客户端发送信息
        if msg_send.upper() == 'Q': break # 判断输入的为q 退出
        msg = conn.recv(1024).decode('utf-8')  #接收客户端信息
        if msg.upper() == 'Q': break  
        print(msg)
    conn.close()         # 挂电话
sk.close()           # 关手机
# 无论在server 还是 client 只要输入q 就两边断开连接 - 挂电话

Client端

import socket

sk = socket.socket()  # 实例化一个socket对象

sk.connect(('127.0.0.1',9000))
while True:
    msg = sk.recv(1024).decode('utf-8')    # 字节 阻塞直到有数据发送过来
    if msg.upper() == 'Q': break
    print(msg) # 字节转字符串 decode
    msg_send = input('>>>')    # input写入的是字符串
    sk.send(msg_send.encode('utf-8')) # 发送的是字节,字符串转字节 encode
    if msg_send.upper() == 'Q': break
sk.close()

基于UDP协议的Socket

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

Server端

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字
sk.bind(('127.0.0.1',8001))   #绑定服务器套接字
while True:
    msg,addr = sk.recvfrom(1024)
    print(msg.decode('utf-8'))
    send_msg = input('>>>')
    sk.sendto(send_msg.encode('utf-8'),addr)  # 对话(接收与发送)
sk.close()   # 关闭服务器套接字

Client端

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)
while True:
    send_msg = input('>>>')
    sk.sendto(send_msg.encode('utf-8'),('127.0.0.1',8001))
    msg,addr = sk.recvfrom(1024)
    print(msg.decode('utf-8'))
sk.close()

例子

QQ聊天

• Server端

import socket
ip_port = ('127.0.0.1',9001)
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]的一条消息:\033[1;44m%s\033[0m'%(addr[0],addr[1],qq_msg.decode('utf8')))
    back_msg = input('回复消息：').strip()

    udp_server_sock.sendto(back_msg.encode('utf8'),addr)

• Client端

import socket

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

qq_name_dic = {
    '金老爸':('127.0.0.1',9001),
    'Alex':('127.0.0.1',9001)
}

while True:
    qq_name = input('请选择聊天对象：').strip()
    while True:
        msg = input('请输入消息,回车发送,输入q结束和他的聊天: ').strip()
        if msg == 'q':break
        if not msg or not qq_name or not qq_name in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf8'),qq_name_dic[qq_name])

        back_msg,addr = udp_client_socket.recvfrom(BUFSIZE)
        print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m'%(addr[0],addr[1],back_msg.decode('utf8')))

    udp_client_socket.close()

时间服务器

• Server端

from socket import *
from time import strftime

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

tcp_server = socket(AF_INET,SOCK_DGRAM)
tcp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_server.bind(ip_port)


while True:
    msg,addr = tcp_server.recvfrom(BUFSIZE)
    print('===>',msg)

if not msg:
    time_fmt = '%Y-%m-%d %x'
else:
    time_fmt = msg.decode('utf8')
    back_msg = strftime(time_fmt)
    tcp_server.sendto(back_msg.encode('utf8'),addr)
    
tcp_server.close()

• Client端

    from socket import *
    
    ip_port = ('127.0.0.1',9000)
    BUFSIZE = 1024
    
    tcp_client = socket(AF_INET,SOCK_DGRAM)
    
    while True:
        msg = input('请输入时间格式(例%Y %m %d)>>: ').strip()
        tcp_client.sendto(msg.encode('utf8'),ip_port)
    
        data = tcp_client.recv(BUFSIZE)
        print(data.decode('utf8'))

飞信通信

from socket import *

updsocket = socket(type = SOCK_DGRAM)
addr = ("192.168.0.168",2425)
msg = input('>>>')
updsocket.sendto(("1:111:eva:eva:32:%s"%msg).encode('gbk'),addr)

飞秋运行时，会监听2425端口，所以我们首先要和本地建立UDP连接
1:111:eva:eva:32:要发送的内容
1表示版本号，111标识包号，eva表示用户名，第二个eva表示主机名，32表示发送消息，后面的表示要发送的消息内容。

socket参数的详解

socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)

创建socket对象的参数说明：

粘包

我们现在来看一中现象

# server端
import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 9000))
sk.listen()
conn,addr = sk.accept()
for i in range(3):
    conn.send(b'sbzz')
conn.close()
sk.close()

# 客户端
import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 9000))
for i in range(3):
    print(sk.recv(1024))

sk.close()

上述代码执行后的结果

本来正常接受的应该是三次sbzz,但是到第二次的时候，第二次和第三次的sbzz粘在一起，这种现象就叫粘包

注意：只有TCP有粘包现象，UDP永远不会粘包

流式传输：特指 TCP协议，像流水一样，无边界

粘包原因

TCP协议中的数据传递

tcp协议的拆包机制

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。

面向流的通信特点和Nagle算法

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

基于tcp协议特点的黏包现象成因

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据。
也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。
而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。
怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

socket数据传输过程中的用户态与内核态说明

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

UDP不会发生黏包

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

补充说明:

用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送）

用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。

会发生黏包的两种情况

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

情况一 发送方的缓存机制

Server端

#_*_coding:utf-8_*_
from socket import *
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(10)
data2=conn.recv(10)

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

Client端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_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'))

情况二 接收方的缓存机制

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

Server端

#_*_coding:utf-8_*_
from socket import *
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()

Client端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_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'))

总结

黏包现象只发生在tcp协议中：

1. 从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
2. 实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

黏包的解决方案

解决方案一

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

Server端

import socket
import struct

def my_send(conn,msg):
    msgb = msg.encode('utf-8')
    len_msg = len(msgb)
    pack_len = struct.pack('i', len_msg)
    conn.send(pack_len)
    conn.send(msgb)

sk = socket.socket()
sk.bind(('127.0.0.1',9002))
sk.listen()

conn,addr = sk.accept()
msg1 = '你好'
msg2 = '吃了么'
my_send(conn,msg1)
my_send(conn,msg2)
conn.close()
sk.close()

Client端

import time
import socket
import struct
sk = socket.socket()

def my_recv(sk):
    pack_len = sk.recv(4)
    len_msg = struct.unpack('i', pack_len)[0]
    msg = sk.recv(len_msg).decode('utf-8')
    return msg

sk.connect(('127.0.0.1',9002))
for i in range(100000):i*2
msg = my_recv(sk)
print(msg)
msg = my_recv(sk)
print(msg)
sk.close()

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

解决方案进阶

刚刚的方法，问题在于我们我们在发送

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

struct模块

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

>>> struct.pack('i',1111111111111)

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

更详细的用法

#_*_coding:utf-8_*_
#http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html
__author__ = 'Linhaifeng'
import struct
import binascii
import ctypes

values1 = (1, 'abc'.encode('utf-8'), 2.7)
values2 = ('defg'.encode('utf-8'),101)
s1 = struct.Struct('I3sf')
s2 = struct.Struct('4sI')

print(s1.size,s2.size)
prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
print('Before : ',binascii.hexlify(prebuffer))
# t=binascii.hexlify('asdfaf'.encode('utf-8'))
# print(t)


s1.pack_into(prebuffer,0,*values1)
s2.pack_into(prebuffer,s1.size,*values2)

print('After pack',binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer,0))
print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct('ii')
s3.pack_into(prebuffer,0,123,123)
print('After pack',binascii.hexlify(prebuffer))
print(s3.unpack_from(prebuffer,0))

使用struct解决黏包

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

文件传输例子

服务端

# 接收文件
import json
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',9001))
sk.listen()

conn,addr = sk.accept()
file_dic = conn.recv(1024).decode('utf-8')
dic = json.loads(file_dic)

with open(dic['filename'],mode='wb') as f:
    while dic['filesize']>0:
        file_content = conn.recv(1024)
        dic['filesize'] -= len(file_content)
        f.write(file_content)
conn.close()
sk.close()

客户端

import os
import json
import socket

sk = socket.socket()
sk.connect(('127.0.0.1',9001))
# 输入需要发送的文件,获取并发送文件大小
file_path = r'D:\ev录屏保存的视频\20190719_150518.mp4'
file_name = os.path.basename(file_path)
file_size = os.path.getsize(file_path)
dic = {'filename':file_name,'filesize':file_size}
str_dic = json.dumps(dic)
dic_b = str_dic.encode('utf-8')
sk.send(dic_b)
with open(file_path,mode = 'rb') as f:
    content = f.read()
    sk.send(content)
sk.close()

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

Python 网络编程

标签：个数   文件类型   英语   body   tst   files   架构   接收   缓存机制   

原文地址：https://www.cnblogs.com/Hybb/p/11493341.html