Python Socket 프로 그래 밍 상세 소개

Python 을 사용 하여 socket 프로 그래 밍 을 할 때 차단(기본)방식 으로 데이터 흐름 을 읽 어야 하기 때문에 데이터 가 끝 날 때마다 스스로 처리 해 야 합 니 다.너무 번 거 롭 습 니 다.그리고 인터넷 에서 도 좋 은 패 키 지 를 찾 지 못 해 간단 한 패 키 지 를 썼 다.
포장 사고
1.클 라 이언 트 가 요청 할 때마다 SocketRequest 대상 을 보 냅 니 다.그 중에서 구체 적 인 데 이 터 를 밀봉 하고 json 을 사용 합 니 다.보 낼 데이터 에 대해 서 는 자동 으로 끝 표시(EOF='0x 00')를 추가 합 니 다.
2.서버 측 에서 데 이 터 를 수신 할 때 엔 딩 마크 에 따라 완전한 데 이 터 를 생 성하 고 SocketRequest 대상 으로 압축 해제 합 니 다.
3.서버 측은 SocketRequest 의 내용 에 따라 SocketResponse 대상 을 생 성 합 니 다.여 기 는 Simple Request Handler 류 를 사용 하여 처 리 했 습 니 다.예 를 들 어 아무런 처리 도 하지 않 고 그대로 되 돌 아 왔 습 니 다.
4.서버 에서 클 라 이언 트 에 SocketResponse 를 보 냅 니 다.그 중에서 도 가방 을 포장 해 야 합 니 다.종료 문자 표지(EOF='0x 00')를 자동 으로 추가 합 니 다.
5.고객 이 데 이 터 를 받 을 때 엔 딩 문자 표지 에 따라 완전한 데 이 터 를 생 성하 고 SocketResponse 대상 으로 압축 을 풀 고 되 돌려 줍 니 다.
패키지 클래스
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)

테스트
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

실행 테스트
우선,socket 실행server.py
그리고 socket 실행client.py
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.