Explication détaillée de l'utilisation de la programmation Python Socket

Cet article présente principalement l'introduction détaillée de la programmation Python Socket. Socket peut établir des connexions et transmettre des données. Il a une certaine valeur de référence.

Lorsque vous utilisez Python pour la programmation socket, puisque vous devez utiliser la méthode de blocage (par défaut) pour lire le flux de données, vous devez gérer vous-même la fin des données à chaque fois, ce qui est trop gênant. Et je n'ai pas trouvé de bon package sur Internet, alors j'ai écrit moi-même un package simple.

Idée d'encapsulation

1 Le client envoie un objet SocketRequest pour chaque requête, qui encapsule des données spécifiques ici. Pour les données à envoyer, un identifiant de caractère de fin (EOF = ‘0x00’) est automatiquement ajouté.

2. Lorsque le serveur reçoit des données, il génère des données complètes basées sur l'identifiant du caractère de fin et les décompresse dans un objet SocketRequest.

3. Le serveur génère un objet SocketResponse basé sur le contenu de SocketRequest. Ici, une classe SimpleRequestHandler est utilisée pour le traitement. Dans l'exemple, aucun traitement n'est effectué et l'objet est renvoyé tel quel. .

4. Le serveur envoie SocketResponse au client. Le package doit également être encapsulé et un identifiant de caractère de fin (EOF = '0x00') sera automatiquement ajouté.

5. Lorsque le client reçoit les données, les données complètes sont générées en fonction de l'identifiant du caractère de fin, décompressées dans un objet SocketResponse, puis renvoyées.

Classe d'emballage

sockets.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import socket
import pickle
import thread


PORT = 12345
EOF = '0x00'


class SocketServer(object):

  def __init__(self, port=None):
    self.port = port

  def startup(self):
    sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock_server.bind(('0.0.0.0', self.port))
    sock_server.listen(0)

    while True:
      sock, address = sock_server.accept()
      thread.start_new_thread(self.__invoke, (sock, address))

  def shutdown(self):
    pass

  def __invoke(self, sock, address):
    try:
      full_data = ''
      while True:
        data = sock.recv(1024)
        if data is None:
          return

        full_data += data
        if full_data.endswith(EOF):
          full_data = full_data[0:len(full_data) - len(EOF)]
          request = pickle.loads(full_data)
          response = SimpleRequestHandler().handle(request)
          sock.sendall(pickle.dumps(response) + EOF)
          return
    except Exception as e:
      print e
    finally:
      sock.close()


class SocketClient(object):

  def __init__(self, host, port):
    self.host = host
    self.port = port

  def execute(self, request):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((self.host, self.port))

    try:
      sock.sendall(pickle.dumps(request) + EOF)
      full_data = ''
      while True:
        data = sock.recv(1024)
        if data:
          full_data += data
          if full_data.endswith(EOF):
            full_data = full_data[0:len(full_data) - len(EOF)]
            response = pickle.loads(full_data)
            return response
        else:
          return None
    except Exception as e:
      print e
      return None
    finally:
      sock.close()


class SocketRequest(object):
  def __init__(self, data):
    self.data = data

  def __repr__(self):
    return repr(self.__dict__)


class SocketResponse(object):
  def __init__(self, data):
    self.data = data

  def __repr__(self):
    return repr(self.__dict__)


class SimpleRequestHandler(object):
  def __init__(self):
    pass

  def __repr__(self):
    return repr(self.__dict__)

  def handle(self, request):
    return SocketResponse(request.data)

Test

socket_server.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from agent.sockets import *

ss = SocketServer(PORT)
ss.startup()

socket_client.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pickle
from agent.sockets import *


sc = SocketClient('localhost', PORT)
request = SocketRequest('abc')
response = sc.execute(request)
print request
print response

Exécuter Test

Tout d'abord, exécutez socket_server.py

Ensuite, exécutez socket_client.py

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!