Python学习总结【第十篇】：Python之Socket编程

Socket简介

　　socket也称为套接字，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过套接字向网络发出请求或者应答网络请求。

　 　socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就 是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

socket和file的区别：

  • file模块是针对某个指定文件进行【打开】【读写】【关闭】
  • socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

while True:
    print 'server waiting...'
    conn,addr = sk.accept()

    client_data = conn.recv(1024)
    print client_data
    conn.sendall('不要回答,不要回答,不要回答')

    conn.close()

socket server
socket server(Python 2.7)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
ip_port = ('127.0.0.1',9999)

sk = socket.socket()
sk.connect(ip_port)

sk.sendall('请求占领地球')

server_reply = sk.recv(1024)
print server_reply

sk.close()

socket client
socket client(Python 2.7)

 Web应用服务（Python 2.7.x）：

#!/usr/bin/env python
#coding:utf-8
import socket
 
def handle_request(client):
    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n")     　　　　　　　　　　# 服务端给客户端返回数据
    client.send("Hello, World")
 
def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    # sock对象
    sock.bind(('localhost',8080))     　　　　　　　　　　　　　　　# 监听本机的8080端口
    sock.listen(5)                             　　　　　　　　　 # 最多接收5个连接
 
    while True:
        connection, address = sock.accept()　　　　　　　　　　　　# 接收客户端请求
        handle_request(connection)
        connection.close()
 
if __name__ == '__main__':
  main()

 浏览器访问查看返回结果：

 Socket类

以下内容基于Python 2.7.x整理

 sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

在创建socket对象的时候一般使用默认即可：sk = socket.socket()

参数一：地址簇

socket.AF_INET IPv4（默认）
socket.AF_INET6 IPv6
 
socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

参数二：类型

socket.SOCK_STREAM　　流式socket , for TCP （默认）
socket.SOCK_DGRAM　　 数据报式socket , for UDP　

参数三：协议

import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)

while True:
    data = sk.recv(1024)
    print data




import socket
ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
    inp = raw_input('数据：').strip()
    if inp == 'exit':
        break
    sk.sendto(inp,ip_port)

sk.close()
UDP案例
0（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

sk.bind(address)
　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
 
sk.listen(backlog)
 
　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
　　backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5，这个值不能无限大，因为要在内核中维护连接队列
 
sk.setblocking(bool)
　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
 
sk.accept()
　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
　　接收TCP 客户的连接（阻塞式）等待连接的到来
 
sk.connect(address)
　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
 
sk.connect_ex(address)
　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
 
sk.close()
　　关闭套接字
 
sk.recv(bufsize[,flag])
　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
 
sk.recvfrom(bufsize[.flag])
　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
 
sk.send(string[,flag])
　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
 
sk.sendall(string[,flag])
　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
    内部通过递归调用send，将所有内容发送出去。
 
sk.sendto(string[,flag],address)
　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
 
sk.settimeout(timeout)
　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为
它们可能用于连接的操作（如 client 连接最多等待5s ）
 
sk.getpeername()
　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
 
sk.getsockname()
　　返回套接字自己的地址。通常是一个元组(ipaddr,port)
 
sk.fileno()
　　套接字的文件描述符　

案例：智能机器人
#!/usr/bin/env python
# -*- coding:utf-8 -*-


import socket

ip_port = ('127.0.0.1',8888)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

while True:
    conn,address =  sk.accept()
    conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
    Flag = True
    while Flag:
        data = conn.recv(1024)
        if data == 'exit':
            Flag = False
        elif data == '0':
            conn.sendall('通过可能会被录音.balabala一大推')
        else:
            conn.sendall('请重新输入.')
    conn.close()
服务端
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket


ip_port = ('127.0.0.1',8005)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)

while True:
    data = sk.recv(1024)
    print 'receive:',data
    inp = raw_input('please input:')
    sk.sendall(inp)
    if inp == 'exit':
        break

sk.close()
客户端

其他常见问题

1）Python3.5.x socket只能收发字节内容，Python2.7可以直接发送字符串

2）客户端服务端如何断开问题：客户端可以主动断开与服务端连接，客户端断开不影响服务端对其他客户端的请求

3）会发生阻塞的函数s.accept() s.recv() (基于客户端服务端链接正常)

