• Python高级网络编程

    Python 提供了两个级别访问的网络服务。

    • 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。
    • 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

    Socket套接字的概念

    Socket(翻译为套接字)，是操作系统内核中的一个数据结构，它是网络中的节点进行相互通信的门户。它是网络进程的ID。网络通信，归根到底还是进程间的通信（不同计算机上的进程间通信, 又称进程间通信, IP协议进行的主要是端到端通信）。在网络中，每一个节点（计算机或路由）都有一个网络地址，也就是IP地址。两个进程通信时，首先要确定各自所在的网络节点的网络地址。但是，网络地址只能确定进程所在的计算机，而一台计算机上很可能同时运行着多个进程，所以仅凭网络地址还不能确定到底是和网络中的哪一个进程进行通信，因此套接口中还需要包括其他的信息，也就是端口号（PORT）。在一台计算机中，一个端口号一次只能分配给一个进程，也就是说，在一台计算机中，端口号和进程之间是一一对应关系。
    所以，使用端口号和网络地址的组合可以唯一的确定整个网络中的一个网络进程.

    端口号的范围从0~65535，一类是由互联网指派名字和号码公司ICANN负责分配给一些常用的应用程序固定使用的“周知的端口”，其值一般为0~1023, 用户自定义端口号一般大于等于1024, 我比较喜欢用8888

    每一个socket都用一个半相关描述{协议、本地地址、本地端口}来表示；一个完整的套接字则用一个相关描述{协议、本地地址、本地端口、远程地址、远程端口}来表示。socket也有一个类似于打开文件的函数调用，该函数返回一个整型的socket描述符，随后的连接建立、数据传输等操作都是通过socket来实现的。

    流程描述：

    1 服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket
    2 服务器为socket绑定ip地址和端口号
    3 服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开
    4 客户端创建socket
    5 客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket
    6 服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，所谓阻塞即accept()方法一直等到客户端返回连接信息后才返回，开始接收下一个客户端连接请求
    7 客户端连接成功，向服务器发送连接状态信息
    8 服务器accept方法返回，连接成功
    9 客户端向socket写入信息(或服务端向socket写入信息)
    10 服务器读取信息(客户端读取信息)
    11 客户端关闭
    12 服务器端关闭

    Socket 类型

    套接字格式：

    socket(family,type[,protocal]) 

    使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。

    socket类型

    描述

    socket.AF_UNIX

    只能够用于单一的Unix系统进程间通信

    socket.AF_INET

    服务器之间网络通信

    socket.AF_INET6

    IPv6

    socket.SOCK_STREAM

    流式socket , for TCP

    socket.SOCK_DGRAM

    数据报式socket , for UDP

    socket.SOCK_RAW

    原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。

    socket.SOCK_SEQPACKET

    可靠的连续数据包服务

    创建TCP Socket：

    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

    创建UDP Socket：

    s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

    socket类型在Liunx和Python是一样的, 只是Python中的类型都定义在socket模块中, 调用方式socket.SOCK_XXXX

    • 流式socket（SOCK_STREAM） 用于TCP通信

    流式套接字提供可靠的、面向连接的通信流；它使用TCP协议，从而保证了数据传输的正确性和顺序性

    • 数据报socket（SOCK_DGRAM） 用于UDP通信

    数据报套接字定义了一种无连接的服务，数据通过相互独立的报文进行传输，是无序的，并且不保证是可靠、无差错的。它使用数据报协议UDP

    • 原始socket（SOCK_RAW） 用于新的网络协议实现的测试等

    原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以, 其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。

    其他方法：

    1. s.getpeername()
    2. #返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
    3. s.getsockname()
    4. #返回套接字自己的地址。通常是一个元组(ipaddr,port)
    5. s.setsockopt(level,optname,value)
    6. #设置给定套接字选项的值。
    7. s.getsockopt(level,optname[.buflen])
    8. #返回套接字选项的值。
    9. s.settimeout(timeout)
    10. #设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
    11. s.gettimeout()
    12. #返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
    13. s.fileno()
    14. #返回套接字的文件描述符
    15. s.setblocking(flag)
    16. #如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
    17. s.makefile()
    18. #创建一个与该套接字相关连的文件

    socker编程

    简单的客户端服务器TCP连接

    一个简单的回显服务器和客户端模型, 客户端发出的数据, 服务器会回显到客户端的终端上(只是一个简单的模型, 没考虑错误处理等问题)。

    1. #服务器端
    2. #!/usr/bin/env python
    3. # -*- coding:utf-8 -*-
    4.  
    5. import socket   #socket模块
    6. import commands   #执行系统命令模块
    7.  
    8.  
    9. BUF_SIZE = 1024  #设置缓冲区大小
    10. server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
    11. server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  #生成一个新的socket对象
    12. server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  #设置地址复用
    13. server.bind(server_addr)  #绑定地址
    14. server.listen(5)  #监听, 最大监听数为5
    15. while True:
    16.     client, client_addr = server.accept()  #接收TCP连接, 并返回新的套接字和地址
    17.     print 'Connected by', client_addr
    18.     while True :
    19.         data = client.recv(BUF_SIZE)  #从客户端接收数据
    20.         print data
    21.         client.sendall(data)  #发送数据到客户端
    22. server.close()
    23.  
    24. #客户端
    25. #!/usr/bin/env python
    26. # -*- coding:utf-8 -*-
    27.  
    28. import socket
    29.  
    30. BUF_SIZE = 1024  #设置缓冲区的大小
    31. server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
    32. client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  #返回新的socket对象
    33. client.connect(server_addr)  #要连接的服务器地址
    34. while True:
    35.     data = raw_input("Please input some string > ") 
    36.     client.sendall(data)  #发送数据到服务器
    37.     data = client.recv(BUF_SIZE)  #从服务器端接收数据
    38.     print data
    39. client.close()

    带错误处理的客户端服务器TCP连接

    在进行网络编程时, 最好使用大量的错误处理, 能够尽量的发现错误, 也能够使代码显得更加严谨。

    简单的客户端服务器UDP连接

    1. #服务器端
    2. #!/usr/bin/env python
    3. # -*- coding:utf-8 -*-
    4.  
    5. import socket
    6.  
    7. BUF_SIZE = 1024  #设置缓冲区大小
    8. server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
    9. server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  #生成新的套接字对象
    10. server.bind(server_addr)  #套接字绑定IP和端口
    11. while True :
    12.     print "waitting for data"
    13.     data, client_addr = server.recvfrom(BUF_SIZE)  #从客户端接收数据
    14.     print 'Connected by', client_addr, ' Receive Data : ', data
    15.     server.sendto(data, client_addr)  #发送数据给客户端
    16. server.close()
    17.  
    18. #客户端
    19. #!/usr/bin/env python
    20. # -*- coding:utf-8 -*-
    21.  
    22. import socket
    23. import struct
    24.  
    25. BUF_SIZE = 1024  #设置缓冲区
    26. server_addr = ('127.0.0.1', 8888)  #IP和端口构成表示地址
    27. client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  #生成新的套接字对象
    28.  
    29. while True :
    30.     data = raw_input('Please Input data > ')
    31.     client.sendto(data, server_addr)  #向服务器发送数据
    32.     data, addr = client.recvfrom(BUF_SIZE)  #从服务器接收数据
    33.     print "Data : ", data
    34. client.close()

    WEB服务应用案例：

    1. #!/usr/bin/env python
    2. #coding:utf-8
    3. import socket
    4.   
    5. def handle_request(client):
    6.     buf = client.recv(1024)
    7.     client.send("HTTP/1.1 200 OK\r\n\r\n")
    8.     client.send("Hello, World")
    9.   
    10. def main():
    11.     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    12.     sock.bind(('localhost',8080))
    13.     sock.listen(5)
    14.   
    15.     while True:
    16.         connection, address = sock.accept()
    17.         handle_request(connection)
    18.         connection.close()
    19.   
    20. if __name__ == '__main__':
    21.   main()

    IO多路复用

    I/O多路复用指：通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

    Linux中的 select，poll，epoll 都是IO多路复用的机制。

    select
      
    select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。
    select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。
    select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。
    另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。
      
    poll
      
    poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。
    poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。
    另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。
      
    epoll
      
    直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。
    epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。
    epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
    另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

    Python中有一个select模块，其中提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用。

    1. Windows Python：
    2.     提供： select
    3. Mac Python：
    4.     提供： select
    5. Linux Python：
    6.     提供： select、poll、epoll

    注意：网络操作、文件操作、终端操作等均属于IO操作，对于windows只支持Socket操作，其他系统支持其他IO操作，但是无法检测 普通文件操作 自动上次读取是否已经变化。

    对于select方法：

    1. 句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)
    2.   
    3. 参数： 可接受四个参数（前三个必须）
    4. 返回值：三个列表

    select方法用来监视文件句柄，如果句柄发生变化，则获取该句柄。
    1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
    2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中
    3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
    4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化
       当 超时时间 ＝ 1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。

    利用select监听终端操作实例：

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3.  
    4. import select
    5. import threading
    6. import sys
    7.  
    8. while True:
    9.     readable, writeable, error = select.select([sys.stdin,],[],[],1)
    10.     if sys.stdin in readable:
    11.         print 'select get stdin',sys.stdin.readline()

    利用select实现伪同时处理多个socket客户端请求案例。

    服务端：

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3.  
    4. import socket
    5. import select
    6.  
    7. sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    8. sk1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    9. sk1.bind(('127.0.0.1',8002))
    10. sk1.listen(5)
    11. sk1.setblocking(0)
    12.  
    13. inputs = [sk1,]
    14.  
    15. while True:
    16.     readable_list, writeable_list, error_list = select.select(inputs, [], inputs, 1)
    17.     for r in readable_list:
    18.         # 当客户端第一次连接服务端时
    19.         if sk1 == r:
    20.             print 'accept'
    21.             request, address = r.accept()
    22.             request.setblocking(0)
    23.             inputs.append(request)
    24.         # 当客户端连接上服务端之后，再次发送数据时
    25.         else:
    26.             received = r.recv(1024)
    27.             # 当正常接收客户端发送的数据时
    28.             if received:
    29.                 print 'received data:', received
    30.             # 当客户端关闭程序时
    31.             else:
    32.                 inputs.remove(r)
    33.  
    34. sk1.close()

    客户端：

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3. import socket
    4.  
    5. ip_port = ('127.0.0.1',8002)
    6. sk = socket.socket()
    7. sk.connect(ip_port)
    8.  
    9. while True:
    10.     inp = raw_input('please input:')
    11.     sk.sendall(inp)
    12. sk.close()

    此处的Socket服务端相比与原生的Socket，他支持当某一个请求不再发送数据时，服务器端不会等待而是可以去处理其他请求的数据。但是，如果每个请求的耗时比较长时，select版本的服务器端也无法完成同时操作。

    基于select实现socket服务端：

    1. #!/usr/bin/env python
    2. #coding:utf8
    3.  
    4. '''
    5.  服务器的实现 采用select的方式
    6. '''
    7.  
    8. import select
    9. import socket
    10. import sys
    11. import Queue
    12.  
    13. #创建套接字并设置该套接字为非阻塞模式
    14.  
    15. server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    16. server.setblocking(0)
    17.  
    18. #绑定套接字
    19. server_address = ('localhost',10000)
    20. print >>sys.stderr,'starting up on %s port %s'% server_address
    21. server.bind(server_address)
    22.  
    23. #将该socket变成服务模式
    24. #backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
    25. #这个值不能无限大，因为要在内核中维护连接队列
    26.  
    27. server.listen(5)
    28.  
    29. #初始化读取数据的监听列表,最开始时希望从server这个套接字上读取数据
    30. inputs = [server]
    31.  
    32. #初始化写入数据的监听列表，最开始并没有客户端连接进来，所以列表为空
    33.  
    34. outputs = []
    35.  
    36. #要发往客户端的数据
    37. message_queues = {}
    38. while inputs:
    39.     print >>sys.stderr,'waiting for the next event'
    40.     #调用select监听所有监听列表中的套接字，并将准备好的套接字加入到对应的列表中
    41.     readable,writable,exceptional = select.select(inputs,outputs,inputs)#列表中的socket 套接字  如果是文件呢？
    42.     #监控文件句柄有某一处发生了变化 可写 可读  异常属于Linux中的网络编程
    43.     #属于同步I/O操作，属于I/O复用模型的一种
    44.     #rlist--等待到准备好读
    45.     #wlist--等待到准备好写
    46.     #xlist--等待到一种异常
    47.     #处理可读取的套接字
    48.  
    49.     '''
    50.         如果server这个套接字可读，则说明有新链接到来
    51.         此时在server套接字上调用accept,生成一个与客户端通讯的套接字
    52.         并将与客户端通讯的套接字加入inputs列表，下一次可以通过select检查连接是否可读
    53.         然后在发往客户端的缓冲中加入一项，键名为:与客户端通讯的套接字，键值为空队列
    54.         select系统调用是用来让我们的程序监视多个文件句柄(file descrīptor)的状态变化的。程序会停在select这里等待，
    55.         直到被监视的文件句柄有某一个或多个发生了状态改变
    56.         '''
    57.  
    58.     '''
    59.         若可读的套接字不是server套接字,有两种情况:一种是有数据到来，另一种是链接断开
    60.         如果有数据到来,先接收数据,然后将收到的数据填入往客户端的缓存区中的对应位置，最后
    61.         将于客户端通讯的套接字加入到写数据的监听列表:
    62.         如果套接字可读.但没有接收到数据，则说明客户端已经断开。这时需要关闭与客户端连接的套接字
    63.         进行资源清理
    64.         '''
    65.          
    66.     for s in readable:
    67.         if s is server:
    68.             connection,client_address = s.accept()
    69.             print >>sys.stderr,'connection from',client_address
    70.             connection.setblocking(0)#设置非阻塞
    71.             inputs.append(connection)
    72.             message_queues[connection] = Queue.Queue()
    73.         else:
    74.             data = s.recv(1024)
    75.             if data:
    76.                 print >>sys.stderr,'received "%s" from %s'% \
    77.                 (data,s.getpeername())
    78.                 message_queues[s].put(data)
    79.                 if s not in outputs:
    80.                     outputs.append(s)
    81.             else:
    82.                 print >>sys.stderr,'closing',client_address
    83.                 if s in outputs:
    84.                     outputs.remove(s)
    85.                 inputs.remove(s)
    86.                 s.close()
    87.                 del message_queues[s]
    88.                      
    89.     #处理可写的套接字
    90.     '''
    91.         在发送缓冲区中取出响应的数据，发往客户端。
    92.         如果没有数据需要写，则将套接字从发送队列中移除，select中不再监视
    93.         '''
    94.  
    95.     for s in writable:
    96.         try:
    97.             next_msg = message_queues[s].get_nowait()
    98.  
    99.         except Queue.Empty:
    100.             print >>sys.stderr,'  ',s,getpeername(),'queue empty'
    101.             outputs.remove(s)
    102.         else:
    103.             print >>sys.stderr,'sending "%s" to %s'% \
    104.             (next_msg,s.getpeername())
    105.             s.send(next_msg)
    106.  
    107.  
    108.  
    109.     #处理异常情况
    110.  
    111.     for s in exceptional:
    112.         for s in exceptional:
    113.             print >>sys.stderr,'exception condition on',s.getpeername()
    114.             inputs.remove(s)
    115.             if s in outputs:
    116.                 outputs.remove(s)
    117.             s.close()
    118.             del message_queues[s]

    SocketServer模块

    SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。

    即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。

    • socketserver是标准库中的一个高级模块（Python2.x中名为SocketServer）。
      • socketserver的目标是简化创建网络客户端和服务器的代码。（隐藏了实现细节）
      • socketserver是使用类来编写应用程序。
        • 以面向对象的方式处理事务有助于组织数据，以及逻辑性地将功能放在正确的地方。应用程序现在是事件驱动的，这意味着只有在系统中的事件发生时，它们才会工作。
    • socketserver中包含了两种类，一种为服务类（server class），一种为请求处理类（request handle class）。
      • 服务类提供了许多方法：像绑定，监听，运行…… （也就是建立连接的过程）
      • 请求处理类专注于如何处理用户所发送的数据（也就是事务逻辑）。
    • socketserver模块是一个以socket为基础而创建的高级套接字通信模块，它支持客户端请求的多线程和多进程处理。
      • 在原始服务器循环中，我们阻塞等待请求，当接收到请求时就对其提供服务，然后继续等待。
      • 在socketserver的服务器循环中，并非在服务器中创建代码，而是定义一个处理程序，这样当服务器接收到一个传入的请求时，服务器就可以调用你的函数。
    • socketserver模块类

     1、服务类（同步处理请求）

    • class socketserver.TCPServer(server_address, RequestHandlerClass, bind_and_activate=True)
      • 它使用Internet TCP协议，该协议在客户机和服务器之间提供连续的数据流。
      • 如果bind_and_activate为true，构造函数会自动尝试调用server_bind()和server_activate()。
      • 其他参数传递给BaseServer基类。
    • class socketserver.UDPServer(server_address, RequestHandlerClass, bind_and_activate=True)
      • 它使用数据报，这是离散的信息包，可能会无序地到达或在传输中丢失。
      • 参数与TCPServer相同。

    • class socketserver.UnixStreamServer(server_address, RequestHandlerClass, bind_and_activate=True)
      class socketserver.UnixDatagramServer(server_address, RequestHandlerClass, bind_and_activate=True)

      • 这两个不常用的类类似于TCP和UDP类，但使用Unix域套接字；它们在非unix平台上不可用。
      • 参数与TCPServer相同。

    • 这四个类同步处理请求；每个请求必须完成后才能启动下一个请求。
      如果每个请求都需要很长时间才能完成，这是不合适的，因为它需要大量的计算，或者因为它返回大量的数据，而客户机处理起来很慢。
      解决方案是每个请求都创建一个单独的进程或线程来处理；ForkingMixIn和ThreadingMixIn的混合类可以用来支持异步行为。

    • 继承图中有五个类，其中四个表示四种类型的同步服务器
      • 注意UnixDatagramServer派生于UDPServer，而不是UnixStreamServer --- IP和Unix流服务器之间的唯一区别是地址族，这只是在两个Unix服务器类中重复。

    • 服务类具有相同的外部方法和属性，无论它们使用什么网络协议。

     2、请求处理类

    一、socketserver.BaseRequestHandler类

    • 这是所有请求处理程序对象的超类。它定义了接口，如下所示。
      • 一个具体的请求处理程序子类必须定义一个新的handle()方法，并且可以覆盖任何其他方法。
      • 每个请求都会创建一个子类的新实例。

    1、setup()方法

    • 在handle()方法之前调用，以执行所需的任何初始化操作。默认什么也不做。

    2、handle()方法

    • 此方法必须完成为请求提供服务所需的所有工作。默认什么也不做。
    • 它可以使用几个实例属性;请求是self.request;客户端地址是self.client_address;服务器实例是self.server，以防它需要访问每个服务器的信息。
    • self.request的类型因数据报或流服务而不同。
      • 对于流服务，self.request是客户端套接字对象;
      • 对于数据报服务，self.request是一个双元组(客户端发送的数据, 客户端的套接字对象)。

    3、finish()方法

    • 在handle()方法之后调用，执行所需的任何清理操作。默认什么也不做。
    • 如果setup()引发异常，则不会调用此函数。

    二、socketserver模块的StreamRequestHandler类和DatagramRequestHandler类

    • 这两个BaseRequestHandler子类覆盖了setup()和finish()方法，并提供了self.rfile和self.wfile属性。self.rfile和self.wfile分别读取或写入，以获取请求数据或将数据返回给客户机。
    • 两个类的rfile属性都支持io.BufferedIOBase可读的接口,和DatagramRequestHandler.wfile支持io.BufferedIOBase可写接口。
    • python3.6版：StreamRequestHandler.wfile也支持io.BufferedIOBase可写接口。

    3、mix-in(混合)服务类（异步处理请求）

    • 可以使用mix-in类创建每种类型基于进程(Forking)和线程(threading)的服务器。
      • mix-in类：socketserver.ForkingMixIn类每次处理用户连接的时候都会开启新的进程。（多进程）
      • mix-in类：socketserver.ThreadingMixIn类每次处理用户连接的时候都会开启新的线程。（多线程）
    • 四种混合服务类
      • mix-in类排在第一位，因为它覆盖了UDPServer中定义的方法。设置各种属性还会更改底层服务器机制的行为。
      • ForkingMixIn和Forking类只在支持fork()的POSIX平台上可用。
    1. #socketserver.ForkingTCPServer
    2. class ForkingTCPServer(ForkingMixIn, TCPServer):
    3.     pass
    4.  
    5. #socketserver.ForkingUDPServer
    6. class ForkingUDPServer(ForkingMixIn, UDPServer):
    7.     pass
    8.  
    9. #socketserver.ThreadingTCPServer
    10. class ThreadingTCPServer(ThreadingMixIn, TCPServer):
    11.     pass
    12.  
    13. #socketserver.ThreadingUDPServer
    14. class ThreadingUDPServer(ThreadingMixIn, UDPServer):
    15.     pass
    • socketserver.ForkingMixIn.server_close()会等待所有子进程完成，除非socketserver.ForkingMixIn.block_on_close属性为false。
    • socketserver.ThreadingMixIn.server_close()会等待所有非守护线程完成，除非socketserver.ThreadingMixIn.block_on_close属性为false。通过将ThreadingMixIn.daemon_threads设置为True来使用守护线程，这样就不会等待线程完成。
    • python3.7：socketserver.ForkingMixIn.server_close()和socketserver.ThreadingMixIn.server_close()现在会等待所有子进程和非守护线程完成。添加一个新的socketserver.ForkingMixIn.block_on_close类属性来选择加入3.7之前的行为。

    4、创建服务器需的步骤

    1. 创建一个请求处理类(request handler class)，合理选择StreamRequestHandler和DatagramRequestHandler之中的一个作为父类（当然也可以使用BaseRequestHandler作为父类），并重写它的handle()方法，此方法将处理传入的请求。。
    2. 实例化一个服务类(server class)对象，并将服务器地址和之前创建的请求处理类传递给它。(建议在with语句中实例化服务类)
    3. 调用服务类对象的handle_request()或serve_forever()方法来处理一个或多个请求。
    4. 调用server_close()关闭套接字(除非使用with语句)。
    • socketserver请求处理程序的默认行为是接受连接、获取请求，然后关闭连接。由于这个原因，我们不能在应用程序整个执行过程中都保持连接，因此每次向服务器发送消息时，都需要创建一个新的套接字。

    socketserver实现服务器

    1. python3创建TCP服务器和客户端

    • 事件包括消息的发送和接收。事实上，类定义只包括一个用来接收客户端消息的事件处理程序。所有其他的功能都来自使用的SocketServer类。
    • 最后一行代码通常是一个服务器的无限循环，它等待并响应客户端的服务请求。

    示例1：实例化服务类时不使用with语句

    • 创建SocketServer TCP服务器
      • 多个客户端连接到服务器时，服务器只能按照客户端连接的顺序（即等待队列中的顺序）依次处理，否则将阻塞。
    1. ###python3.8
    2. #!/usr/bin/env python
    3. from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
    4. from time import ctime
    5.  
    6. HOST = ''
    7. PORT = 21567
    8. ADDR = (HOST, PORT)
    9.  
    10. class MyRequesHandler(SRH):                                                    #创建一个请求处理类
    11.     def handle(self):                                                          #重写handle()方法
    12.         self.data = str(self.request.recv(1024).strip(), 'utf8')               #接收客户端发来的数据
    13.         print('...connected from:', self.client_address)
    14.         print(self.data)
    15.         self.request.sendall(bytes('%s %s' % (self.data, ctime()), 'utf8'))    #处理数据，并发送给客户端
    16.  
    17. TCP.request_queue_size = 10                      #默认等待队列中可以有5个客户端，即最大可以连接6个客户端，request_queue_size = 5
    18. tcpServ = TCP(ADDR, MyRequesHandler)             #实例化一个服务类对象。会创建一个套接字，并绑定地址和监听
    19. print('waiting for connection...')
    20. tcpServ.serve_forever()                          #处理客户端发来的请求，其实就是调用handle()方法
    • 创建SocketServer TCP客户端
    1. ###python3.8
    2. #!/usr/bin/env python
    3. from socket import *
    4.  
    5. HOST = 'localhost'
    6. PORT = 21567
    7. BUFSIZ = 1024
    8. ADDR = (HOST, PORT)
    9.  
    10. while True:
    11.     tcpClisock = socket(AF_INET, SOCK_STREAM)
    12.     tcpClisock.connect(ADDR)
    13.     data = input('> ')
    14.     if not data:
    15.         break
    16.     tcpClisock.send(bytes(data,'utf8'))
    17.     data = tcpClisock.recv(BUFSIZ)
    18.     if not data:
    19.         break
    20.     print(str(data.strip(),'utf8'))
    21.     tcpClisock.close()

    示例2：实例化服务类时使用with语句

    • 创建SocketServer TCP服务器
      • 多个客户端连接到服务器时，服务器只能按照客户端连接的顺序（即等待队列中的顺序）依次处理，否则将阻塞。
    1. ###python3.8
    2. #!/usr/bin/env python
    3. import socketserver
    4.  
    5. class MyTCPHandler(socketserver.BaseRequestHandler):
    6.     def handle(self):
    7.         self.data = self.request.recv(1024).strip()
    8.         print("{} wrote:".format(self.client_address[0]))
    9.         print(self.data)
    10.         self.request.sendall(self.data.upper())
    11.  
    12. if __name__ == "__main__":
    13.     HOST, PORT = "localhost", 21567
    14.     with socketserver.TCPServer((HOST, PORT), MyTCPHandler) as server:
    15.         server.serve_forever()
    • 创建SocketServer TCP客户端
    1. ###python3.8
    2. #!/usr/bin/env python
    3. import socket
    4. import sys
    5.  
    6. HOST, PORT = "localhost", 21567
    7. while True:
    8.     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    9.         sock.connect((HOST, PORT))
    10.         data = input('>')
    11.         if not data:
    12.             break
    13.         sock.sendall(bytes(data + "\n", "utf-8"))
    14.         received = str(sock.recv(1024), "utf-8")
    15.     print("Sent:     {}".format(data))
    16.     print("Received: {}".format(received))

    2.  python2创建TCP服务器和客户端

    • 创建SocketServer TCP服务器
    1. ###python2.7
    2. #!/usr/bin/env python
    3. from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
    4. from time import ctime
    5.  
    6. HOST = ''
    7. PORT = 21567
    8. ADDR = (HOST, PORT)
    9.  
    10. class MyRequesHandler(SRH):
    11.     def handle(self):
    12.         print '...connected from:',self.client_address
    13.         self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
    14.  
    15. tcpServ = TCP(ADDR, MyRequesHandler)
    16. print 'waiting for connection...'
    17. tcpServ.serve_forever()
    • 创建SocketServer TCP客户端
    1. ###python2.7
    2. #!/usr/bin/env python
    3. from socket import *
    4.  
    5. HOST = 'localhost'
    6. PORT = 21567
    7. BUFSIZ = 1024
    8. ADDR = (HOST, PORT)
    9.  
    10. while True:
    11.     tcpClisock = socket(AF_INET, SOCK_STREAM)
    12.     tcpClisock.connect(ADDR)
    13.     data = raw_input('> ')
    14.     if not data:
    15.         break
    16.     tcpClisock.send('%s\r\n' % data)
    17.     data = tcpClisock.recv(BUFSIZ)
    18.     if not data:
    19.         break
    20.     print data.strip()
    21.     tcpClisock.close()

    3.  服务类创建UDP服务器

    • 创建SocketServer UDP服务器
      • 多个客户端连接到服务器时，服务器收到一个请求处理一个请求，不会阻塞。
    1. ###python3.8
    2. #!/usr/bin/env python
    3. import socketserver
    4.  
    5. class MyUDPHandler(socketserver.BaseRequestHandler):
    6.     def handle(self):
    7.         #print(self.request)    #(b'221\n', <socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 21567)>)
    8.         data = self.request[0].strip()
    9.         socket = self.request[1]
    10.         print("{} wrote:".format(self.client_address[0]))
    11.         print(data)
    12.         socket.sendto(data.upper(), self.client_address)
    13.  
    14. if __name__ == "__main__":
    15.     HOST, PORT = "localhost", 21567
    16.     with socketserver.UDPServer((HOST, PORT), MyUDPHandler) as server:
    17.         server.serve_forever()
    • 创建SocketServer UDP客户端
    1. ###python3.8
    2. #!/usr/bin/env python
    3. import socket
    4.  
    5. HOST, PORT = "localhost", 21567
    6. while True:
    7.     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    8.     data = input('> ')
    9.     if not data:
    10.         break
    11.     sock.sendto(bytes(data + "\n", "utf-8"), (HOST, PORT))
    12.     received = str(sock.recv(1024), "utf-8")
    13.     print("Sent:     {}".format(data))
    14.     print("Received: {}".format(received))

    4. ThreadingTCPServer实现的Socket服务器

    ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。

    1、ThreadingTCPServer基础

    使用ThreadingTCPServer:

    • 创建一个继承自 SocketServer.BaseRequestHandler 的类
    • 类中必须定义一个名称为 handle 的方法
    • 启动ThreadingTCPServer

    创建socketserver服务器：

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3. import SocketServer
    4.  
    5. class MyServer(SocketServer.BaseRequestHandler):
    6.  
    7.     def handle(self):
    8.         # print self.request,self.client_address,self.server
    9.         conn = self.request
    10.         conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
    11.         Flag = True
    12.         while Flag:
    13.             data = conn.recv(1024)
    14.             if data == 'exit':
    15.                 Flag = False
    16.             elif data == '0':
    17.                 conn.sendall('通过可能会被录音.balabala一大推')
    18.             else:
    19.                 conn.sendall('请重新输入.')
    20.  
    21.  
    22. if __name__ == '__main__':
    23.     server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
    24.     server.serve_forever()

     创建socketserver客户端：

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3.  
    4. import socket
    5.  
    6.  
    7. ip_port = ('127.0.0.1',8009)
    8. sk = socket.socket()
    9. sk.connect(ip_port)
    10. sk.settimeout(5)
    11.  
    12. while True:
    13.     data = sk.recv(1024)
    14.     print 'receive:',data
    15.     inp = raw_input('please input:')
    16.     sk.sendall(inp)
    17.     if inp == 'exit':
    18.         break
    19.  
    20. sk.close()

    ThreadingTCPServer源码剖析

    ThreadingTCPServer的类图关系如下：

    内部调用流程为：

    • 启动服务端程序
    • 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
    • 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给 self.RequestHandlerClass
    • 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
    • 当客户端连接到达服务器
    • 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
    • 执行 ThreadingMixIn.process_request_thread 方法
    • 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass()  即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）

    5. mix-in(混合)类创建TCP服务器

    案例一、多线程处理请求（ThreadingMixIn类）

    • 创建SocketServer TCP服务器
      • 多个客户端连接到服务器时，客户端的每个请求服务器都会新创建一个线程进行处理。
    1. ###python3.8
    2. #!/usr/bin/env python
    3. import socketserver
    4.  
    5. class MyTCPHandler(socketserver.BaseRequestHandler):
    6.     def handle(self):
    7.         self.data = self.request.recv(1024).strip()
    8.         print("{} wrote:".format(self.client_address[0]))
    9.         print(self.data)
    10.         self.request.sendall(self.data.upper())
    11.  
    12. if __name__ == "__main__":
    13.     HOST, PORT = "localhost", 21567
    14.     with socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler) as server:    #与同步的相比，几乎没有变化，除了服务类使用了ThreadingTCPServer类
    15.         server.serve_forever()
    • 创建SocketServer TCP客户端
    1. ###python3.8
    2. #!/usr/bin/env python
    3. from socket import *
    4.  
    5. HOST = 'localhost'
    6. PORT = 21567
    7. BUFSIZ = 1024
    8. ADDR = (HOST, PORT)
    9.  
    10. while True:
    11.     tcpClisock = socket(AF_INET, SOCK_STREAM)
    12.     tcpClisock.connect(ADDR)
    13.     data = input('> ')
    14.     if not data:
    15.         break
    16.     tcpClisock.send(bytes(data, 'utf8'))
    17.     data = tcpClisock.recv(BUFSIZ)
    18.     if not data:
    19.         break
    20.     print(str(data.strip(), 'utf8'))
    21.     tcpClisock.close()

    案例二、多进程处理请求（ForkingMixIn类）

    • 创建SocketServer TCP服务器
      • 多个客户端连接到服务器时，客户端的每个请求服务器都会新创建一个进程进行处理。
      • 特别注意：必须运行在unix上。因为Windows不支持fork()，所以ForkingMixIn类在Windows上不可用。
    1. #!/usr/bin/env python
    2. import socketserver
    3.  
    4. class MyTCPHandler(socketserver.BaseRequestHandler):
    5.     def handle(self):
    6.         self.data = self.request.recv(1024).strip()
    7.         print("{} wrote:".format(self.client_address[0]))
    8.         print(self.data)
    9.         self.request.sendall(self.data.upper())
    10.  
    11. if __name__ == "__main__":
    12.     HOST, PORT = '192.168.248.128', 21567
    13.     with socketserver.ForkingTCPServer((HOST, PORT), MyTCPHandler) as server:    #与同步的相比，几乎没有变化，除了服务类使用了ForkingTCPServer类
    14.         server.serve_forever()
    • 创建SocketServer TCP客户端
    1. ###python3.8
    2. #!/usr/bin/env python
    3. from socket import *
    4.  
    5. HOST = '192.168.248.128'
    6. PORT = 21567
    7. BUFSIZ = 1024
    8. ADDR = (HOST, PORT)
    9.  
    10. while True:
    11.     tcpClisock = socket(AF_INET, SOCK_STREAM)
    12.     tcpClisock.connect(ADDR)
    13.     data = input('> ')
    14.     if not data:
    15.         break
    16.     tcpClisock.send(bytes(data, 'utf8'))
    17.     data = tcpClisock.recv(BUFSIZ)
    18.     if not data:
    19.         break
    20.     print(str(data.strip(), 'utf8'))
    21.     tcpClisock.close()

    6. mix-in(混合)类创建UDP服务器

    案例一、多线程处理请求（ThreadingMixIn类）

    • 创建SocketServer UDP服务器
    1. ###python3.8
    2. #!/usr/bin/env python
    3. import socketserver
    4.  
    5. class MyUDPHandler(socketserver.BaseRequestHandler):
    6.     def handle(self):
    7.         #print(self.request)
    8.         data = self.request[0].strip()
    9.         socket = self.request[1]
    10.         print("{} wrote:".format(self.client_address[0]))
    11.         print(data)
    12.         socket.sendto(data.upper(), self.client_address)
    13.  
    14. if __name__ == "__main__":
    15.     HOST, PORT = "localhost", 21567
    16.     with socketserver.ThreadingUDPServer((HOST, PORT), MyUDPHandler) as server:    #区别仅在于服务类是ThreadingUDPServer
    17.         server.serve_forever()
    • 创建SocketServer UDP客户端
    1. ###python3.8
    2. #!/usr/bin/env python
    3. import socket
    4.  
    5. HOST, PORT = "localhost", 21567
    6. while True:
    7.     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    8.     data = input('> ')
    9.     if not data:
    10.         break
    11.     sock.sendto(bytes(data + "\n", "utf-8"), (HOST, PORT))
    12.     received = str(sock.recv(1024), "utf-8")
    13.     print("Sent:     {}".format(data))
    14.     print("Received: {}".format(received))

    案例二、多进程处理请求（ForkingMixIn类）

    创建SocketServer UDP服务器

    • 特别注意：必须运行在unix上。因为Windows不支持fork()，所以ForkingMixIn类在Windows上不可用。
    1. #!/usr/bin/env python
    2. import socketserver
    3.   
    4. class MyUDPHandler(socketserver.BaseRequestHandler):
    5.     def handle(self):
    6.         #print(self.request)
    7.         data = self.request[0].strip()
    8.         socket = self.request[1]
    9.         print("{} wrote:".format(self.client_address[0]))
    10.         print(data)
    11.         socket.sendto(data.upper(), self.client_address)
    12.   
    13. if __name__ == "__main__":
    14.     HOST, PORT = '192.168.248.128', 21567
    15.     with socketserver.ForkingUDPServer((HOST, PORT), MyUDPHandler) as server:    #区别仅在于服务类是ForkingUDPServer
    16.         server.serve_forever()
    • 创建SocketServer UDP客户端
    1. ###python3.8
    2. # !/usr/bin/env python
    3. import socket
    4.  
    5. HOST, PORT = '192.168.248.128', 21567
    6. while True:
    7.     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    8.     data = input('> ')
    9.     if not data:
    10.         break
    11.     sock.sendto(bytes(data + "\n", "utf-8"), (HOST, PORT))
    12.     received = str(sock.recv(1024), "utf-8")
    13.     print("Sent:     {}".format(data))
    14.     print("Received: {}".format(received))
  • 相关阅读:
    OpenCV使用教程-读取视频VideoCapture
    MySQL-数据操作语言（DML）详解
    WorkPlus Meet：高效私有音视频会议，助力多场景协作
    十年来高薪专业变成了它——信息安全
    JavaWeb开发之——数据库相关概念(02)
    【附源码】计算机毕业设计SSM软考刷题系统
    GoF之代理模式
    基于Java+SpringBoot+Thymeleaf+Mysql在线电影院选座订票系统设计与实现
    Linux相关用法（时刻更新）
    AI服装生成，帮你完成服装设计的最后一步
  • 原文地址：https://blog.csdn.net/qq_35029061/article/details/125558269