python套接字中的发送字典

Question

我想通过python套接字发送字典

我尝试对发送数据进行编码，然后在接收点进行编码

但问题在于接收到的数据无法转换，无法转换成字典

这是我的密码：

类client.py：

HEADER_LENGTH = 512
IP = "127.0.0.1"
PORT = 963

my_username = input("Username: ")
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((IP, PORT))
client_socket.setblocking(False)
username = my_username.encode('utf-8')
username_header = f"{len(username):<{HEADER_LENGTH}}".encode('utf-8')
client_socket.send(username_header + username)
while True:
    message = input(f"{my_username} > ")
    if message:
        message = message.encode('utf-8')
        message_header = f"{len(message)}:<{HEADER_LENGTH}".encode('utf-8')
        # {'header': {message_header}, 'data': {message}}
        send_dict = {} # 'header': message_header, 'data': message
        send_dict["header"] = str(message_header)
        send_dict["data"] = str(message)
        client_socket.send(json.dumps(send_dict).encode('utf-8'))  # message_header + message
    try:
        while True:
            # Receive ...
            username_header = client_socket.recv(HEADER_LENGTH)
            if not len(username_header):
                print("Connection closed by the server")
                sys.exit()
            username_length = int(username_header.decode('utf-8').strip())
            username = client_socket.recv(username_length).decode(('utf-8'))

            message_header = client_socket.recv(HEADER_LENGTH)
            message_length = int(message_header.decode('utf-8').strip())
            message = client_socket.recv(message_length).decode(('utf-8'))
            print(f"{username} > {message}")

    except IOError as e:
        if e.errno != errno.EAGAIN and e.errno != errno.EWOULDBLOCK:
            print('Reading error', str(e))
            sys.exit()
        continue
    except Exception as e:
        print('General error', str(e))
        sys.exit()

类server.py：

HEADER_LENGTH = 512
IP = "127.0.0.1"
PORT = 963

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind((IP, PORT))
server_socket.listen()

socket_list = [server_socket]
clients = {}


def receive_message(client_socket):
    # print(f"client socket: {client_socket}")
    # try:
    message_header = client_socket.recv(HEADER_LENGTH)
    if not len(message_header):
        print("return from receive message /condition/")
        return False
    print(f"message header: {type(message_header)}")
    print(f"message header: {message_header}")
    print(f"message header decode : {type(message_header.decode('utf-8').strip())}")
    message_header_dict = message_header.decode('utf-8').strip()
    # print(f"message header replaced : {message_header}")
    print(f"message header replaced : {type(message_header_dict)}")
    print(f"message header replaced : {message_header_dict}")
    # print("message header header : " + message_header_dict['header'].decode('utf-8').strip())
    json_message_header = json.loads(message_header_dict)
    print(f"message header replaced : {json_message_header}")
    print(f"message header replaced : {json_message_header['data']}") # Error line
    message_length = int(message_header.decode("utf-8").strip())
    return {"header": message_header, "data": client_socket.recv(message_length)}
    # except:
        # print("return from receive message /except/")
        # return False


while True:
    read_sockets, _, exception_sockets = select.select(socket_list, [], socket_list)
    for notified_socket in read_sockets:
        if notified_socket == server_socket:
            client_socket, client_address = server_socket.accept()
            user = receive_message(client_socket)
            if user == False:
                continue
            socket_list.append(client_socket)
            clients[client_socket] = user
            print(
                f"Accept new connection from {client_address[0]}:{client_address[1]} username:{user['data'].decode('utf-8')}")
        else:
            message = receive_message(notified_socket)
            if message == False:
                print(f"close connection from: {clients[notified_socket]['data'].decode('utf-8')}")
                socket_list.remove(notified_socket)
                del clients[notified_socket]
                continue
            user = clients[notified_socket]
            print(f"Received message from: {user['data'].decode('utf-8')}: {message['data'].decode('utf-8')}")
            for client_socket in clients:
                if client_socket != notified_socket:
                    client_socket.send(user['header'] + user['data'] + message['header'] + message['data'])
    for notified_socket in exception_sockets:
        socket_list.remove(notified_socket)
        del clients[notified_socket]

Answer 1

您可以使用pickle或其更快的版本cPickle来序列化数据和反序列化数据

import pickle

# for serializing data 
pickle.dumps(data_to_serialized)
# for deserializing 
pickle.loads(data_to_be_deserialized)

下面是使用pickle发送和接收数据以进行序列化的示例函数：

def send_data(conn, data):
        serialized_data = pickle.dumps(data)
        conn.sendall(struct.pack('>I', len(serialized_data)))
        conn.sendall(serialized_data)


def receive_data(conn):
    data_size = struct.unpack('>I', conn.recv(4))[0]
    received_payload = b""
    reamining_payload_size = data_size
    while reamining_payload_size != 0:
        received_payload += conn.recv(reamining_payload_size)
        reamining_payload_size = data_size - len(received_payload)
    data = pickle.loads(received_payload)

    return data

您可以在https://github.com/vijendra1125/Python-Socket-Programming.git找到示例程序

Answer 2

您的客户端发送JSON。然后，服务器读取整个JSON消息并尝试将其解释为整数。轰

传输完整消息基本上有3个选项：发送字节，并假设您从一次读取中接收到整个消息，而不是更多（最不可靠）；使用分隔符（，例如，CRLF），并确保它不会出现在消息中（受限数据流）；或者发送一个字节计数，后跟消息字节（长度+数据，最可靠）。看起来您混合了第一种和第三种方法，这基本上不起作用

要使用length+数据将dict序列化为JSON传输，首先JSON对dict进行编码，然后UTF8对结果字符串进行编码以获得消息字节。从这一点开始，直到服务器反序列化消息，代码都在使用字节

要发送长度+数据，struct模块是您的朋友。定义打包/解包说明符（基本上是选定的大小整数加上bytestring）。例如，"!Hs"将支持高达64K的消息bytestring

在客户端

• 获取UTF8编码消息字符串的编码长度
• 使用struct.pack创建二进制消息（<；长度头>；<；消息字节>；）
• 使用socket.sendall发送二进制消息（发送消息可能需要多次send调用，而sendall会为您处理这些调用）

在服务器中

• 使用socket.recv只接收头字节（例如、4或8字节）
• 使用struct.unpack解压字节计数
• 使用socket.recv仅接收消息字节（即，字节计数字节）
• 要从接收的（序列化的）消息字节反序列化dict，请先进行UTF8解码，然后进行JSON解码