开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 网络协议 -> python基础?-网络编程socket进阶 -> 正文阅读

[网络协议]python基础?-网络编程socket进阶

如何解决客户端与服务端多次收发消息

服务端


import socket

# AF_INET 互联网协议
# SOCK_STREAM TCP流式协议,
import time

serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(serverSocket)
# 绑定ip和端口
serverSocket.bind(('127.0.0.1', 8080))

#
# 监听端口。指定限制
serverSocket.listen(5)

print('start')
# io 操作 沿着网络传输数据 读写文件
# 建立三次握手
conn, client_addr = serverSocket.accept()
print(conn)
print(client_addr)

while True:
    try:
        #  收/发消息
        # 1024接收的最大字节数bytes
        data = conn.recv(1024)
        # linux环境下。客户端close后，服务端会一直接受 b''。而不是抛异常。所以需要判断下
        # https://blog.csdn.net/bbg221/article/details/78464051
        if data == b'':
            break
        print('收到客户端的数据', data)
        # 变大写发送回去
        conn.send(data.upper())
    except ConnectionResetError as e:
        print('------')
        # 客户端断开连接
        break

# 关闭与客户端建立的连接
conn.close()
# 关闭服务器
serverSocket.close()

客户端

import socket

# AF_INET 互联网协议
# SOCK_STREAM TCP流式协议,
import time

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(socket)
# 与服务端建立连接，服务端的 ip和端口
socket.connect(('127.0.0.1', 8080))

for i in range(0, 20):
    # 发/收消息
    socket.send(('hello%s' % (i)).encode('utf-8'))
    # 收
    data = socket.recv(1024)
    print('收到服务端的数据', data)
# 关闭与服务端的链接
socket.close()

服务端
客户端

如何一个服务端支持多个客户端

服务端

import socket

# AF_INET 互联网协议
# SOCK_STREAM TCP流式协议,
import time

serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(serverSocket)
# 绑定ip和端口
serverSocket.bind(('127.0.0.1', 8080))

#
# 监听端口。指定限制
serverSocket.listen(5)

print('start')
# io 操作 沿着网络传输数据 读写文件
# 建立三次握手

while True:
    conn, client_addr = serverSocket.accept()
    print(conn)
    print(client_addr)
    while True:
        try:
            #  收/发消息
            # 1024接收的最大字节数bytes
            data = conn.recv(1024)
            # linux环境下。客户端close后，服务端会一直接受 b''。而不是抛异常。所以需要判断下
            # https://blog.csdn.net/bbg221/article/details/78464051
            if data == b'':
                break
            print('收到客户端的数据', data)
            # 变大写发送回去
            conn.send(data.upper())
        except ConnectionResetError as e:
            print('------')
            # 客户端断开连接
            break
    # 关闭与客户端建立的连接
    conn.close()

# 关闭服务器
serverSocket.close()

客户端

不用改动。多启动接个客户端来处理

带来另一个问题。发现第二次的连接必须等第一次连接完全结束了服务端才能继续处理。这肯定不合适

服务端并发处理客户端连接

通过单线程（协程）来解决

服务端

import socket
from gevent import monkey

monkey.patch_all()
from gevent import spawn


def recv_send(conn):
    # 通信循环
    while True:
        try:
            data = conn.recv(1024)
            if data == b'':
                break
            print('收到客户端数据', data)
            conn.send(data.upper())
        except ConnectionResetError:
            break


def connection(ip, port, backlog=5):
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((ip, port))
    server.listen(backlog)
    while True:
        # 链接循环
        conn, client_addr = server.accept()
        # 通信任务提交
        spawn(recv_send, conn)


if __name__ == '__main__':
    # 链接循环任务提交
    g1 = spawn(connection, '127.0.0.1', 8080)
    # 链接等待结束，是一个死循环任务不会结束
    g1.join()

通过多线程来执行

import socket
from concurrent.futures import ThreadPoolExecutor
from threading import Thread