4）listen(5)含义
listen(5)  可以链接1个阻塞5个 第7个报错
报错：
Traceback (most recent call last):
  File "E:/开源中国/192.168.21.140/trunk/Python/scripts/S13/s13day09/socket_1/socket_client.py", line 18, in <module>
    sk.connect(ip_port)
ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接

5）黏包问题

6）服务器端口被占用，等待半分钟或者更换一个端口

7）send和sendall区别

send：要发送的内容不一定一次发送完整

sendall：调用send进行数据发送，但是要发送的内容一定会一次发送完整（对send的高级封装方法）

8）recv（1024） 代表一次最多接收1024字节，实际传输过程中可以小于1024字节

黏包问题

某次服务端给客户端回应的请求内容长度超过了每次包的接收大小，需要客户端循环接收信息，直到完整接收信息（难点：客户端如何完整的接收并不发生异常情况）

解决思路：服务端在给客户端发送数据前先给客户端发送本次发送数据包的大小，客户端接收并返回一个已经准备好接收数据包的信号给服务端，服务端开始给客户端发正式数据

# 服务端
#!/usr/bin/env python
# encoding: utf-8

import socket
import subprocess

ip_port = ('127.0.0.1', 9999)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)
while True:
    conn, addr = sk.accept()

    while True:
        try:
            recv_data = conn.recv(1024)
            print("接收%s发送来的数据：%s" % (conn.getpeername()[1], str(recv_data, encoding='utf-8')))
            # send_data = recv_data.upper()
            p = subprocess.Popen(str(recv_data, encoding='utf-8'), shell=True, stdout=subprocess.PIPE)
            res = p.stdout.read()
            if len(res) == 0:
                send_data = 'cmd error'
            else:
                send_data = str(res, encoding='gbk')
　　　　　　　# 给客户端发本次数据包大小 
            recv_tag = "ready|%s" % len(bytes(send_data, encoding='utf-8'))
            conn.send(bytes(recv_tag, encoding='utf-8'))

　　　　　　　# 接收客户端的应答信息，如果内容为start则开始发送数据 
            start_tag = conn.recv(1024)
            if str(start_tag, encoding="utf-8").startswith("start"):
                conn.send(bytes(send_data, encoding='utf-8'))

            print("给%s发送数据：%s" % (conn.getpeername()[1], bytes(send_data, encoding='utf-8')))
            if str(recv_data, encoding='utf-8') == 'exit':
                break
        except Exception:
            break
    conn.close()


# 客户端
#!/usr/bin/env python
# encoding: utf-8

import socket

ip_port = ('127.0.0.1', 9999)
sk = socket.socket()
sk.connect(ip_port)
while True:
    send_data = input(">>：").strip()
    if len(send_data) == 0:
        print("内容不能为空，请重新输入")
        continue
    sk.send(bytes(send_data, encoding="utf-8"))

    # 接收服务端发来的发送信息及获取本次发送数据包的长度 
    recv_tag = sk.recv(1024)      
    recv_tag = str(recv_tag, encoding='utf-8')
    if recv_tag.startswith("ready"):
        send_size = int(recv_tag.split('|')[1])
    # 接收完成服务端发送的传输信息，返回客户端一个标示，说：我已经准备好接收数据包，服务端你可以发送数据包了
    send_tag = bytes("start", encoding="utf-8")
    sk.send(send_tag)

    recv_msg = b''
    recv_size = 0
    # 判断已经接收的数据包的大小是否等于本次发送数据包的大小，如果小于则持续接收数据包
    while recv_size < send_size:
        recv_data = sk.recv(1024)
        recv_msg += recv_data
        recv_size += len(recv_data)
        print("send_size:%s,recv_size:%s" % (send_size, recv_size))

    print(str(recv_msg, encoding='utf-8'))
    if str(recv_data, encoding='utf-8') == "EXIT":
        break
sk.close()

断点续传问题

文件指针：seek(num)

文件打开方式：

  • a：追加（断点续传）
  • w：清空写（覆盖上传/下载）

IO多路复用

　　I/O多路复用指：通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。关于这三种IO多路复用的用法，请参考如下三篇文章：
select：http://www.cnblogs.com/Anker/archive/2013/08/14/3258674.html
poll：http://www.cnblogs.com/Anker/archive/2013/08/15/3261006.html
epoll：http://www.cnblogs.com/Anker/archive/2013/08/17/3263780.html

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多路复用。

