Python 소켓 프로그래밍에 대한 예비 탐구

소켓 프로그래밍 단계

서버는 소켓을 생성하고 주소와 포트를 바인딩한 후 해당 포트에서 들어오는 연결을 수신합니다. 연결이 들어오면 accept 함수를 통해 들어오는 연결을 받습니다.

클라이언트도 소켓을 생성합니다. 원격 주소와 포트를 바인딩한 다음 연결을 설정하고 데이터를 보냅니다.

서버측 소켓

다음은 서버측 socker_server.py를 자세히 설명하기 위한 샘플 코드입니다

import socket
import sys

HOST = "127.0.0.1"               
PORT = 10000              
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
                              socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except socket.error as msg:
        s = None
        continue
    try:
        s.bind(sa)
        s.listen(5)
    except socket.error as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print 'could not open socket'
    sys.exit(1)
conn, addr = s.accept()
print 'Connected by', addr
while 1:
    data = conn.recv(1024)
    if not data: break
    conn.send(data)
conn.close()

먼저 호스트/포트를 A로 변환합니다. 5-튜플을 포함하는 시퀀스. 이 5-튜플에는 소켓 연결을 생성하는 데 필요한 모든 매개변수가 포함되어 있습니다. 반환된 5-튜플은 (family, 소켓 유형, proto, canonname, sockaddr)

가족 주소 클러스터이며, 이는 소켓() 함수의 첫 번째 매개 변수로 사용됩니다. 주로 다음과 같은 것들이 있습니다.

socket.AF_UNIX는 단일 시스템의 프로세스와 통신하는 데 사용됩니다.
socket.AF_INET은 서버와 통신하는 데 사용됩니다.
socket.AF_INET6은 IPv6
소켓 유형 소켓 유형을 지원하며, 일반적으로 사용되는

socket.SOCK_STREAM 기본값은 TCP 프로토콜
소켓에 사용됩니다. . SOCK_DGRAM은 UDP 프로토콜
proto 프로토콜에 사용되며 소켓() 함수의 세 번째 매개변수로 사용됩니다. getaddrinnfo 함수는 적절한 프로토콜

canonname과 주소 형식 및 소켓 유형을 기반으로 표준화된 호스트 이름을 반환합니다.

그런 다음 내 소켓 주소를 바인딩합니다

s = socket.socket(af, socktype, proto)

리스닝 모드 활성화

s.bind(sa)

듣기 기능은 소켓에 연결된 연결, 매개변수 연결을 거부하기 전에 시스템이 정지할 수 있는 최대 연결 대기열 수는 5입니다. 이러한 연결은 아직 승인되지 않았습니다. 수량은 무한할 수 없으며 일반적으로 5가 지정됩니다.

연결을 수신하면 연결을 수신하기 위해 accept 함수를 호출합니다.

s.listen(5)

accept 함수는 튜플을 반환하고 conn은 연결을 수신하는 데 사용되는 새로운 소켓 개체입니다. 데이터를 보내십시오. addr은 상대방의 소켓 주소를 나타냅니다.

다음으로 conn 개체를 사용하여 데이터를 보내고 받을 수 있습니다.

conn, addr = s.accept()

여기서 연결 소켓을 수신하면 실행이 중지되므로 연결을 반복하려면 다음을 사용하세요. accept 함수를 무한 루프에 넣습니다.

클라이언트 소켓

 data = conn.recv(1024) # 接收数据, 这里指定一次最多接收的字符数量为1024
 conn.send(data) # 发送数据

클라이언트 소켓 프로그래밍은 비교적 간단합니다. Connect를 통해 서버와 연결을 맺은 후 서로 통신할 수 있습니다. 소켓_client.py는 다음과 같습니다

위 내용은 주로 TCP 스트림 데이터의 소켓 프로그래밍을 위한 것입니다. UDP 프로토콜 데이터의 경우 처리가 약간 다릅니다. 예를 들어 UDP 데이터 패킷을 보내고 받는 처리 기능은 다음과 같습니다.

for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except socket.error as msg:
        s = None
        continue
    try:
        s.connect(sa)
    except socket.error as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print 'could not open socket'
    sys.exit(1)
s.sendall('Hello, world')
data = s.recv(1024)
s.close()
print 'Received', repr(data)

SocketServer 모듈

파이썬의 네트워크 프로그래밍에서는 소켓 모듈 외에도 SocketServer 모듈이 제공됩니다. 모듈은 주로 소켓 모듈을 수행합니다. 캡슐화는 소켓 객체의 생성, 바인딩, 연결, 수신, 전송 및 닫기를 캡슐화하여 네트워크 서비스 프로그래밍을 크게 단순화합니다.

