socket套接字
socket套接字简介
由于操作OSI七层是所有C/S架构的程序都需要经历的过程，而操作OSI七层相当的复杂，所以这时候就出现了一门技术——socket套接字。
socket套接字可以向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯，而python语言提供了socket模块来使用这门技术。
socket模块
C/S架构的软件无论是在编写还是运行，都应该先考虑服务端，所以我们先编写服务端的代码。
服务端(Server)
import socket
# 创建套接字对象，相当于买手机
server = socket.socket()
# 将ip地址和端口号绑定到套接字，相当于插电话卡
server.bind(('127.0.0.1', 8080))
# 监听，后面详细讲解，相当于开机
server.listen(5)
# 等待客户端的消息，获取客户端的对象和地址，相当于等待并接听电话
sock, addr = server.accept() # 没有消息来就原地等待(程序阻塞)
# 获取客户端的消息
data = sock.recv(1024)
# 获取的消息是bytes类型，需要解码
print(data.decode('utf8'))
# 给客户端发消息，需要转成bytes类型
sock.send('来自服务端的消息'.encode('utf8'))
# 断开与客户端的连接，相当于挂电话
sock.close()
# 关闭服务端，相当于电话关机
server.close()
客户端(Client)
import socket
# 产生一个socket对象
client = socket.socket()
# 根据服务端的地址和端口连接
client.connect(('127.0.0.1', 8080))
# 给服务端发消息
client.send('来自客户端的消息'.encode('utf8'))
# 接收来自服务端的消息
data = client.recv(1024)
# 解码并输出
print(data.decode('utf8'))
# 关闭客户端
client.close()
服务端与客户端首次交互，一边是recv那么另一边必须是send，两边不能相同，否则两边都在等待对方发来的消息，程序就卡住了。
通信循环
上面的代码已启动就结束了，无法让服务端一直运行，为了能让服务端和客户端一直可以互相发送消息，我们可以用循环的方式实现服务端和客户端一直可以交互，可以互相发消息。
服务端(Server)
import socket
# 服务端启动
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
# 建立与客户端连接
sock, addr = server.accept()
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
msg = input('需要发送给客户端的消息：').strip()
sock.send(msg.encode('utf8'))
# 断开连接
sock.close()
server.close()
客户端(Client)
import socket
# 客户端建立连接
client = socket.socket()
client.connect(('127.0.0.1', 8080))
while True:
# 与服务端交互
msg = input('需要发送给服务端的消息：').strip()
client.send(msg.encode('utf8'))
data = client.recv(1024)
print(data.decode('utf8'))
# 断开连接
client.close()
代码优化
在实现了通信循环后，还是有很多小问题，比如当服务端或者客户端发送的消息为空时，程序会卡住，无法获取空的数据。
解决方法：加一个判断条件判断输入的数据是否为空。
# 客户端
msg = input('需要发送给服务端的消息：').strip()
if len(msg) == 0:
print('不能发送空消息')
continue
# 服务端
msg = input('需要发送给客户端的消息：').strip()
if len(msg) == 0:
msg = '服务端给你发送了空消息'
有些时候重启服务端可能会报错：Address already in use
解决方法：在服务端的bind方法前加一串代码
from socket import SOL_SOCKET,SO_REUSEADDR
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) # 在bind前加
连接循环
在windows系统中，如果客户端异常退出，那么服务端会引起报错，所以我们要让代码可以在客户端异常退出后可以重新回到accept等待新的客户端，这里可以使用异常处理的方法。
服务端(Server)
import socket
# 服务端启动
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
# 建立与客户端连接
sock, addr = server.accept()
while True:
try:
data = sock.recv(1024)
print(data.decode('utf8'))
msg = input('需要发送给客户端的消息：').strip()
if len(msg) == 0:
msg = '服务端给你发送了空消息'
sock.send(msg.encode('utf8'))
except ConnectionResetError:
# 重新建立与客户端连接
sock, addr = server.accept()
# 断开连接
sock.close()
server.close()
客户端(Client)
import socket
# 客户端建立连接
client = socket.socket()
client.connect(('127.0.0.1', 8080))
while True:
# 与服务端交互
msg = input('需要发送给服务端的消息：').strip()
if len(msg) == 0:
print('不能发送空消息')
continue
client.send(msg.encode('utf8'))
data = client.recv(1024)
print(data.decode('utf8'))
# 断开连接
client.close()
PS：目前我们的服务端只能实现一个服务端对应一个客户端，不能做到一个服务端对应多个客户端，这个功能需要学了并发编程才可以实现。
半连接池
在创建服务端的时候，我们需要建立半连接池，server.listen()这个方法就是建立半连接池的。
半连接池的作用就是设置的最大等待的客户端的数量，可以有效节省资源，提高效率。listen(5)就是可以让最多有5个客户端进行等待。
与当前客户端断开连接后，就会去等待区与下一个客户端连接。
黏包问题
我们先来看一段代码：
服务端(Server)
import socket
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
sock, addr = server.accept()
data1 = sock.recv(1024)
print(data1.decode('utf8'))
data2 = sock.recv(1024)
print(data2.decode('utf8'))
data3 = sock.recv(1024)
print(data3.decode('utf8'))
sock.close()
server.close()
客户端(Client)
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8080))
client.send(b'one')
client.send(b'two')
client.send(b'three')
client.close()
首先启动服务端，然后启动客户端，按照之前的理解，服务端应该是输出三段数据，但是并不是，而是把三段数据合在第一个send一起发送了，后面两个send发送的是空字符。
服务端输出内容：
b'onetwothree'
b''
b''
这个就是黏包问题！因为TCP协议的特点：会将数据量比较小并且时间间隔比较短的数据整合到一起发送，并且还会受制于recv括号内的数字大小。
我们可以更改服务端的recv括号内的大小来防止黏包问题：
data1 = sock.recv(3)
data2 = sock.recv(3)
data3 = sock.recv(5)
但这只能在我们知道发送的数据大小才能这样使用，如果我们不知道即将要接收的数据到底多大呢？
解决黏包问题
解决黏包问题，我们可以使用python中的struct模块，这个模块可以把长度任意的数据打包成固定长度的数据。
struct模块操作：
import struct
data1 = 'hello world!'
print(len(data1)) # 输出：12
# 数据打包
res1 = struct.pack('i', len(data1)) # 第一个参数是格式 写i就可以了
print(len(res1)) # 输出：4
# 数据解包
ret1 = struct.unpack('i', res1)
# 返回的是元组
print(ret1) # 输出：(12,)
data2 = 'hello world world world '
print(len(data2)) # 24
# 数据打包
res2 = struct.pack('i', len(data2))
print(len(res2)) # 4
# 数据解包
ret2 = struct.unpack('i', res2)
# 返回的是元组
print(ret2) # (24,)
结合C/S架构：
服务端(Server)
import socket
import struct
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
sock, addr = server.accept()
# 先获取打包的数据
msg1 = sock.recv(4)
# 解包获取真实数据长度
data1_len = struct.unpack('i', msg1)[0]
# 在获取真实数据
data1 = sock.recv(data1_len)
print(data1)
# 获取第二段数据
msg2 = sock.recv(4)
data2_len = struct.unpack('i', msg2)[0]
data2 = sock.recv(data2_len)
print(data2)
# 获取第三段数据
msg3 = sock.recv(4)
data3_len = struct.unpack('i', msg3)[0]
data3 = sock.recv(data3_len)
print(data3)
sock.close()
server.close()
客户端(Client)
import socket
import struct
client = socket.socket()
client.connect(('127.0.0.1', 8080))
data1 = b'one'
data2 = b'two'
data3 = b'three'
# 数据打包
msg1 = struct.pack('i', len(data1))
# 先发送打包好的数据，服务端解包获取长度
client.send(msg1)
# 在发送真实的数据
client.send(data1)
msg2 = struct.pack('i', len(data2))
client.send(msg2)
client.send(data2)
msg3 = struct.pack('i', len(data3))
client.send(msg3)
client.send(data3)
client.close()
黏包问题特殊情况(文件过大)
recv括号内的数字尽量不要写太大，1024、2048、4096足够了，如果要发送的数据大小过大，我们可以使用字典的方式。
1.先接收固定长度的字典包
2.解析出字典的真实长度
3.接收字典数据
4.从字典数据中解析出各种信息
5.接收真实的数据
比如客户端给服务端传输文件的信息:
服务端(Server)
import socket
import struct
import json
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
sock, addr = server.accept()
# 获取打包的数据
data_json_pack = sock.recv(4)
# 解包
data_json_len = struct.unpack('i', data_json_pack)[0]
# 获取json数据
data_json = sock.recv(data_json_len)
# json转字典
data_dict = json.loads(data_json)
print(data_dict)
# 接收文件
size = 0
while size < data_dict['file_size']:
data = sock.recv(1024)
print(data.decode('utf8'))
size += len(data)
sock.close()
server.close()
客户端(Client)
import socket
import os
import struct
import json
client = socket.socket()
client.connect(('127.0.0.1', 8080))
data_dict = {
'file_name': r'main.py', # 文件名
'file_size': os.path.getsize(r'main.py') # 文件大小
}
# 字典转json
data_json = json.dumps(data_dict)
# 打包json,并发送
data_json_pack = struct.pack('i', len(data_json))
client.send(data_json_pack)
# 发送json数据
client.send(data_json.encode('utf8'))
# 发送文件
with open(data_dict['file_name'], 'rb') as f:
for line in f:
client.send(line)
client.close()
socket套接字之UDP协议
在我们创建socket对象的时候，默认是使用TCP协议的，如果想要使用UDP协议，需要给个参数。
server = socket.socket(type=socket.SOCK_DGRAM)
如果使用了UDP协议，那么它的一些方法也会发生变化。
举例
服务端(Server)
import socket
server = socket.socket(type=socket.SOCK_DGRAM)
# 绑定ip地址和端口号不变
server.bind(('127.0.0.1', 8080))
# 接收消息的方法改变了，不与客户端进行连接就直接获取消息
msg, addr = server.recvfrom(1024)
print('来自客户端:', msg.decode('utf8'))
print('客户端地址:', addr)
# 发送消息的方法改变了，根据客户端地址发送
server.sendto('来自服务端的消息'.encode('utf8'), addr)
客户端(Client)
import socket
client = socket.socket(type=socket.SOCK_DGRAM)
# 可以先写个变量存储服务端地址，后续用起来方便
server_addr = ('127.0.0.1', 8080)
# 发送消息的方法改变了，根据服务端地址发送
client.sendto('来自客户端的消息'.encode('utf8'), server_addr)
# 接收消息的方法改变了，可以获取服务端的消息和地址
msg, addr = client.recvfrom(1024)
print('来自服务端:', msg.decode('utf8'))
print('服务端地址:', addr)
由于使用的是UDP协议，不会建立双向通道，所以可以启动多个客户端给服务端发送消息，服务端都会接收到，谁先发送消息服务端就会优先收到，并且使用UDP协议是不会发生黏包问题的。