Windows Python：
    提供：select
Mac Python:
    提供：select
Linux Python：
    提供：select、poll、epoll

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

 对于select方法：

句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)
 
参数： 可接受四个参数（前三个必须）
返回值：三个列表
 
select方法用来监视文件句柄，如果句柄发生变化，则获取该句柄。
1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中
3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化
   当 超时时间 ＝ 1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import select
import threading
import sys

while True:
    readable, writeable, error = select.select([sys.stdin,],[],[],1)
    if sys.stdin in readable:
        print 'select get stdin',sys.stdin.readline()
利用select监听终端操作实例
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket
import select

sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk1.bind(('127.0.0.1',8002))
sk1.listen(5)
sk1.setblocking(0)

inputs = [sk1,]

while True:
    readable_list, writeable_list, error_list = select.select(inputs, [], inputs, 1)
    for r in readable_list:
        # 当客户端第一次连接服务端时
        if sk1 == r:
            print 'accept'
            request, address = r.accept()
            request.setblocking(0)
            inputs.append(request)
        # 当客户端连接上服务端之后，再次发送数据时
        else:
            received = r.recv(1024)
            # 当正常接收客户端发送的数据时
            if received:
                print 'received data:', received
            # 当客户端关闭程序时
            else:
                inputs.remove(r)

sk1.close()
利用select实现伪同时处理多个Socket客户端请求：服务端
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket

ip_port = ('127.0.0.1',8002)
sk = socket.socket()
sk.connect(ip_port)

while True:
    inp = raw_input('please input:')
    sk.sendall(inp)
sk.close()
利用select实现伪同时处理多个Socket客户端请求：客户端

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

#!/usr/bin/env python
#coding:utf8

'''
 服务器的实现 采用select的方式
'''

import select
import socket
import sys
import Queue

#创建套接字并设置该套接字为非阻塞模式

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setblocking(0)

#绑定套接字
server_address = ('localhost',10000)
print >>sys.stderr,'starting up on %s port %s'% server_address
server.bind(server_address)

#将该socket变成服务模式
#backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
#这个值不能无限大，因为要在内核中维护连接队列

server.listen(5)

#初始化读取数据的监听列表,最开始时希望从server这个套接字上读取数据
inputs = [server]

#初始化写入数据的监听列表，最开始并没有客户端连接进来，所以列表为空

outputs = []

#要发往客户端的数据
message_queues = {}
while inputs:
    print >>sys.stderr,'waiting for the next event'
    #调用select监听所有监听列表中的套接字，并将准备好的套接字加入到对应的列表中
    readable,writable,exceptional = select.select(inputs,outputs,inputs)#列表中的socket 套接字  如果是文件呢？ 
    #监控文件句柄有某一处发生了变化 可写 可读  异常属于Linux中的网络编程 
    #属于同步I/O操作，属于I/O复用模型的一种
    #rlist--等待到准备好读
    #wlist--等待到准备好写
    #xlist--等待到一种异常
    #处理可读取的套接字

    '''
        如果server这个套接字可读，则说明有新链接到来
        此时在server套接字上调用accept,生成一个与客户端通讯的套接字
        并将与客户端通讯的套接字加入inputs列表，下一次可以通过select检查连接是否可读
        然后在发往客户端的缓冲中加入一项，键名为:与客户端通讯的套接字，键值为空队列
        select系统调用是用来让我们的程序监视多个文件句柄(file descrīptor)的状态变化的。程序会停在select这里等待，
        直到被监视的文件句柄有某一个或多个发生了状态改变
        '''

    '''
        若可读的套接字不是server套接字,有两种情况:一种是有数据到来，另一种是链接断开
        如果有数据到来,先接收数据,然后将收到的数据填入往客户端的缓存区中的对应位置，最后
        将于客户端通讯的套接字加入到写数据的监听列表:
        如果套接字可读.但没有接收到数据，则说明客户端已经断开。这时需要关闭与客户端连接的套接字
        进行资源清理
        '''
        
    for s in readable: 
        if s is server:
            connection,client_address = s.accept()
            print >>sys.stderr,'connection from',client_address
            connection.setblocking(0)#设置非阻塞
            inputs.append(connection)
            message_queues[connection] = Queue.Queue()
        else:
            data = s.recv(1024)
            if data:
                print >>sys.stderr,'received "%s" from %s'% \
                (data,s.getpeername())
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                print >>sys.stderr,'closing',client_address
                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                s.close()
                del message_queues[s]
                    
    #处理可写的套接字
    '''
        在发送缓冲区中取出响应的数据，发往客户端。
        如果没有数据需要写，则将套接字从发送队列中移除，select中不再监视
        '''

    for s in writable:
        try:
            next_msg = message_queues[s].get_nowait()

        except Queue.Empty:
            print >>sys.stderr,'  ',s,getpeername(),'queue empty'
            outputs.remove(s)
        else:
            print >>sys.stderr,'sending "%s" to %s'% \
            (next_msg,s.getpeername())
            s.send(next_msg)



    #处理异常情况

    for s in exceptional:
        for s in exceptional:
            print >>sys.stderr,'exception condition on',s.getpeername()
            inputs.remove(s)
            if s in outputs:
                outputs.remove(s)
            s.close()
            del message_queues[s]