socket.sendto(string, flags, address)
socket.recvfrom(bufsize[, flags]) #返回(string, address)，string是返回的数据，address是发送方的socket地址

이 모듈은 해당 소켓 스트림을 생성하기 위해 다음 2가지 주요 네트워크 서비스 클래스를 제공합니다.

TCPServer는 TCP 프로토콜의 소켓 스트림을 생성합니다.

UDPServer UDP 프로토콜의 소켓 스트림을 생성합니다

소켓 스트림 객체가 있고 요청 처리 클래스도 필요합니다. SocketServer 모듈은 BaseRequestHandler, 파생 클래스 StreamRequestHandler 및 DatagramRequestHandler를 포함한 요청 처리 클래스를 제공합니다. 따라서 이 3개 클래스 중 하나를 상속한 다음 핸들 함수를 재정의하면 수신된 요청을 처리하는 데 사용됩니다. 서버 측 코드 예제를 살펴보겠습니다

import SocketServer

class MyTCPHandler(SocketServer.StreamRequestHandler):
   """创建请求处理类，重写handle方法。此外也可以重写setup()和finish()来做一些请求处理前和处理后的一些工作"""
    def handle(self):
        # self.request is the TCP socket connected to the client
        self.data = self.request.recv(1024).strip()
        print "{} wrote:".format(self.client_address[0])
        print self.data
        # just send back the same data, but upper-cased
        self.request.sendall(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 10000

    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    # server.shutdown()
    server.serve_forever()  # 一直循环接收请求
    # server.handle_request() # 只处理一次请求就退出

看着是不是代码简单了很多，而且SocketServer模块内部使用了多路复用IO技术，可以实现更好的连接性能。看serve_forever函数的源代码用到了select模块。通过传入socket对象调用select.select()来监听socket对象的文件描述符，一旦发现socket对象就绪，就通知应用程序进行相应的读写操作。源代码如下：

def serve_forever(self, poll_interval=0.5):
        """Handle one request at a time until shutdown.

        Polls for shutdown every poll_interval seconds. Ignores
        self.timeout. If you need to do periodic tasks, do them in
        another thread.
        """
        self.__is_shut_down.clear()
        try:
            while not self.__shutdown_request:
                # XXX: Consider using another file descriptor or
                # connecting to the socket to wake this up instead of
                # polling. Polling reduces our responsiveness to a
                # shutdown request and wastes cpu at all other times.
                r, w, e = _eintr_retry(select.select, [self], [], [],
                                       poll_interval)
                if self in r:
                    self._handle_request_noblock()
        finally:
            self.__shutdown_request = False
            self.__is_shut_down.set()

即使使用了select技术，TCPServer，UDPServer处理请求仍然是同步的，意味着一个请求处理完，才能处理下一个请求。但SocketServer模块提供了另外2个类用来支持异步的模式。

ForkingMixIn 利用多进程实现异步

ThreadingMixIn 利用多线程实现异步

看名字就知道使用了mixin模式。而mixin模式可以通过多继承来实现，所以通过对网络服务类进行多继承的方式就可以实现异步模式

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass

针对ThreadindMixIn,实现异步的原理也就是在内部对每个请求创建一个线程来处理。看源码

def process_request(self, request, client_address):
        """Start a new thread to process the request."""
        t = threading.Thread(target = self.process_request_thread,
                             args = (request, client_address))
        t.daemon = self.daemon_threads
        t.start()

下面提供一个异步模式的示例

import socket
import threading
import SocketServer

class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):

    def handle(self):
        data = self.request.recv(1024)
        cur_thread = threading.current_thread()
        response = "{}: {}".format(cur_thread.name, data)
        self.request.sendall(response)

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass

def client(ip, port, message):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((ip, port))
    try:
        sock.sendall(message)
        response = sock.recv(1024)
        print "Received: {}".format(response)
    finally:
        sock.close()

if __name__ == "__main__":
    # Port 0 means to select an arbitrary unused port
    HOST, PORT = "localhost", 0

    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
    ip, port = server.server_address

    # Start a thread with the server -- that thread will then start one
    # more thread for each request
    server_thread = threading.Thread(target=server.serve_forever)
    # Exit the server thread when the main thread terminates
    server_thread.daemon = True
    server_thread.start()
    print "Server loop running in thread:", server_thread.name

    client(ip, port, "Hello World 1")
    client(ip, port, "Hello World 2")
    client(ip, port, "Hello World 3")

    server.shutdown()
    server.server_close()

以上是本人对socket相关的理解，有什么不当或错误之处，还请指出。