Ausführliche Erklärung der Programmierung mit Python Socket

Dieser Artikel stellt hauptsächlich die detaillierte Einführung in die Python-Socket-Programmierung vor. Interessierte Freunde können sich darauf beziehen.

Wenn Sie Python für die Socket-Programmierung verwenden, müssen Sie das Ende der Daten jedes Mal selbst verwalten, da Sie zum Lesen des Datenstroms die Blockierungsmethode (Standard) verwenden müssen, was zu mühsam ist. Und ich konnte im Internet kein gutes Paket finden, also habe ich selbst ein einfaches Paket geschrieben.

Kapselungsidee

1. Der Client sendet für jede Anfrage ein SocketRequest-Objekt, das hier spezifische Daten kapselt. Für die zu sendenden Daten wird automatisch eine Endzeichenkennung (EOF = „0x00“) hinzugefügt.

2. Wenn der Server Daten empfängt, generiert er vollständige Daten basierend auf der Endzeichenkennung und entpackt sie in ein SocketRequest-Objekt.

3. Der Server generiert ein SocketResponse-Objekt basierend auf dem Inhalt der SocketRequest. Hier wird eine SimpleRequestHandler-Klasse für die Verarbeitung verwendet und das Objekt wird unverändert zurückgegeben .

4. Der Server sendet SocketResponse an den Client. Das Paket muss außerdem gekapselt werden und eine Endzeichenkennung (EOF = „0x00“) wird automatisch hinzugefügt.

5. Wenn der Client die Daten empfängt, werden die vollständigen Daten basierend auf der Endzeichenkennung generiert, in ein SocketResponse-Objekt entpackt und dann zurückgegeben.

Verpackungsklasse

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

Ausführen Testen Sie

Führen Sie zuerst socket_server.py aus

Dann führen Sie socket_client.py aus

Das obige ist der detaillierte Inhalt vonAusführliche Erklärung der Programmierung mit Python Socket. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!