基于select实现socket服务端

 13期案例

#!/usr/bin/env python
# encoding: utf-8

"""
@version: v1.0
@author: 杩栋胜
@license: Apache Licence
@contact: 1455975151@qq.com
@site: http://madsstudy.blog.51cto.com/
@software: PyCharm
@file: server.py
@time: 2016/7/10 9:02
"""

import socket
import select

"""
    服务端采用select方式
"""

sk = socket.socket()              # 创建套接字对象
sk.bind(("127.0.0.1", 9999))      # 绑定套接字
sk.listen(5)   # 将该socket变为服务模式，5表示服务器还没有调用accept进行处理的连接个数最大为5，这个值不能无限大，内核要维护连接队列

inputs = [sk, ]  # 初始化读取数据的监听列表，最开始从sk这个套接字上读取数据
outputs = []     # 初始化写如数据的监听列表，最开始并没有客户端连接进来，所以列表为空
messages = {}    # 保存客户端发送过来的消息记录（还没有回复过的）
while True:
    rlist, wlist, e = select.select(inputs, outputs, [], 2)  # 调用select监听所有列表中的套接字，将发生变化的套接字加入对应列表
    # 监听三类事件：可读、可写及异常
    # rlist--被读的socket
    # wlist--被写的socket
    # e--异常的socket
    print(len(inputs), len(rlist), len(wlist), len(outputs))
    for r in rlist:
        if r == sk:
            conn, address = r.accept()
            conn.sendall(bytes("Hello", encoding="utf-8"))
            inputs.append(conn)
            messages[conn] = []  # 为客户端创建一个存储接受信息的列表
        else:
            try:
                data = r.recv(1024)
                if not data:
                    raise Exception("断开连接")
                else:
                    outputs.append(r)   # 标记谁给我发送过消息
                    messages[r].append(data)
            except Exception as e:
                inputs.remove(r)    # 移除移除的客户端，放置下次循环时异常报错
                del messages[r]
    for w in wlist:  # 遍历所有给我发过消息的用户，以此给予回复
        msg = messages[w].pop()
        resp = msg + bytes('response', encoding='utf-8')
        w.sendall(resp)
        outputs.remove(w)   # 将回复过信息的用户从列表中移除，防止下次循环重复回复用户
基于select实现的socket服务端
#!/usr/bin/env python
# encoding: utf-8

"""
@version: v1.0
@author: 杩栋胜
@license: Apache Licence
@contact: 1455975151@qq.com
@site: http://madsstudy.blog.51cto.com/
@software: PyCharm
@file: client.py
@time: 2016/7/10 15:13
"""


import socket

s = socket.socket()
s.connect(("127.0.0.1", 9999))
data = s.recv(1024)
print(data.decode("utf-8"))
while True:
    inp = input(">>>:")
    s.sendall(bytes(inp, encoding="utf-8"))
    print(s.recv(1024).decode("utf-8"))
s.close()
基于select实现的socket对应的客户端

SocketServer模块

 　　socketserver内部使用IO多路复用以及"多线程"和"多进程"，从而实现并发处理多个客户端的socket服务端，即：每个客户端请求连接到服务器时，socket服务端都会在服务器端创建一个"线程"或者"进程"专门负责处理当前客户端的所有请求。

