phthon网络编程

软件开发架构

既然谈起网络编程，就得说说软件开发的架构：

c/s架构

C/S结构软件（即客户机/服务器模式）分为客户机和服务器两层，客户机不是毫无运算能力的输入、输出设备，而是具有了一定的数据处理和数据存储能力，通过把应用软件的计算和数据合理地分配在客户机和服务器两端，可以有效地降低网络通信量和服务器运算量。由于服务器连接个数和数据通信量的限制，这种结构的软件适于在用户数目不多的局域网内使用。国内现阶段的大部分ERP（财务）软件产品即属于此类结构。

B/S架构

B/S(浏览器/服务器模式)是随着Internet技术的兴起，对C/S结构的一种改进。在这种结构下，软件应用的业务逻辑完全在应用服务器端实现，用户表现完全在Web服务器实现，客户端只需要浏览器即可进行业务处理，是一种全新的软件系统构造技术。这种结构更成为当今应用软件的首选体系结构。

计算机网络基础

计算机网络基础

网络编程的实质其实也就是应用程序间的通信，那么一个应用程序如何找到另外一个应用程序呢

这个就得提到IP地址与端口了，ip地址精确到具体的一台电脑，而端口精确到具体的程序。

如:一个应用程序的ip地址为：192.168.0.16端口为9662，那这个应用程序就可以通过192.168.0.16:9662这个标识来进行通信

IP地址是指互联网协议地址（英语：Internet Protocol Address，又译为网际协议地址），是IP Address的缩写。IP地址是IP协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。

IP地址是一个32位的二进制数，通常被分割为4个“8位二进制数”（也就是4个字节）。IP地址通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之间的十进制整数。例：点分十进IP地址（100.4.5.6），实际上是32位二进制数（01100100.00000100.00000101.00000110）。

什么是IP协议

"端口"是英文port的意译，可以认为是设备与外界通讯交流的出口。

什么是端口

socket编程

socket概念

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

套接字的发展

1、基于文件类型的套接字家族：AF_UNIX

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

2、基于网络类型的套接字家族：AF_INET

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

tcp协议与udp协议

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

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

基于TCP协议的socket

Server端

import socket #导入socket模块

sk=socket.socket(type=socket.SOCK_STREAM)#创建socket对象，type关键字默认为socket.SOCK_STREAM

sk.bind((‘127.0.0.1‘,8080))#服务端绑定IP与端口

sk.listen()#监听端口

conn,addr=sk.accept()#接受客户端连接

ret=conn.recv(1024)#接受客户端信息

print(ret)#打印客户端信息

conn.send(b‘hello‘)#向客户端发送消息

conn.close()#关闭客户端套接字

sk.close()#关闭服务端套接字

Client端

import socket   #导入socket模块

sk=socket.socket(type=socket.SOCK_STREAM)

sk.connect((‘127.0.0.1‘,8080))#连接服务器

sk.send(b‘hi‘)#向服务端发送消息

ret=sk.recv(1024)#接收来自服务端消息

print(ret)#打印消息

sk.close()#关闭客户端连接

有的可能会报出一条：OSError：address already in use的错误

import socket #导入socket模块

sk=socket.socket(type=socket.SOCK_STREAM)#创建socket对象，type关键字默认为socket.SOCK_STREAM

sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#加上这一句话就搞定了

sk.bind((‘127.0.0.1‘,8080))#服务端绑定IP与端口

sk.listen()#监听端口

conn,addr=sk.accept()#接受客户端连接

ret=conn.recv(1024)#接受客户端信息

print(ret)#打印客户端信息

conn.send(b‘hello‘)#向客户端发送消息

conn.close()#关闭客户端套接字

sk.close()#关闭服务端套接字

基于UDP协议的Socket

Server端

import socket #导入socket模块

sk=socket.socket(type=socket.SOCK_DGRAM)#创建socket对象，type关键字默认为socket.SOCK_STREAM

sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

sk.bind((‘127.0.0.1‘,8080))#服务端绑定IP与端口

msg,addr=sk.recvfrom(1024)#接受客户端信息

print(msg)#打印客户端信息

sk.sendto(b‘hello‘,addr)#向客户端发送消息

sk.close()#关闭服务端套接字

Client端

import socket   #导入socket模块

sk=socket.socket(type=socket.SOCK_DGRAM)#指定type为socket.SOCK_DGRAM

ip_port=(‘127.0.0.1‘,8080)

sk.sendto(b‘hi‘,ip_port)#向服务端发送消息

