源码 - 轻量级异步爬虫框架 ruia

前言

在源码剖析 - 公众号采集阅读器 Liuli 一文中提到了 ruia，这篇文章就简单记录一下 ruia。

为啥要看？主要是在阅读 Liuli 的过程中，顺手看了一下 ruia 的仓库，发现代码量很少，其宣传中又强调除爬虫核心功能外的所有功能都通过插件的方式实现，我便对其插件系统的实现感到好奇，是像 Flask 那种动态引入呢？还是其他我不知道的方式？

老规矩，看前先理一下兴趣点，不然一头扎入细节，最后啥也带不走，我主要对以下 2 点感兴趣：

• 1.ruia 的设计架构是怎么样的？

• 2.ruia 如何使用插件系统？

观前提示，ruia 并没有实现插件系统，而是利用中间件的形式来实现所谓的插件，跟我自己理解的插件有所差异。

ruia 设计架构

如果你熟悉 Scrapy，那么 ruia 的使用方式和架构你会非常熟悉，因为我在自己开设的进阶爬虫课里手把手带领大家剖析过 Scrapy 框架的代码，所以我比较熟悉Scrapy，如果你不熟悉，本文你可能会比较懵逼。

ruia 相比于 Scrapy 轻量很多，它没有调度器相关的逻辑，而是直接通过 Spider 完成完整的爬取逻辑，先以一个 Demo 为例，看看 ruia 的基本使用，部分代码如下：

1.  
   class DoubanSpider(Spider):
2.  
       # 爬虫名称
3.  
       name = "DoubanSpider"
4.  
       # 入口url
5.  
       start_urls = ["https://movie.douban.com/top250"]
6.  
       # 爬虫相关配置
7.  
       request_config = {"RETRIES": 3, "DELAY": 0, "TIMEOUT": 20}
8.  
       concurrency = 10
9.  
       # aiohttp config
10.  
        aiohttp_kwargs = {}
11.  
     
12.  
        # 异步方法
13.  
        async def parse(self, response):
14.  
            # 异步阻塞等待
15.  
            html = await response.text()
16.  
            etree = response.html_etree(html=html)
17.  
            pages = ["?start=0&filter="]   [
18.  
                # 通过css选择器，获得需要进一步爬虫的url
19.  
                i.get("href") for i in etree.cssselect(".paginator>a")
20.  
            ]
21.  
            for index, page in enumerate(pages):
22.  
                url = self.start_urls[0]   page
23.  
                # 构建新的请求
24.  
                # 回调方法为parse_item
25.  
                yield self.request(
26.  
                    url=url, metadata={"index": index}, callback=self.parse_item
27.  
                )
28.  
     
29.  
        async def parse_item(self, response):
30.  
            async for item in DoubanItem.get_items(html=await response.text()):
31.  
                yield item
32.  
     
33.  
        async def process_item(self, item: DoubanItem):
34.  
            self.logger.info(item)
35.  
     
36.  
     
37.  
    if __name__ == "__main__":
38.  
        # 启动爬虫
39.  
        DoubanSpider.start()

从上述代码中，通过 Spider 的 start 方法启动爬虫，该方法代码如下：

1.  
   @classmethod
2.  
   def start(
3.  
       cls,
4.  
       middleware: typing.Union[typing.Iterable, Middleware] = None,
5.  
       loop=None,
6.  
       after_start=None,
7.  
       before_stop=None,
8.  
       close_event_loop=True,
9.  
       **spider_kwargs,
10.  
    ):
11.  
        # 获取事件循环
12.  
        loop = loop or asyncio.new_event_loop()
13.  
        # 实例化当前类，即类方法中的spider_ins变量为当前类的实例 - Scrapy也是这样做的
14.  
        spider_ins = cls(middleware=middleware, loop=loop, **spider_kwargs)
15.  
     
16.  
        # 启动事件循环，执行爬虫实例的_start方法
17.  
        spider_ins.loop.run_until_complete(
18.  
            spider_ins._start(after_start=after_start, before_stop=before_stop)
19.  
        )
20.  
        # 关闭事件循环中的异步生成器对象（asynchronous generator）
21.  
        spider_ins.loop.run_until_complete(spider_ins.loop.shutdown_asyncgens())
22.  
        if close_event_loop:
23.  
            # 关闭事件循环
24.  
            spider_ins.loop.close()
25.  
     