ThreadingTCPServer

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

 1、ThreadingTCPServer基础

如何使用ThreadingTCPServer？

  • 自定义一个类并继承SocketServer.BaseRequestHandler类
  • 类中必须定义一个名为handle的方法
  • SocketServer.ThreadingTCPServer调用自定义的类
  • 启动ThreadingTCPServer
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import SocketServer                                              # 导入模块

class MyServer(SocketServer.BaseRequestHandler):  # 定义一个类继承SocketServer.BaseRequestHandler

    def handle(self):    # 定义一个名为handle的方法
        # print self.request,self.client_address,self.server
        conn = self.request
        conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
        Flag = True
        while Flag:
            data = conn.recv(1024)
            if data == 'exit':
                Flag = False
            elif data == '0':
                conn.sendall('通过可能会被录音.balabala一大推')
            else:
                conn.sendall('请重新输入.')


if __name__ == '__main__':
    server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
    server.serve_forever()   # 启动
SocketServer实现服务器
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket


ip_port = ('127.0.0.1',8009)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)

while True:
    data = sk.recv(1024)
    print 'receive:',data
    inp = raw_input('please input:')
    sk.sendall(inp)
    if inp == 'exit':
        break

sk.close()
客户端

2、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方法）

相关源代码参考Python安装路径下的socketserver.py实现

主要类：

BaseServer
TCPServer
ThreadingMixIn
ThreadingTCPServer
BaseRequestHandler
import socket
import threading
import select


def process(request, client_address):
    print request,client_address
    conn = request
    conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
    flag = True
    while flag:
        data = conn.recv(1024)
        if data == 'exit':
            flag = False
        elif data == '0':
            conn.sendall('通过可能会被录音.balabala一大推')
        else:
            conn.sendall('请重新输入.')

sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.bind(('127.0.0.1',8002))
sk.listen(5)

while True:
    r, w, e = select.select([sk,],[],[],1)
    print 'looping'
    if sk in r:
        print 'get request'
        request, client_address = sk.accept()
        t = threading.Thread(target=process, args=(request, client_address))
        t.daemon = False
        t.start()

sk.close()
源码精简

　　如精简代码可以看出，SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西，其实本质上就是在服务器端为每一个客户端创建一个线程，当前线程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）。

ForkingTCPServer

ForkingTCPServer和ThreadingTCPServer的使用和执行流程基本一致，只不过在内部分别为请求者建立 “线程”  和 “进程”。

基本使用：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import SocketServer

class MyServer(SocketServer.BaseRequestHandler):

    def handle(self):
        # print self.request,self.client_address,self.server
        conn = self.request
        conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
        Flag = True
        while Flag:
            data = conn.recv(1024)
            if data == 'exit':
                Flag = False
            elif data == '0':
                conn.sendall('通过可能会被录音.balabala一大推')
            else:
                conn.sendall('请重新输入.')


if __name__ == '__main__':
    server = SocketServer.ForkingTCPServer(('127.0.0.1',8009),MyServer)
    server.serve_forever()
服务端
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket


ip_port = ('127.0.0.1',8009)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)

while True:
    data = sk.recv(1024)
    print 'receive:',data
    inp = raw_input('please input:')
    sk.sendall(inp)
    if inp == 'exit':
        break

sk.close()
客户端

以上ForkingTCPServer只是将 ThreadingTCPServer 实例中的代码：

server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyRequestHandler)
变更为：
server = SocketServer.ForkingTCPServer(('127.0.0.1',8009),MyRequestHandler)

　　SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 os.fork 两个东西，其实本质上就是在服务器端为每一个客户端创建一个进程，当前新创建的进程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）。

源码剖析参考 ThreadingTCPServer

Twisted

Twisted是一个事件驱动的网络框架，其中包含了诸多功能，例如：网络协议、线程、数据库管理、网络操作、电子邮件等。

事件驱动

简而言之，事件驱动分为二个部分：第一，注册事件；第二，触发事件。

自定义事件驱动框架

#!/usr/bin/env python
# -*- coding:utf-8 -*-

# event_drive.py

event_list = []


def run():
    for event in event_list:
        obj = event()
        obj.execute()