ret=sk.recv(1024)#接收来自服务端消息

print(ret)#打印消息

sk.close()#关闭客户端连接

自定义时间服务器

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(‘utf-8‘)
    back_msg = strftime(time_fmt)

    tcp_server.sendto(back_msg.encode(‘utf-8‘), addr)

tcp_server.close()

Server端

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(‘utf-8‘),ip_port)

    data=tcp_client.recv(bufsize)

Client端

关于socket（）参数

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

参数说明：

TCP黏包现象

现象：发送方发送两个字符串”hello”+”world”，接收方却一次性接收到了”helloworld”

黏包成因

1、TCP的拆包机制

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

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

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根本不会粘包，但是会丢数据，不可靠。

会发生黏包的两种情况

1、发送方的缓存机制（即当发送方缓冲区满了之后消息才会发送，举例如下）：

import socket   #导入socket模块

sk=socket.socket(type=socket.SOCK_STREAM)#指定type为socket.SOCK_STREAM

ip_port=(‘127.0.0.1‘,8080)

sk.bind(ip_port)

sk.listen()

conn,addr=sk.accept()

ret=conn.recv(12)#接收来自服务端消息

print(ret)#打印消息

ret=conn.recv(12)

print(ret)

sk.close()#关闭客户端连接

Server端

import socket #导入socket模块

sk=socket.socket(type=socket.SOCK_STREAM)#创建socket对象，type关键字默认为socket.SOCK_STREAM

sk.connect((‘127.0.0.1‘,8080))#服务端绑定IP与端口

sk.send(b‘hello‘)
sk.send(b‘world‘)

sk.close()#关闭服务端套接字

Client端

2、接受方的缓存机制（接收方不及时接收缓冲区的包，造成多个包接收，举例如下）：

import socket   #导入socket模块

sk=socket.socket(type=socket.SOCK_STREAM)#指定type为socket.SOCK_STREAM

ip_port=(‘127.0.0.1‘,8080)

sk.bind(ip_port)

sk.listen()

conn,addr=sk.accept()

ret=conn.recv(2)#接收来自服务端消息,一次未接收完整

print(ret)#打印消息

ret=conn.recv(12)

print(ret)

sk.close()#关闭客户端连接

Server端

import socket #导入socket模块

sk=socket.socket(type=socket.SOCK_STREAM)#创建socket对象，type关键字默认为socket.SOCK_STREAM

sk.connect((‘127.0.0.1‘,8080))#服务端绑定IP与端口

sk.send(b‘hello‘)
sk.send(b‘world‘)

sk.close()#关闭服务端套接字

Client端

实际上，TCP黏包主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

TCP黏包问题解决

struct模块

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

使用struct解决黏包

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

发送：先发送struct转换好的数据长度4字节------------>发送数据

接收：先接受4个字节使用struct转换成数字来获取要接收的数据长度---------->接收数据

代码如下：

Server端

import socket,struct #导入socket，struct包

sk=socket.socket(type=socket.SOCK_STREAM)#指定type为socket.SOCK_STREAM

ip_port=(‘127.0.0.1‘,8080)

sk.bind(ip_port)

sk.listen()

conn,addr=sk.accept()

#接收消息
msg_len=conn.recv(4)##接收来自客户端消息长度信息

len=struct.unpack(‘i‘,msg_len)[0]#解包，提取长度

msg=conn.recv(len)
print(msg.decode(‘utf-8‘))

#再一次接收消息
msg_len=conn.recv(4)#接收来自客户端消息长度信息

len=struct.unpack(‘i‘,msg_len)[0]#解包，提取长度

msg=conn.recv(len)
print(msg.decode(‘utf-8‘))

sk.close()#关闭客户端连接

Client端

import socket,struct #导入socket，struct包

sk=socket.socket(type=socket.SOCK_STREAM)#创建socket对象，type关键字默认为socket.SOCK_STREAM

sk.connect((‘127.0.0.1‘,8080))#服务端绑定IP与端口
msg1=‘hello‘
msg2=‘world‘

sk.send(struct.pack(‘i‘,len(msg1)))#首先发送要发送信息长度
sk.send(msg1.encode(‘utf-8‘))#发送信息

sk.send(struct.pack(‘i‘,len(msg2)))#首先发送要发送信息长度
sk.send(msg2.encode(‘utf-8‘))#发送信息

sk.close()#关闭服务端套接字

如果数据的长度未知，这种解决黏包的方式就会显现出来了

原文地址：https://www.cnblogs.com/qflyue/p/8378821.html