python 30 基于TCP协议的socket通信

时间：2023-03-08 19:37:29

1. 单对单循环通信

​ send() 和recv()不是一一对应的。

# 服务端 server.py

import socket

phone = socket.socket()

phone.bind = (('127.0.0.1', 8888))  # 绑定本地回环地址/端口号

phone.listen()  # 开始监听

conn, addr = phone.accept()  # 等待连接

print(f"连接{addr}成功！")

while 1:

    try:

    	from_client_data = conn.recv(1024)

    	if from_client_data.upper() == b'Q':   # 字节bytes Q

        	print('客户端已正常退出！')

        	break

        print(f"来自客户端{addr}的消息：{from_client_data.decode('utf-8')}")

        to_server_data = input('>>>').strip().encode('utf-8')

        phone.send(to_server_data)

    except ConnectionResetError:

        print('客户端连接中断！')

        break

conn.close()

phone.close()


# 客户端 client.py

import socket

phone = socket.socket()

phone.connect(('127.0.0.1',8888))

while 1:

    to_server_data = input('>>>').strip().encode('utf-8')

    if not to_server_data:

        print('输入内容不能为空！')

        continue

    phone.send(to_server_data)

    if to_server_data.upper() == b'Q':

        break

    from_server_data = phone.recv(1024)

    print(f"来自服务端的消息：{from_server_data.decode('utf-8')}")

phone.close()

2. 循环连接通信：可连接多个客户端

# 服务端循环接收连接

import socket

phone = socket.socket()

phone.bind(('127.0.0.1',8848))

phone.listen()

while 1:

	conn,addr = phone.accept()		# 循环可接收客户端

	print(f'与客户端{addr}连接成功！')

    while 1:

        try:

            from_client_data = conn.recv(1024)

            if from_client_data.upper() == b'Q':

                print('客户端已退出！')

                break

            print(f"来自客户端的消息：{from_client_data.decode('utf-8')}")

            to_client_data = input('>>>').strip().encode('utf-8')

            conn.send(to_client_data)

        except ConnectionResetError:

            print('客户端连接中断！')

            break

    conn.close()

phone.close()


# 客户端 client

import socket

phone = socket.socket()

phone.connect(('127.0.0.1',8848))

while 1:

    to_server_data = input('>>>').strip().encode('utf-8')

    if not to_server_data:

        print('输入内容不能为空！')

        continue

    phone.send(to_server_data)

    if to_server_data.upper() == b'Q':

        break

    from_server_data = phone.recv(1024)

    print(f"来自服务端的消息：{from_server_data.decode('utf-8')}")

phone.close

3. 执行远程命令

# 使用subproess模块 可像操作系统cmd一样执行命令

import subprocess

obj = subprocess.Popen('dir',

                 shell=True,

                 stdout=subprocess.PIPE,

                 stderr=subprocess.PIPE,

                )

print(obj.stdout.read().decode('gbk'))  # 正确命令

print(obj.stderr.read().decode('gbk'))  # 错误命令

# 如果是正确的命令，那么错误命令会输出空字符。

# shell: 命令解释器，相当于调用cmd 执行指定的命令。

# stdout:正确结果丢到管道中。

# stderr:错了丢到另一个管道中。

# windows操作系统的默认编码是gbk编码。
# 在服务端 增加subprocess模块，

import subprocess

import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8888))

phone.listen()

while 1:

    conn, addr = phone.accept()

    print(f'连接{addr}成功！')

    while 1:

        try:

            from_client_data = conn.recv(1024)

            if from_client_data.upper() == b'Q':

                print('客户端正常退出！')

                break

            # print(f"来自客户端{addr}的消息：{from_client_data.decode('utf-8')}")

            obj = subprocess.Popen(from_client_data.decode("utf-8"),

                                   shell=True,

                                   stdout=subprocess.PIPE,

                                   stderr=subprocess.PIPE,

                                   )

            to_client_data = obj.stdout.read() + obj.stderr.read()

            # subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码

            conn.send(to_client_data) # 此时是gbk的bytes的类型

        except ConnectionResetError:

            print('客户端连接中断！')

            break

    conn.close()

phone.close()
# 客户端 client

import socket

phone = socket.socket()

phone.connect(('127.0.0.1', 8888))