def recv_send(conn):
    # 通信循环

    while True:
        try:
            data = conn.recv(1024)
            if data == b'':
                break
            print('收到客户端数据', data)
            conn.send(data.upper())
        except ConnectionResetError:
            break


def connection(ip, port, backlog=5):
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((ip, port))
    server.listen(backlog)
    global allconn
    while True:
        # 链接循环
        conn, client_addr = server.accept()
        t2 = Thread(target=recv_send, args=(conn,))
        t2.start()


if __name__ == '__main__':
    # 开启一个线程专门来建立连接
    t1 = Thread(target=connection, args=('127.0.0.1', 8080))
    t1.start()
    t1.join()

通过 tcpsocketserver 服务器

import socketserver
class MyTCPhanler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                data = self.request.recv(1024)
                print('收到客户端数据', data)
                self.request.send(data.upper())
            except ConnectionResetError:
                break


if __name__ == '__main__':
    # 通信循环
server=socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyTCPhanler)
    # 链接循环
    server.serve_forever()

多进程没有意义参考多线程实现就可

实际案例（远程在服务器上执行命令）

subprocess

'''
1. 什么是进程
        进程指的是一个程序的运行过程,或者说一个正在执行的程序
        所以说进程一种虚拟的概念,该虚拟概念起源操作系统
subprocess模块
    sub    子
    process 进程
        正在进行中的程序   每当打开一个程序就会开启一个进程
        每个进程包含运行程序所需的所有资源
        正常情况下 不可以跨进程访问数据  qq不能访问微信，微信不能访问qq
        但是有些情况写就需要访问别的进程数据    美团跳转到支付宝  这里跨进程了
        提供一个叫做管道的对象 专门用于跨进程通讯
    作用:用于执行系统命令
    总结  subprocess的好处是可以获取指令的执行结果
'''
import subprocess
cmd = input('输入命令')
        # shell：如果该参数为 True，
        # 将通过操作系统的 shell 执行指定的命令。
        # PIPE开启了一座桥，在2个进程之间
        # 命令stdout正确输出的结果
        # 命令stderr错误输出的结果
obj=subprocess.Popen(cmd,
                 shell=True,
                 stdout= subprocess.PIPE,
                 stderr= subprocess.PIPE,
                 )
stdout=obj.stdout.read().decode('gbk')
stderr=obj.stderr.read().decode('gbk')
print(stdout+stderr)

在这里插入图片描述

服务端

import socket
import subprocess
from threading import Thread


def recv_send(conn):
    # 通信循环
    while True:
        try:
            cmd = conn.recv(1024)
            if cmd == b'':
                break
            print('收到客户端数据', cmd.decode('utf-8'))
            obj = subprocess.Popen(cmd,
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,
                                   )
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()
            conn.send(stdout + stderr)
        except ConnectionResetError:
            break


def connection(ip, port, backlog=5):
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((ip, port))
    server.listen(backlog)
    while True:
        # 链接循环
        conn, client_addr = server.accept()
        t2 = Thread(target=recv_send, args=(conn,))
        t2.start()


if __name__ == '__main__':
    # 开启一个线程专门来建立连接
    t1 = Thread(target=connection, args=('127.0.0.1', 8080))
    t1.start()
    t1.join()

客户端

import socket

# AF_INET 互联网协议
# SOCK_STREAM TCP流式协议,
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(socket)
# 与服务端建立连接，服务端的 ip和端口
socket.connect(('127.0.0.1', 8080))

while True:
    cmd = input('请输入命令,输入quit退出: ')
    if cmd == 'quit':
        break
    socket.send(cmd.encode('utf-8'))
    out = socket.recv(1024)
    print('命令执行结果：')
    print(out.decode('utf-8'))
# 关闭与服务端的链接
socket.close()

客户端操作

粘包问题

上面的例子每次接受指定1024个字节，那如果传输的数据超过了1024个字节怎么办？
如果接受的数据没有读完，下次再读取的时候就会接着上次的读取，这样的话就会导致数据不完整。多了或者少了。我们无法评估网络传输的数据量到底有多少，也不可能传输的数据量有多少我们就在内存中开辟多大的空间。

