socketserver — 网络服务器的框架

+------------+
| BaseServer |
+------------+
      |
      v
+-----------+        +------------------+
| TCPServer |------->| UnixStreamServer |
+-----------+        +------------------+
      |
      v
+-----------+        +--------------------+
| UDPServer |------->| UnixDatagramServer |
+-----------+        +--------------------+

BaseServer 包含服务器的核心功能与混合类(mix-in)挂钩
TCPServer / UDPServer 基本的网络同步TCP/UDP服务器
UnixStreamServer / UnixDatagramServer 基本的基于文件同步TCP/UDP服务器
ForkingMixIn / ThreadingMixIn 实现了核心的进程化或线程化的功能;作为混合类，与服务器类一并使用以提供一些异步特性
ForkingTCPServer / ForkingUDPServer
ThreadingTCPServer / ThreadingUDPServer
BaseRequestHandler 包含处理服务请求的核心功能
StreamRequestHandler / DatagramRequestHandler 用于TCP/UDP服务器的服务处理工具

'''
Created on 2016年3月29日
File Name:TCPServer.py
@author: LindenTao
Description : 引用socketserver框架的TCPServer
'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    """
    The request handler class for our server.

    It is instantiated once per connection to the server, and must
    override the handle() method to implement communication to the
    client.
    """

    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())

class MyTCPHandlerBak(socketserver.StreamRequestHandler):

    def handle(self):
        # self.rfile is a file-like object created by the handler;
        # we can now use e.g. readline() instead of raw recv() calls
        self.data = self.rfile.readline().strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        # Likewise, self.wfile is a file-like object used to write back
        # to the client
        self.wfile.write(self.data.upper())

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

    # Create the server, binding to localhost on port 9999
    server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
    print('Server is running...')
    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    server.serve_forever()

'''
Created on 2016年3月29日
File Name:TCPClient.py
@author: LindenTao
Description : TCPClient
'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import socket
#import sys

HOST, PORT = "localhost", 9999
print('Please input data:')
data = input()
# data = " ".join(sys.argv[1:])

# Create a socket (SOCK_STREAM means a TCP socket)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

try:
    # Connect to server and send data
    sock.connect((HOST, PORT))
    sock.sendall(bytes(data + "\n", "utf-8"))

    # Receive data from the server and shut down
    received = str(sock.recv(1024), "utf-8")
finally:
    sock.close()

print("Sent:     {}".format(data))
print("Received: {}".format(received))

'''
Created on 2016年3月29日
File Name:ThreadedTCPServer.py
@author: LindenTao
Description : 引用socketserver框架的ThreadedTCPServer
'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import socket
import threading
import socketserver

class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):

    def handle(self):
        data = str(self.request.recv(1024), 'ascii')
        cur_thread = threading.current_thread()
        response = bytes("{}: {}".format(cur_thread.name, data), 'ascii')
        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(bytes(message, 'ascii'))
        response = str(sock.recv(1024), 'ascii')
        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()