Detailed explanation of using Python Socket programming

This article mainly introduces the detailed introduction of Python Socket programming. Socket can establish connections and transmit data. It has certain reference value. Interested friends can refer to it.

When using Python for socket programming, since you need to use blocking (default) to read the data stream, you need to handle the end of the data yourself every time, which is too troublesome. And I couldn't find a good package on the Internet, so I wrote a simple package myself.

Encapsulation ideas

1. The client sends a SocketRequest object for each request, which encapsulates specific data. json is used here. For the data to be sent, an end character identifier (EOF = ‘0x00’) is automatically added.

2. When the server receives data, it generates complete data based on the end character identifier and unpacks it into a SocketRequest object.

3. The server generates a SocketResponse object based on the content of the SocketRequest. Here a SimpleRequestHandler class is used to process it. In the example, no processing is done and the object is returned as is.

4. The server sends SocketResponse to the client. The package also needs to be encapsulated, and an end character identifier (EOF = ‘0x00’) will be automatically added.

5. When the client receives data, it generates complete data based on the end character identifier, unpacks it into a SocketResponse object, and then returns it.

Packaging class

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

Run test

First, run socket_server.py

Then, run socket_client.py

The above is the detailed content of Detailed explanation of using Python Socket programming. For more information, please follow other related articles on the PHP Chinese website!