粘包案例

客户端发送两次 10个字节
服务端每次只接受9个字节
导致服务端第一次只能接受9个字节
剩下一个字节在第二次循环的时候继续接受。
同理第二次循环也没有读完，继续留给第三次循环接受
但是客户端只发送了两次。

服务端

import socket
import subprocess

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8080))
server.listen(5)
# 链接循环
conn, client_addr = server.accept()
# 通信循环
while True:
    try:
        # 每次都接受递9个字节
        data = conn.recv(9)
        if data == b'':
            break
        print('收到客户端数据', data.decode('utf-8'))
    except ConnectionResetError:
        break

在这里插入图片描述

客户端

import socket

# AF_INET 互联网协议
# SOCK_STREAM TCP流式协议,
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(socket)
# 与服务端建立连接，服务端的 ip和端口
socket.connect(('127.0.0.1', 8080))
# 客户端发送10个字节
send_data = '0123456789'
socket.send(send_data.encode('utf-8'))

send_data = '0123456789'
socket.send(send_data.encode('utf-8'))
# 关闭与服务端的链接
socket.close()

解决粘包问题

粘包问题是tcp协议流式传输数据的方式导致的
如何解决粘包问题:接收端能够精确地收干净每个数据包没有任何残留
所以客户端必须告诉服务端发送多少数据，就要有个报头

分析:
报头的信息应该包含长度信息
问题1：发送的时候只能是Bytes类型
描述长度的是数字
所以我们应该把整型数字转换成固定长度的Bytes类型

服务端

import socket
import struct

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8080))
server.listen(5)
# 链接循环
conn, client_addr = server.accept()
# 通信循环
while True:
    try:
        # 按照固定的格式先解析请求头中的长度
        header = conn.recv(4)
        if header == b'':
            break
        data_len = struct.unpack('i', header)[0]
        data = conn.recv(data_len)

        print('收到客户端数据', data.decode('utf-8'))
    except ConnectionResetError:
        break
conn.close()
server.close()

服务端输出

客户端


import socket
# 把整型数字转换成固定长度的Bytes类型
import struct

# AF_INET 互联网协议
# SOCK_STREAM TCP流式协议,
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(socket)
# 与服务端建立连接，服务端的 ip和端口
socket.connect(('127.0.0.1', 8080))
# 把数字转换成4个Bytes
# 客户端发送10个字节
send_data = '0123456789'
send_header = struct.pack('i', len(send_data))
socket.send(send_header + send_data.encode('utf-8'))

send_data = '0123456789'
send_header = struct.pack('i', len(send_data))
socket.send(send_header + send_data.encode('utf-8'))
# 关闭与服务端的链接
socket.close()

UDP通讯

服务端

# 没有实现真正意义的并发
# 只是说收发消息很快
# 原因是由于数据量太小
# 客户端太少
import socket

# udp用SOCK_DGRAM数据报
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8080))

while True:
    # 接收的是数据和客户端的ip和端口元组
    data, client_addr = server.recvfrom(1024)
    print(data)
    print(client_addr)
    server.sendto(data.upper(), client_addr)

客户端

import socket
# udp用SOCK_DGRAM数据报
client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

while True:
    msg = input('>>>.').strip()
    # 爱收就收，不收也会把操作系统数据清清除
    client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
    # 发空也可以，因为报头有数据
    data, server_addr = client.recvfrom(1024)
    print(data)

socketserver 模块实现多线程并发服务端

服务端

import socketserver
import time


class MyUphander(socketserver.BaseRequestHandler):
    def handle(self):
        # print(self.request)
        data, sock = self.request
        print(data)
        # self.client_address
        time.sleep(1)
        sock.sendto(data.upper(), self.client_address)


if __name__ == '__main__':
    # 1.创建一个线程的通信循环
    server = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), MyUphander)
    # 3.链接循环 serve_forever永远提供服务
    server.serve_forever()