本文以实例分析了Python中asyncore模块的原理及用法，分享给大家供大家参考。具体分析如下：

asyncore库是python的一个标准库，它是一个异步socket的包装。我们操作网络的时候可以直接使用socket等底层的库，但是asyncore使得我们可以更加方便的操作网络，避免直接使用socket，select，poll等工具时需要面对的复杂。

这个库很简单，包含了一个函数和一个类
* loop()函数
* dispatcher基类
需要注意的是，loop函数是全局的，不是dispatcher的方法

每一个从dispatcher继承的类的对象，都可以看作我们需要处理的一个socket,可以是TCP连接或者UDP，甚至是其它不常用的。使用容易，我们需要定义一个类，它继承dispatcher，然后我们重写（覆盖）一些方法就可以了。

我们需要重写的方法一般都以handle_打头。

class refuse(dispatcher): 
  def handle_accept(): 
    #do nothing ... 
    pass

loop()函数负责检测一个dict，dict中保存dispatcher的实例，这个字典被称为channel。每次创建一个dispatcher对象，都会把自己加入到一个默认的dict里面去（当然也可以自己指定channel）。当对象被加入到channel中的时候，socket的行为都已经被定义好，程序只需要调用loop()，一切功能就实现了。

asyncore是python标准库中的一个良好的设计
在python的标准文档中，有一个asyncore的例子

import asyncore, socket 
class http_client(asyncore.dispatcher): 
  def __init__(self, host, path): 
    asyncore.dispatcher.__init__(self) 
    self.create_socket(socket.AF_INET, socket.SOCK_STREAM) 
    self.connect( (host, 80) ) 
    self.buffer = 'GET %s HTTP/1.0\r\n\r\n' % path 
  def handle_connect(self): 
    pass
  def handle_close(self): 
    self.close() 
  def handle_read(self): 
    print self.recv(8192) 
  def writable(self): 
    return (len(self.buffer) > 0) 
  def handle_write(self): 
    sent = self.send(self.buffer) 
    self.buffer = self.buffer[sent:] 
c = http_client('www.python.org', '/') 
asyncore.loop()

运行这个函数，发现python.org的首页被下载下来了，也就是说我们实现了一个http层的协议？但是我们用的仅仅是socket级别的API…那么来看看这几行代码的奥妙吧！

writable和readable在检测到一个socket可以写入或者检测到数据到达的时候，被调用，并返回一个bool来决定是否handle_read或者handle_write

打开asyncore.py可以看到，dispatcher类中定义的方法writable和readable的定义相当的简单：

def readable(self): 
  return True
def writable(self): 
  return True

就是说，一旦检测到可读或可写，就直接调用handle_read/handle_write，但是在上面的例子中，我们却看到了一个重载（看上去像C++的虚函数，不是吗？）

def writable(self): 
  return (len(self.buffer) > 0)

很明显，当我们有数据需要发送的时候，我们才给writable的调用者返回一个True，这样就不需要在handle_write中再做判断了，逻辑很明确，代码很清晰，美中不足的是理解需要一点时间，但是不算困难吧！

其余的代码看起来就很清晰了，有一种兵来将挡的感觉。当一个http服务器发送处理完成你的请求，close socket的时候，我们的handle_close()也相应完成自己的使命。close()将对象自身从channel中删除，并且负责销毁socket对象。

def close(self): 
  self.del_channel() 
  self.socket.close()

loop()函数检测到一个空的channel，将退出循环，程序完成任务，exit。

 

 

 

 

在Python中，既可直接使用socket类，也可使用socketserver，asyncore等经过封装的类来进行编码。当然最佳方式还是twisted

《Python.In.A.Nutshell》19章第2节有关于socketserver的详细讲解，现在重点讨论asyncore，这个由Python提供的Asynchronous socket handler

输入命令pydoc asyncore就可看到该模块的文档说明，第一行就开宗明义的说明了该模块的作用:

This module provides the basic infrastructure for writing asynchronous socket service clients and servers. 

通过阅读整个文档，知道该模块是事件驱动(event-driver)。主要方法是loop()，用于进行网络事件的循环。而类dispatcher用于进行网络交互事件。不能直接Instance，需要通过继承并在__init__中显式的声明。它封装了网络的读写事件，并通过readable()和writable()来进行事件进行控制。