while 1:

    to_server_data = input('>>>').strip().encode('utf-8')

    if not to_server_data:

        print('输入内容不能为空！')

        continue

    phone.send(to_server_data)

    if to_server_data.upper() == b'Q':

        break

    from_server_data = phone.recv(1024)

    print(f"{from_server_data.decode('gbk')}")  # 需gbk解码

phone.close()

4. 粘包现象

4.1 socket缓冲区

python 30 基于TCP协议的socket通信

​ 每个socket，都会有两个缓冲区，输入/输出缓冲区。过程如上图，send()结束后，会马上进入recv()状态（有阻塞）。

​ 作用：1. 暂时存储一些数据；2. 如果网络有波动，缓冲区会保护数据的收发稳定、匀速。

​ 缺点：是会造成粘包的现象之一。

4.2 出现粘包的情况：

​ 1. 如果客户端send() 数据超过recv() 设定的字节数，会先接收最大限制的字节数，当第二次send() 数据时，recv() 会将上次遗留的数据接收，产生粘包现象。

  1. 连续短暂send() 多次（数据量较小），数据会统一发送出去，产生粘包。

    （Nagle算法）

4.3 解决粘包现象

#思路：

	服务端发出send() 数据有10000字节，客户端接收数据时，循环recv()接收，每次（至多）接收1024字节，直至将所有的字节全部接收完毕，将接收的数据拼接在一起，编码打印出。

#遇到的问题：

	1. recv() 次数无法确定。

	客户端先接收总数据的一个长度，然后再循环recv 控制循环次数，只有接收的数据长度 < 总数据长度，就会一直接收。（先发总数据长度，再发总数据）

	2.获取总数据的长度是 int 类型，先要转换成 bytes 类型，再发出，但是总数据的长度转化成的 bytes类型的字节数是不固定的。

	int:376 ——> str(376):'376' ——> bytes:b'376'  (长度为3)

	int:4558 ——> str(4558):'4558' ——> bytes:b'4558'  (长度为4)     解决：将不固定长度的int类型转换成固定长度的bytes，并且还可以反解回来。（用来制定固定长度的报头）


# 将不固定长度的int类型转换成固定长度的bytes

import struct

ret = struct.pack('i',376) # 将int 376转换成固定4个长度的bytes字节

# i 默认长度为 4； q 默认为8

print(ret,type(ret),len(ret))

ret1 = struct.unpack('i',ret)[0]    # 是元组形式， 反解成int型

print(ret1,type(ret1))

# 但是通过struct 处理不能处理太大数据

ret = struct.pack('l', 4323241232132324)

print(ret, type(ret), len(ret))  # 报错
# low版解决粘包现象

# 服务端server

import socket

import subprocess

import struct

phone = socket.socket()

phone.bind(('127.0.0.1',8888))

phone.listen()

while 1:

    conn, addr = phone.accept()

    print(f'与客户端{addr}连接')

    while 1:

        try:

            from_client_data = conn.recv(1024)

            if from_client_data.upper() == b'Q':

                print('客户端已退出！')

                break

            obj = subprocess.Popen(from_client_data.decode("utf-8"),

                                   shell=True,

                                   stdout=subprocess.PIPE,

                                   stderr=subprocess.PIPE,

                                   )

            total_data = obj.stdout.read() + obj.stderr.read()

            conn.send(struct.pack('i', len(total_data)))  # 发出 总数据长度的bytes类型

            print(len(total_data))

            conn.send(total_data)   # 发出总数据 gbk编码的字节

        except ConnectionResetError:

            print('与客户端连接中断！')

            break

    conn.close()

phone.close()


# 客户端client

import socket

import struct

phone = socket.socket()

phone.connect(('127.0.0.1', 8888))

while 1:

    to_server_data = input('>>>').strip().encode('utf-8')

    if not to_server_data:

        print('内容不能为空！')

        continue

    phone.send(to_server_data)

    if to_server_data.upper() == b'Q':

        break

    head_bytes = phone.recv(4)   # 接收总数据长度的bytes

    head_int = struct.unpack('i', head_bytes)[0]  # 反解成int

    print(head_int)

    data = b''		# 定义一个空字节

    while len(data) < head_int:

        data = data + phone.recv(1024)

    print(len(data))

    print(f"{data.decode('gbk')}")  # 终端是 gbk 编码的

phone.close()

bytes

​ 用于网络传输、文件存储时。

python 30 基于TCP协议的socket通信

能够保持数据原本类型。

相关文章