基于socketserver实现并发socket套接字编程
基于socketserver实现并发的socket套接字编程
一、基于TCP协议实现并发
-
基于TCP的套接字，关键就是两个循环，一个链接循环，一个通信循环
-
socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）
1.1 server类
1.2 request类
1.3 继承关系
1.4 服务端
"""
TCP服务端:
服务端要做两件事:
- 第1件事就是循环地从半连接池中取出链接请求与其建立双向链接，拿到链接对象
- 第2件事就是拿到链接对象，与其进行通信循环 ===> handle
import socketserver
class MyHandler(socketserver.BaseRequestHandler):
def handle(self): # 必须要写. 里面放的就是我们的通讯循环. 用来存放与客户端进行通信的逻辑代码.
self.request
- 如果是TCP协议，拿到的就是一个客户端的套接字对象conn
self.client_address
- 以('ip', 端口)二元组的形式表示, Ip和端口都是客户端的.
补充: socketserver.ForkingTCPServer Windows系统中不支持.
server = socketserver.ThreadingTcpServer(('IP', 端口), 自定义的类)
- 第1个参数: 指定服务端所绑定的Ip和端口, 这里的Ip和端口目的是提供客户端进行访问.
- 第2个参数: 指定我们自定义的那个类里面定义我们的通信循环.
server.serve_forever()
- 永久提供服务. 这是一个死循环的过程，对应的就是我们的链接循环.
"""
import socketserver
class MyHandler(socketserver.BaseRequestHandler): # 必须继承这个类来使用它的功能
def handle(self): #用于通信循环
print(self.request)
print(self.client_address)
# 通信循环
while True:
try:
data = self.request.recv(1024)
if not data: break
self.request.send(data.upper())
except ConnectionResetError:
break
self.request.close()
if __name__ == '__main__':
#做绑定IP和端口并设置监听的事，"bind_and_activate" 默认等于 "True"
s = socketserver.ThreadingTCPServer(('127.0.0.1', 8888), MyHandler, bind_and_activate=True)
s.serve_forever() # 代表循环连接通讯
# 循环建立连接，每建立一个连接就会启动一个线程（服务员）+调用Myhanlder类产生一个对象，调用该对象下的handle方法，专门与刚刚建立好的连接做通信循环
1.5 客户端
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(("127.0.0.1",8888))
while True:
msg=input("请输入你要操作的指令>>>:").strip()
if not msg: continue
client.send(msg.encode("utf-8"))
date_bytes=client.recv(1024)
print(date_bytes)
client.close()
1.6 客户端一
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(("127.0.0.1",8888))
while True:
msg=input("请输入你要操作的指令>>>:").strip()
if not msg: continue
client.send(msg.encode("utf-8"))
date_bytes=client.recv(1024)
print(date_bytes)
client.close()
二、基于UDP协议实现并发
2.1 服务端
"""
UDP服务端:
import socketserver
class MyRequestHandle(socketserver.BaseRequestHandler):
def handle(self): # 必须要写. 里面放的就是我们的通讯循环. 用来存放与客户端进行通信的逻辑代码.
self.request 拿到的是一个元组
- 第1个参数是客户端发送过来的数据，
- 第2个参数是拿到的客户端的套接字对象
self.client_address
- 以('ip', 端口)二元组的形式表示, Ip和端口都是客户端的.
server = socketserver.ThreadingUDPServer(('IP', 端口), 自定义的类)
- 第1个参数: 指定服务端所绑定的Ip和端口, 这里的Ip和端口目的是提供客户端进行访问.
- 第2个参数: 指定我们自定义的那个类类里面定义我们的通信循环.
server.serve_forever()
- 只负责循环的收，以后包括收发在内后续的数据，都交给线程去处理.
"""
import socketserver
print("Wait...")
class MyRequestHanlder(socketserver.BaseRequestHandler):
def handle(self):
print(self.request)
print(self.client_address)
data_bytes, conn = self.request
print(f'来自{self.client_address}客户端发送过来的消息: {data_bytes.decode("utf-8")}')
conn.sendto(data_bytes.upper(), self.client_address)
s = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), MyRequestHanlder)
s.serve_forever()
2.2 客户端
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 流式协议=》tcp协议
while True:
msg = input('请输入你要操作的指令>>>: ').strip()
client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
data_bytes, server_address = client.recvfrom(1024)
print('data_bytes:', data_bytes)
print('server_address:', server_address)
client.close()
2.3 客户端一
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 流式协议=》tcp协议
while True:
msg = input('请输入你要操作的指令>>>: ').strip()
client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
data_bytes, server_address = client.recvfrom(1024)
print('data_bytes:', data_bytes)
print('server_address:', server_address)
client.close()
2.4 .补充: 解决服务端重启, 操作系统没来的及回收端口占用的系统资源导致端口无法重用
# 加入一条socket配置，重用ip和端口
import socket
from socket import SOL_SOCKET,SO_REUSEADDR
sk = socket.socket()
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
sk.bind(('127.0.0.1',8888)) #把地址绑定到套接字
sk.listen() #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024) #接收客户端信息
print(ret) #打印客户端信息
conn.send(b'hello') #向客户端发送信息
conn.close() #关闭客户端套接字
sk.close() #关闭服务器套接字(可选)