网络编程之socket套接字

目录

• socket套接字简介
• 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()