一、软件开发的架构
1、C/S架构
C/S（Client/Server ），是客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。
这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。
例如：qq、微信、网盘、优酷这一类是属于需要安装的桌面应用。
2、B/S架构
B/S（Browser/Server）,是浏览器端与服务器端架构，这种架构是从用户层面来划分的。
Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。
例如：百度、知乎、博客园等使用浏览器访问就可以直接使用的应用。
二、套接字（socket）
1、套接字（socket）概念
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
其实站在你的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。
也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。
所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。
2、套接字（socket）的发展史
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
1）基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信。
2）基于网络类型的套接字家族
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
三、套接字（socket）初使用
1、基于TCP协议的socket
tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端。
server端：
import socket sk = socket.socket() sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 表示这个地址允许被重用 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!') # 发送数据必须是bytes类型 ret = sk.recv(1024) # 对话(发送/接收) 11024代表接收数据的长度 print(ret) sk.close() # 关闭客户套接字
例：使用TCP协议实现聊天功能
# server端 import socket sk = socket.socket() sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sk.bind(('127.0.0.1', 9000)) sk.listen() while True: conn, addr = sk.accept() # 阻塞 三次握手完毕 while True: msg = input('>>>') conn.send(msg.encode('utf-8')) if msg == 'q': break ret = conn.recv(1024).decode('utf-8') if ret == 'q': break print(ret) conn.close() sk.close() # clent端 import socket sk = socket.socket() sk.connect(('127.0.0.1', 9000)) while True: ret = sk.recv(1024).decode('utf-8') if ret == 'q': break print(ret) msg = input('>>>') sk.send(msg.encode('utf-8')) if msg == 'q': break sk.close()
【注意】
出现以下报错信息，原因服务端未断开连接就进行重连，可以添加sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)解决，表示这个地址允许被重用。
2、基于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)
例：使用UDP协议实现QQ聊天
# server端 # _*_coding:utf-8_*_ 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%s 33[0m' % (addr[0], addr[1], qq_msg.decode('utf-8'))) back_msg = input('回复消息: ').strip() udp_server_sock.sendto(back_msg.encode('utf-8'), addr) # 客户端 # _*_coding:utf-8_*_ 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), 'egg': ('127.0.0.1', 8081), 'yuan': ('127.0.0.1', 8081), } while True: qq_name = input('请选择聊天对象: ').strip() while True: msg = input('请输入消息,回车发送,输入q结束和他的聊天: ').strip() if msg == 'q': 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%s 33[0m' % (addr[0], addr[1], back_msg.decode('utf-8'))) udp_client_socket.close()
例：使用UDP协议实现时间服务器
# server端 # _*_coding:utf-8_*_ 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() # 客户端 # _*_coding:utf-8_*_ 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 %X)>>: ').strip() tcp_client.sendto(msg.encode('utf-8'), ip_port) data = tcp_client.recv(bufsize) print(data)
3、socket参数详解
三、黏包
1、黏包现象
注意：只有TCP有粘包现象，UDP永远不会粘包
基于tcp协议实现的黏包：
# server端 # _*_coding:utf-8_*_ import socket sk = socket.socket() sk.bind(('127.0.0.1', 8080)) sk.listen() conn, addr = sk.accept() data1 = conn.recv(10) data2 = conn.recv(10) print('--->', data1.decode('utf-8')) print('--->', data2.decode('utf-8')) conn.close() sk.close() # 客户端 # _*_coding:utf-8_*_ import socket sk = socket.socket() sk.connect(('127.0.0.1', 8080)) sk.send('hello'.encode('utf-8')) sk.send('world'.encode('utf-8')) sk.close()
2、黏包成因
1）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协议特点的黏包现象成因 ：
socket数据传输过程中的用户态与内核态说明
发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据。
也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。
而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。
怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束。
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
2）UDP不会发生黏包
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。
不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。
udp和tcp一次发送数据长度的限制：
用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送）
用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。
3）TCP会发生黏包的两种情况
情况一 发送方的缓存机制
发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
情况二 接收方的缓存机制
接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
4）总结
黏包现象只发生在tcp协议中：
1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
2、黏包的解决方案
1）解决方案一
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。
存在的问题：
程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗。
2）解决方案进阶
可以使用struct模块，可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。
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)
#关于struct的详细用法 #_*_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))
例：
# server端 # _*_coding:utf-8_*_ import socket import struct sk = socket.socket() sk.bind(('127.0.0.1', 8080)) sk.listen() conn, addr = sk.accept() inp = input('>>>').encode('utf-8') inp_len = len(inp) bytes_msg = struct.pack('i', inp_len) # i 代表int conn.send(bytes_msg) conn.send(inp) conn.send(b'alex sb') conn.close() sk.close() # 客户端 # _*_coding:utf-8_*_ import socket import struct sk = socket.socket() sk.connect(('127.0.0.1', 8080)) num = sk.recv(4) num = struct.unpack('i', num)[0] print(sk.recv(num)) print(sk.recv(10)) sk.close()