26.  
        return spider_ins

从上述代码可知，爬虫的完全流程为：

• 1. 创建事件循环

• 2. 实例化爬虫

• 3. 将爬虫爬取逻辑放入事件循环中异步执行

• 4. 关闭事件循环中异步生成器对象，简单理解即关闭事件循环中的任务

• 5. 关闭事件循环本身

run_until_complete 方法是 asyncio 中比较底层的方法，用于将协程函数或任务对象（task）添加到事件循环中并启动，其基本用法如下：

1.  
   In [1]: import asyncio
2.  
    
3.  
   In [2]: # 定义协程函数
4.  
    
5.  
   In [3]: async def fun(a):
6.  
      ...:         print(a)
7.  
      ...:
8.  
    
9.  
   In [4]: # 调用协程函数，生成一个协程对象，此时协程函数并未执行
10.  
     
11.  
    In [5]: coroutine = fun('hello world')
12.  
     
13.  
    In [6]: # 创建事件循环
14.  
     
15.  
    In [7]: loop = asyncio.get_event_loop()
16.  
     
17.  
    In [8]: # 将协程函数添加到事件循环，并启动
18.  
     
19.  
    In [9]: loop.run_until_complete(coroutine)
20.  
    hello world

关于 Python 事件循环更多信息，可以阅读文档：https://docs.python.org/zh-cn/3/library/asyncio-eventloop.html

从 start 方法可知，爬虫主逻辑其实在_start 方法中，该方法代码比较长，我们拆分来看，首先是添加 signal 的逻辑，相关代码如下：

1.  
   # Add signal
2.  
   for signal in (SIGINT, SIGTERM):
3.  
       try:
4.  
           self.loop.add_signal_handler(
5.  
               signal, lambda: asyncio.ensure_future(self.stop(signal))
6.  
           )
7.  
       except NotImplementedError:
8.  
           self.logger.warning(
9.  
               f"{self.name} tried to use loop.add_signal_handler "
10.  
                "but it is not implemented on this platform."
11.  
            )

上述代码中，将 SIGINT 和 SIGTERM 这两个信号添加当前事件循环中，除了这两个外，SIGKILL 也是我们常见的信号，注意，这 3 个信号只实现于类 Unix 平台，即 Linux、MacOS 中有，Windows 没有，Windows 有自己的一套类似实现。

SIGINT、SIGTERM 和 SIGKILL 作用是啥？

当我们按 ctrl c 来停止进程时，Linux 系统其实就向进程发送 SIGINT 信号，进程接收到 SIGINT 信号后，会停止当前进程，也会停止子进程，注意，SIGINT 信号只能结束前台进程。

在 Linux 中，通过 kill 命令可以干掉某个进程，如果 kill 命令不加任何参数的话，该命令的底层，Linux 系统会向进程发 SIGTERM 信号，注意，当前进程会收到该信号，但子进程不会，即如果进程被 kill 了，那么当前进程的父进程比如是 init，即 PID 为 1 的进程，如果是有用户进程创建出的进程，SIGTERM 是无法关闭的。

对于需要强制关闭的情况，我们会使用 kill -9 来 kill 进程，此时 Linux 会向进程发送 SIGKILL 信号，该信号是无法被捕捉的，进程收到 SIGKILL 信号后，当前进程以及相关的子进程都会被 kill 掉。

为了校验上面我说的是否合理，可以构建一段简单的代码来判断一下，代码如下：

1.  
   import sys
2.  
   import asyncio
3.  
   from signal import SIGINT, SIGTERM
4.  
   import traceback
5.  
    
6.  
   # 不同Python版本不同
7.  
   if sys.version_info >= (3, 9):
8.  
       async_all_tasks = asyncio.all_tasks
9.  
       async_current_task = asyncio.current_task
10.  
    else:
11.  
        async_all_tasks = asyncio.Task.all_tasks
12.  
        async_current_task = asyncio.tasks.Task.current_task
13.  
     
14.  
    async def fun(a):  
15.  
        # 添加信号
16.  
        for signal in (SIGINT, SIGTERM):
17.  
            try:
18.  
                loop.add_signal_handler(
19.  
                    signal, lambda: asyncio.ensure_future(stop(signal))
20.  
                )
21.  
            except Exception as e:
22.  
                traceback.print_exc()
23.  
        await asyncio.sleep(600) 
24.  
     