class BaseHandler(object):
    """
    用户必须继承该类，从而规范所有类的方法（类似于接口的功能）
    """
    def execute(self):
        raise Exception('you must overwrite execute')
最牛逼的事件驱动框架

用户使用自定义事件驱动框架

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from source import event_drive


class MyHandler(event_drive.BaseHandler):

    def execute(self):
        print 'event-drive execute MyHandler'


event_drive.event_list.append(MyHandler)
event_drive.run()
案例

如上述代码，事件驱动只不过是框架规定了执行顺序，程序员在使用框架时，可以向原执行顺序中注册“事件”，从而在框架执行时可以出发已注册的“事件”。

基于事件驱动socket

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
from twisted.internet import protocol
from twisted.internet import reactor
 
class Echo(protocol.Protocol):
    def dataReceived(self, data):
        self.transport.write(data)
 
def main():
    factory = protocol.ServerFactory()
    factory.protocol = Echo
 
    reactor.listenTCP(8000,factory)
    reactor.run()
 
if __name__ == '__main__':
    main()
案例

程序执行流程：

  • 运行服务端程序
  • 创建Protocol的派生类Echo
  • 创建ServerFactory对象，并将Echo类封装到其protocol字段中
  • 执行reactor的 listenTCP 方法，内部使用 tcp.Port 创建socket server对象，并将该对象添加到了 reactor的set类型的字段 _read 中
  • 执行reactor的 run 方法，内部执行 while 循环，并通过 select 来监视 _read 中文件描述符是否有变化，循环中...
  • 客户端请求到达
  • 执行reactor的 _doReadOrWrite 方法，其内部通过反射调用 tcp.Port 类的 doRead 方法，内部 accept 客户端连接并创建Server对象实例（用于封装客户端socket信息）和 创建 Echo 对象实例（用于处理请求） ，然后调用 Echo 对象实例的 makeConnection 方法，创建连接。
  • 执行 tcp.Server 类的 doRead 方法，读取数据，
  • 执行 tcp.Server 类的 _dataReceived 方法，如果读取数据内容为空（关闭链接），否则，出发 Echo 的 dataReceived 方法
  • 执行 Echo 的 dataReceived 方法

从源码可以看出，上述实例本质上使用了事件驱动的方法 和 IO多路复用的机制来进行Socket的处理。

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from twisted.internet import reactor, protocol
from twisted.web.client import getPage
from twisted.internet import reactor
import time

class Echo(protocol.Protocol):

    def dataReceived(self, data):
        deferred1 = getPage('http://cnblogs.com')
        deferred1.addCallback(self.printContents)

        deferred2 = getPage('http://baidu.com')
        deferred2.addCallback(self.printContents)

        for i in range(2):
            time.sleep(1)
            print 'execute ',i


    def execute(self,data):
        self.transport.write(data)

    def printContents(self,content):
        print len(content),content[0:100],time.time()

def main():

    factory = protocol.ServerFactory()
    factory.protocol = Echo

    reactor.listenTCP(8000,factory)
    reactor.run()

if __name__ == '__main__':
    main()
异步IO操作

更多参考：

https://twistedmatrix.com/trac
http://twistedmatrix.com/documents/current/api/

作业

作业：开发一个支持多用户在线的FTP程序

要求：

  1. 用户加密认证（密码认证及传输都要加密）
  2. 允许同时多用户登录
  3. 每个用户有自己的家目录 ，且只能访问自己的家目录
  4. 对用户进行磁盘配额，每个用户的可用空间不同
  5. 允许用户在ftp server上随意切换目录
  6. 允许用户查看当前目录下文件（执行一些常见的命令 tree hostname ls dir等等）
  7. 允许上传和下载文件，保证文件一致性
  8. 文件传输过程中显示进度条
  9. 附加功能：支持文件的断点续传
  10. 附加功能：离线秒传（查看是否存在md5值一致的文件，直接做文件链接）
  11. 附加功能：客户端可以主动与服务端断开

作业思路：

1）划分功能模块，各个实现攻破

2）定义客户端及服务端发送数据的格式（json便于存取修改）

3）subprocess win返回gbk编码的内容处理 可以在服务端统一转为utf-8格式在发送，客户端就可以不用特殊处理 或者使用try finally

posted @ 2016-06-12 08:53  每天进步一点点！！！  阅读(1363)  评论(0)  编辑  收藏  举报