打开asyncore.py(Win32在其Python安装目录的lib下，Linux则在/usr/lib/python2.x下)，可以看见readable()和writable()很简单，没有做任何判断，直接返回True。这都需要我们overload以控制流程及状态，然后在handle_read()和handle_write()进行网络数据的读写发送。在帮助手册(17.5.1)里面提供了一个基于http协议的客户端例子，如下：

import asyncore, socket
 
class http_client(asyncore.dispatcher):
    def __init__(self, host, path):
        asyncore.dispatcher.__init__(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect((host, 80))
        self.buffer = 'GET %s HTTP/1.0\r\n\r\n' % path
 
    def handle_connect(self):
        pass
 
    def handle_close(self):
        self.close()
       
    def handle_read(self):
        print self.recv(8192)
 
    def writable(self):
        return (len(self.buffer) > 0)
   
    def handle_write(self):
        sent = self.send(self.buffer)
        self.buffer = self.buffer[sent:]
 
if __name__=='__main__':
    c = http_client('www.chinaunix.net', '/')
    asyncore.loop()
    print 'Program exit'

在例子中，http_client的__init__显式的重载了asyncore.dispatcher。接着创建了一个socket。这里你会感觉到有些奇怪，因为平时我们都是采用如下的格式：
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
......
很明显，create_socket()是asyncore.dispatcher的类成员函数，它为我们实现了上述的功能，从asyncore.py中可以看见它的原型:

   

def create_socket(self, family, type):
        self.family_and_type = family, type
        self.socket = socket.socket(family, type)
        self.socket.setblocking(0)
        self._fileno = self.socket.fileno()
        self.add_channel()

声明了一个类成员变量self.socket，让它等于socket创建出来的描述符，并将其设置为非阻塞，并将其添加到add_channel()中。

接着执行self.connect()函数，该函数很明显被封装过，可以在源码中找到答案。需要注意的是，在说明文档中，有这样的一行话:

handle_connect() Implied by the first write event

当handle_connect()事件发生后，会首先调用write事件，这就不能理解为什么在http_client中，connect()成功后会立刻进入writable()事件，而不是随机的进入readable()事件(当然如果实行的自定义的私有协议，服务器在对于每个连入的客户端都发送一个欢迎信息，那么就需要进行状态控制，先进行读事件)。

默认的writable()直接返回True，这里进行了重载，用于对缓冲区进行判断。当发现缓冲区不为0时，就会返回True，直到缓冲区变成0，才返回False。当writable()返回True的时候，就会触发handle_write()。该函数使用send()发送数据，并检查每一次send的长度，以便对缓冲区进行截取，留下未发送完的数据。这样writable()检查到缓冲区还有数据，又会返回True，触发handle_write()，直到把缓冲区的数据全部送完。

   

def writable(self):
        return (len(self.buffer) > 0)
 
    def handle_write(self):
        sent = self.send(self.buffer)
        self.buffer = self.buffer[sent:]

打开源码看看self.send()的实现:

   

def send(self, data):
        try:
            result = self.socket.send(data)
            return result
        except socket.error, why:
            if why[0] == EWOULDBLOCK:
                return 0
            else:
                raise
            return 0

可见self.send()并没有一个循环数据发送动作，只是简单的调用socket.send()，并捕获出现的异常。该函数不保证将数据的完整发送，只会返回发送了多少。这就需要靠我们自己在外面调用时来完成(循环数据发送在异步的socket I/O里是很常见的)。

例子中并没有重载readable()，意味着在每个时间轮询间隔，都允许触发handle_read()事件。这次采用的是self.recv()函数来完成对http报文的接受。打开源码看看self.recv()的实现:

  

def recv(self, buffer_size):
        try:
            data = self.socket.recv(buffer_size)
            if not data:
                # a closed connection is indicated by signaling
                # a read condition, and having rece() return 0.
                self.handle_close()
                return ''
            else:
                return data
        except socket.error, why:
            # winsock sometimes throws ENOTCONN
            if why[0] in [ECONNRESET, ENOTCONN, ESHUTDOWN]:
                self.handle_close()
                return ''
            else:
                raise

注意到文档中对于接受和发送缓冲区都有描述:
ac_in_buffer_size 
The asynchronous input buffer size (default 4096). 

ac_out_buffer_size 
The asynchronous output buffer size (default 4096). 
缓冲区的大小是可以显式的更改的。这里直接使用self.recv(8192)就有点随意了，应该从http的头部读出后面的数据的size，然后再进行接受。当然这并不是例子的重点