25.  
    async def stop(_signal):
26.  
        print("Stopping async")
27.  
        # 取消事件循环中所有的任务
28.  
        await cancel_all_tasks()
29.  
        # 关停事件循环
30.  
        loop.stop()
31.  
     
32.  
    async def cancel_all_tasks():
33.  
        tasks = []
34.  
        for task in async_all_tasks():
35.  
            if task is not async_current_task():
36.  
                tasks.append(task)
37.  
                task.cancel()
38.  
        await asyncio.gather(*tasks, return_exceptions=True)
39.  
     
40.  
    coroutine = fun('hello world')
41.  
    loop = asyncio.get_event_loop()
42.  
    loop.run_until_complete(coroutine)

上述代码中，使用 ruia 相似的逻辑弄了一个简单脚本，在 Linux 中运行，然后通过 ctrl c 将其关闭，效果如下图，可以发现 Stopping async 被打印了出来。

回到_start 方法，添加完信号量后，其代码如下：

1.  
   # hook - 爬取前需要执行的逻辑
2.  
   await self._run_spider_hook(after_start)
3.  
    
4.  
   try:
5.  
       # 爬虫主逻辑
6.  
       await self.start_master()
7.  
   finally:
8.  
     
9.  
       # hook - 爬取结束前要执行的逻辑
10.  
        await self._run_spider_hook(before_stop)
11.  
        await self.request_session.close()

先看到 start_master 方法，代码如下：

1.  
   async def start_master(self):
2.  
       """
3.  
       Actually start crawling
4.  
       """
5.  
       # 获得Request类实例对象
6.  
       async for request_ins in self.process_start_urls():
7.  
           # 完成了请求，获得了response和callback方法处理的结果
8.  
           self.request_queue.put_nowait(self.handle_request(request_ins))
9.  
       workers = [
10.  
            # asyncio.ensure_future方法将start_worker协程方法构建成task
11.  
            asyncio.ensure_future(self.start_worker())
12.  
            for i in range(self.worker_numbers)
13.  
        ]
14.  
        for worker in workers:
15.  
            self.logger.info(f"Worker started: {id(worker)}")
16.  
     
17.  
        # 阻塞至队列中所有的元素都被接收和处理完毕
18.  
        await self.request_queue.join()
19.  
     
20.  
        if not self.is_async_start:
21.  
            await self.stop(SIGINT)
22.  
        else:
23.  
            if self.cancel_tasks:
24.  
                await self.cancel_all_tasks()

start_master 方法有两大块逻辑，一块是构建异步任务逻辑，一块是并发执行构建好的异步任务。一步步看一下，先看 process_start_urls 方法，代码如下：

1.  
   async def process_start_urls(self):
2.  
       for url in self.start_urls:
3.  
           # 获得Request类实例
4.  
           yield self.request(url=url, callback=self.parse, metadata=self.metadata)

process_start_urls 方法的作用就是 start_urls 列表中填写的 url 构建成 Request 类对象，此时并没有完成对网页数据的请求，这里需要注意的是 callback 参数，直接使用 parse 方法作为 callback 的值。

请求的具体逻辑在 handle_request 方法中，该方法代码如下（只摘取了关键代码展示）：

1.  
   async def handle_request(
2.  
       self, request: Request
3.  
   ) -> typing.Tuple[AsyncGeneratorType, Response]:
4.  
       callback_result, response = None, None
5.  
       await self._run_request_middleware(request)
6.  
       # 完成请求
7.  
       callback_result, response = await request.fetch_callback(self.sem)
8.  
       await self._run_response_middleware(request, response)
9.  
       await self._process_response(request=request, response=response)
10.  
        # response结果
11.  
        return callback_result, response

handle_request 方法中，有中间件效果逻辑的调用，即请求前，通过_run_request_middleware 方法调用相关的中间件逻辑处理请求前的 Request 类实例，请求后是类似的，通过_run_response_middleware 方法处理，最后调用_process_response 方法处理最终的 Reponse 类实例。

看到 fetch_callback 方法，该方法完成了请求并获得了相应的结果。

1.  
   async def fetch_callback(
2.  
       self, sem: Semaphore
3.  
   ) -> Tuple[AsyncGeneratorType, Response]:
4.  
       try:
5.  
           async with sem:
6.  
               # 请求逻辑
7.  
               response = await self.fetch()
8.  
       except Exception as e:
9.  
           response = None
10.  
            self.logger.error(f"<Error: {self.url} {e}>")
11.  
     
12.  
        if self.callback is not None:
13.  
            if iscoroutinefunction(self.callback):
14.  
                # 调用callback方法处理后的结果
15.  
                callback_result = await self.callback(response)
16.  
            else:
17.  
                callback_result = self.callback(response)
18.  
        else:
19.  
            callback_result = None
20.  
        return callback_result, response

fetch_callback 方法其实就一层封装，该方法内通过 fetch 方法完成对网页的请求，通过 callback 方法完成对 response 的处理。

看到 fetch 方法，它调用了_make_request 方法实现请求，然后将请求的结果封装成 Response 类实例，相关代码如下（只展示相关代码）：

1.  
   async def fetch(self, delay=True) -> Response:
2.  
       async with async_timeout.timeout(timeout):
3.  
                   # 发送请求
4.  
                   resp = await self._make_request()
5.  
               try:
6.  
                   resp_encoding = resp.get_encoding()
7.  
               except:
8.  
                   resp_encoding = self.encoding
9.  
               # 使用请求获得的结果构建Response对象
10.  
                response = Response(
11.  
                    url=str(resp.url),
12.  
                    method=resp.method,
13.  
                    encoding=resp_encoding,
14.  
                    metadata=self.metadata,
15.  
                    cookies=resp.cookies,
16.  
                    headers=resp.headers,
17.  
                    history=resp.history,
18.  
                    status=resp.status,
19.  
                    aws_json=resp.json,
20.  
                    aws_text=resp.text,
21.  
                    aws_read=resp.read,
22.  
                )

关键的_make_request 方法其实就是利用 aiohttp 相关的方实现了异步请求，代码如下：

1.  
   async def _make_request(self):
2.  
       self.logger.info(f"<{self.method}: {self.url}>")
3.  
       if self.method == "GET":
4.  
           request_func = self.current_request_session.get(
5.  
               self.url, headers=self.headers, ssl=self.ssl, **self.aiohttp_kwargs
6.  
           )
7.  
       else:
8.  
           request_func = self.current_request_session.post(
9.  
               self.url, headers=self.headers, ssl=self.ssl, **self.aiohttp_kwargs
10.  
            )
11.  
        resp = await request_func
12.  
        return resp

fetch 方法看完后，来看 callback 相关的逻辑，在 spider.py 的 process_start_urls 方法中，callback 参数的入参为 parse 方法，所以这里会调用 parse 方法的逻辑来处理网页返回的数据，而 parse 方法通常会实现在最外部的子类中（我们自己实现对网页的解析逻辑）。

回到 start_master 方法，该方法第一步的逻辑就讲完了，这部分逻辑的效果就是将 callback_reuslt 和 response 添加到了 request_queue 队列中，但需要注意，因为这里是异步操作，所以 requests_queue 是异步对象实例，而不是 callback_reuslt 与 response。

然后看到其第二部分的逻辑，因为第一部分逻辑都是异步操作，第二部分逻辑，主要是并发执行第一部分异步逻辑，然后获得 callback_reuslt 与 response，其主要逻辑实现在 start_worker 方法中。

start_worker 方法代码如下：

1.  
   async def start_worker(self):
2.  
       """
3.  
       Start spider worker
4.  
       :return:
5.  
       """
6.  
       while True:
7.  
           # 获得Request类实例
8.  
           request_item = await self.request_queue.get()
9.  
           # 添加到任务列表中
10.  
            self.worker_tasks.append(request_item)
11.  
            if self.request_queue.empty():
12.  
                # 并发运行 self.worker_tasks 序列中的可等待对象
13.  
                results = await asyncio.gather(
14.  
                    *self.worker_tasks, return_exceptions=True
15.  
                )
16.  
                for task_result in results:
17.  
                    if not isinstance(task_result, RuntimeError) and task_result:
18.  
                        callback_results, response = task_result
19.  
                        if isinstance(callback_results, AsyncGeneratorType):
20.  
                            await self._process_async_callback(
21.  
                                callback_results, response
22.  
                            )
23.  
                self.worker_tasks = []
24.  
            self.request_queue.task_done()

这部分逻辑没啥好讲的，主要就是通过 asyncio.gather 并发执行 worker_tasks 中的任务，然后获得 callback_results 和 response。

在 start_master 方法中，通过 join 方法等待 request_queue 队列中的任务都完成执行。

至此，ruia 中的主逻辑就阅读完了，不太复杂，是学习 Python asyncio 很好的参考代码。

ruia 插件系统

ruia 其实没有设计所谓的插件系统，而是利用中间件的概念来作为所谓的插件，与 scrapy 类似，ruia 中间件会在请求前以及请求后两个时间点调用，在上文的代码中也提及了:_run_request_middleware 方法与_run_response_middleware 方法。

为了进一步理解 ruia 的插件，这里拉取 ruia-ua 项目的代码，该项目是 ruia 作者实现的用于替换请求头中 User-Agent 的插件，使用 ruia-ua 以及 ruia 来爬取 HackerNews 网站数据，代码如下：

1.  
   from ruia import AttrField, TextField, Item, Spider
2.  
   from ruia_ua import middleware
3.  
    
4.  
    
5.  
   class HackerNewsItem(Item):
6.  
       target_item = TextField(css_select='tr.athing')
7.  
       title = TextField(css_select='a.storylink')
8.  
       url = AttrField(css_select='a.storylink', attr='href')
9.  
    
10.  
     
11.  
    class HackerNewsSpider(Spider):
12.  
        start_urls = ['https://news.ycombinator.com/news?p=1', 'https://news.ycombinator.com/news?p=2']
13.  
     
14.  
        async def parse(self, response):
15.  
            # Do something...
16.  
            print(response.url)
17.  
     
18.  
     
19.  
    if __name__ == '__main__':
20.  
        # 使用ruia-ua插件
21.  
        HackerNewsSpider.start(middleware=middleware)

从上述代码可知，所谓使用 ruia-ua 插件，其实就是使用 ruia-ua 提供的中间件。

翻阅 ruia-ua 代码，其中关键的逻辑如下：

1.  
   middleware = Middleware()
2.  
    
3.  
    
4.  
   @middleware.request
5.  
   async def add_random_ua(spider_ins, request):
6.  
       ua = await get_random_user_agent()
7.  
       if request.headers:
8.  
           request.headers.update({'User-Agent': ua})
9.  
       else:
10.  
            request.headers = {
11.  
                'User-Agent': ua
12.  
            }

上述代码很简单，就是用 middleware.request 装饰器处理了 add_random_ua 方法，而 add_random_ua 方法实现了替换 User-Agent 的逻辑。

middleware.request 装饰器的代码在 ruia/middleware.py 中，相关代码如下：

1.  
   def request(self, *args, **kwargs):
2.  
       """
3.  
       Define a Decorate to be called before a request.
4.  
       eg: @middleware.request
5.  
       """
6.  
       middleware = args[0]
7.  
    
8.  
       @wraps(middleware)
9.  
       def register_middleware(*args, **kwargs):
10.  
            self.request_middleware.append(middleware)
11.  
            return middleware
12.  
     
13.  
        return register_middleware()

middleware.request 方法的逻辑也非常简单，就是向 request_middleware 列表中添加相应的方法对象，然后在_run_request_middleware 方法中被调用。

_run_request_middleware 方法的代码如下：

1.  
   async def _run_request_middleware(self, request: Request):
2.  
       if self.middleware.request_middleware:
3.  
           # 顺序调用中间件
4.  
           for middleware in self.middleware.request_middleware:
5.  
               if callable(middleware):
6.  
                   try:
7.  
                       aws_middleware_func = middleware(self, request)
8.  
                       if isawaitable(aws_middleware_func):
9.  
                           await aws_middleware_func
10.  
                        else:
11.  
                            self.logger.error(
12.  
                                f"<Middleware {middleware.__name__}: must be a coroutine function"
13.  
                            )
14.  
                    except Exception as e:
15.  
                        self.logger.exception(f"<Middleware {middleware.__name__}: {e}")

这便是 ruia 中所谓的插件，即利用装饰器，将需要使用的方法添加到某个 list 对象中，在 ruia 请求网站的过程中，在请求前和请求后都给相应 list 对象中的方法调用的机会，从而实现所谓的插件。

结尾

总的来说，ruia 是很好的 Python Asyncio 学习资料，里面关于 asyncio 的用法是可以直接抄，至于其插件系统，其实是中间件的换一种说法，离真正的插件还有差距。

这篇文章就到这，我是二两，下篇文章见。