Scrapy框架的执行流程解析

这里主要介绍七个大类
Command->CrawlerProcess->Crawler->ExecutionEngine->sceduler
另外还有两个类：Request和HttpRessponse

执行流程

1.首先通过Command类中的run方法
(1).创建开始运行的命令
(2).将每一个spider对象的路径传入到crawl_process.crawl方法中去
(3).crawl_process.crawl方法创建一个Crawler对象,通过调用Crawler.crawl方法创建一个引擎和spider对象
(4).通过引擎的open_spider方法创建一个Scheduler对象，将每一个spider对象加入到schedler队列中去，并且通过自身的_next_request方法对下一次请求进行调度
(5).调用CrawlerProcess对象的start方法开始事件循环
2.CrawlerProcess类：
初始值：创建一个集合_active，用于存放每一个请求的socket对象
crawl方法：创建一个Crawler对象，调用Crawler.crawl方法，传入spider对象的路径（Crawler.crawl方法的作用是将传入的spider对象的路径通过调用_create_spider方法，
创建一个spider对象，通过_create_engine方法创建一个引擎，通过调用引擎中的open_spider方法将spider对象的start_reuqests请求加入到scheduler调度器中的
队列当中，然后调用引擎的中的_next_request方法对下一个请求进行调度。然后yield一个引擎的start方法，start方法返回的是一个defer.Defered对象，
不发送任何请求，需要手动停止，目的是为了夯住事件循环)并将返回的scoket的对象加入到集合中
start方法：将该socket对象的集合加到到defer.DeferedList中去，并添加回调函数进行手动停止。开始事件循环

3.Crawler类：用户封装引擎及spider对象
_create_engine方法:创建一个引擎
_create_spider:通过传入的spider对象的路径创建spider对象
crawl:调用_create_engine方法创建engine,调用_create_spider方法去打开spider对象，对spider中的start_requests请求转化为迭代器，通过调用engine.open_spider方法
调用next函数将每一个请求加入到调度器中的队列中去，并调用engine._next_request方法对下一次请求进行调度
4.ExecutionEngine类：
引擎：所有的调度
初始值：self._close = None:用于存放一个defer。defered对象， self.scheduler = None用于创建一个队列
self.max = 5设置最大并发数 self.crawlling = []创建一个正在执行请求的列表
open_spider方法:
1.创建一个调度器对象,将传入的start_requests请求通过next方法将每一个请求加入到队列当中去
2.然后开始事件循环执行_next_request方法对下一次请求的调度
注：每一个@defer.inlineCallbacks装饰的函数都必须yield一个对象，即使为None
_next_request方法:
1.对spider对象的请求进行调度
2.设置事件循环终止条件：调度器队列中请求的个数为0，正在执行的请求数为0
3.设置最大并发数，根据正在执行的请求数量满足最大并发数条件对sceduler队列中的请求进行调度执行，并将返回的请求加入到正在执行的列表中
4.包括对请求进行下载，以及对返回的数据执行callback函数
5.开始执行事件循环的下一次请求的调度
get_response_callback方法：
1.将返回数据的请求从正在执行的列表中移出
2.将返回的数据调用HttpResponse封装成一个response对象，执行请求的callback函数，并判断如果callback函数返回的结果是一个生成器对象，则将该生成器
中的每一个对 象加入到调度器中的队列中去
start方法：不发送任何请求，需要手动停止，目的是为了夯住循环
5.Scheduler类：任务调度器
1.初始化一个队列
2.next_request方法：读取队列中的下一个请求
3.enqueue_request方法：将请求加入到队列
4.size方法：返回当前队列请求的数量
5.open方法：无任何操作，返回一个空值，用于引擎中用装饰器装饰的open_spider方法返回一个yield对象

6.Resquet类：用于封装用户请求相关信息，供用户编写spider时发送请求所用，主要的两个参数：url和callback
7.HttpResponse类：
通过响应请求返回的数据和穿入的request对象封装成一个response对象
目的是为了将请求返回的数据不仅包括返回的content数据，使其拥有更多的属性，比如请求头，请求url，请求的cookies等等
更方便的被回调函数所解析有用的数据

下面是根据自己的理解写的一个小型的scrapy框架：

from twisted.internet import reactor   # 事件循环（终止条件，所有的socket都已经移除）
from twisted.web.client import getPage # socket对象（如果下载完成，自动从时间循环中移除...）
from twisted.internet import defer     # defer.Deferred 特殊的socket对象 （不会发请求，手动移除）
from queue import Queue


class Request(object):
    """
    用于封装用户请求相关信息，供用户编写spider时发送请求所用
    """
    def __init__(self,url,callback):
        self.url = url
        self.callback = callback


class HttpResponse(object):
    """
    通过响应请求返回的数据和穿入的request对象封装成一个response对象
    目的是为了将请求返回的数据不仅包括返回的content数据，使其拥有更多的属性，比如请求头，请求url，请求的cookies等等
    更方便的被回调函数所解析有用的数据
    """
    def __init__(self,content,request):
        self.content = content
        self.request = request
        self.url = request.url
        self.text = str(content,encoding='utf-8')


class Scheduler(object):
    """
    任务调度器:
    1.初始化一个队列
    2.next_request方法：读取队列中的下一个请求
    3.enqueue_request方法：将请求加入到队列
    4.size方法：返回当前队列请求的数量
    5.open方法：无任何操作，返回一个空值，用于引擎中用装饰器装饰的open_spider方法返回一个yield对象
    """
    def __init__(self):
        self.q = Queue()

    def open(self):
        pass

    def next_request(self):
        try:
            req = self.q.get(block=False)
        except Exception as e:
            req = None
        return req

    def enqueue_request(self,req):
        self.q.put(req)

    def size(self):
        return self.q.qsize()


class ExecutionEngine(object):
    """
    引擎：所有的调度
    1.通过open_spider方法将start_requests中的每一个请求加入到scdeuler中的队列当中，
    2.处理每一个请求响应之后的回调函数（get_response_callback)和执行下一次请求的调度(_next_request)
    """
    def __init__(self):
        self._close = None
        self.scheduler = None
        self.max = 5
        self.crawlling = []

    def get_response_callback(self,content,request):
        self.crawlling.remove(request)
        response = HttpResponse(content,request)
        result = request.callback(response)
        import types
        if isinstance(result,types.GeneratorType):
            for req in result:
                self.scheduler.enqueue_request(req)

    def _next_request(self):
        """
        1.对spider对象的请求进行调度
        2.设置事件循环终止条件：调度器队列中请求的个数为0，正在执行的请求数为0
        3.设置最大并发数，根据正在执行的请求数量满足最大并发数条件对sceduler队列中的请求进行调度执行
        4.包括对请求进行下载，以及对返回的数据执行callback函数
        5.开始执行事件循环的下一次请求的调度
        """
        if self.scheduler.size() == 0 and len(self.crawlling) == 0:
            self._close.callback(None)
            return
        """设置最大并发数为5"""
        while len(self.crawlling) < self.max:
            req = self.scheduler.next_request()
            if not req:
                return
            self.crawlling.append(req)
            d = getPage(req.url.encode('utf-8'))
            d.addCallback(self.get_response_callback,req)
            d.addCallback(lambda _:reactor.callLater(0,self._next_request))

    @defer.inlineCallbacks
    def open_spider(self,start_requests):
        """
        1.创建一个调度器对象
        2.将start_requests中的每一个请求加入到scheduler队列中去
        3.然后开始事件循环执行下一次请求的调度
        注：每一个@defer.inlineCallbacks装饰的函数都必须yield一个对象，即使为None
        """
        self.scheduler = Scheduler()
        yield self.scheduler.open()
        while True:
            try:
                req = next(start_requests)
            except StopIteration as e:
                break
            self.scheduler.enqueue_request(req)
        reactor.callLater(0,self._next_request)

    @defer.inlineCallbacks
    def start(self):
        """不发送任何请求，需要手动停止，目的是为了夯住循环"""
        self._close = defer.Deferred()
        yield self._close


class Crawler(object):
    """
    1.用户封装调度器以及引擎
    2.通过传入的spider对象的路径创建spider对象
    3.创建引擎去打开spider对象，对spider中的每一个请求加入到调度器中的队列中去，通过引擎对请求去进行调度
    """
    def _create_engine(self):
        return ExecutionEngine()

    def _create_spider(self,spider_cls_path):
        """

        :param spider_cls_path:  spider.chouti.ChoutiSpider
        :return:
        """
        module_path,cls_name = spider_cls_path.rsplit('.',maxsplit=1)
        import importlib
        m = importlib.import_module(module_path)
        cls = getattr(m,cls_name)
        return cls()

    @defer.inlineCallbacks
    def crawl(self,spider_cls_path):
        engine = self._create_engine()
        spider = self._create_spider(spider_cls_path)
        start_requests = iter(spider.start_requests())
        yield engine.open_spider(start_requests) #将start_requests中的每一个请求加入到调度器的队列中去，并有引擎调度请求的执行
        yield engine.start() #创建一个defer对象，目的是为了夯住事件循环，手动停止


class CrawlerProcess(object):
    """
    1.创建一个Crawler对象
    2.将传入的每一个spider对象的路径传入Crawler.crawl方法
    3.并将返回的socket对象加入到集合中
    4.开始事件循环
    """
    def __init__(self):
        self._active = set()

    def crawl(self,spider_cls_path):
        """
        :param spider_cls_path:
        :return:
        """
        crawler = Crawler()
        d = crawler.crawl(spider_cls_path)
        self._active.add(d)

    def start(self):
        dd = defer.DeferredList(self._active)
        dd.addBoth(lambda _:reactor.stop())

        reactor.run()


class Command(object):
    """
    1.创建开始运行的命令
    2.将每一个spider对象的路径传入到crawl_process.crawl方法中去
    3.crawl_process.crawl方法创建一个Crawler对象,通过调用Crawler.crawl方法创建一个引擎和spider对象
    4.通过引擎的open_spider方法创建一个scheduler对象，将每一个spider对象加入到schedler队列中去，并且通过自身的_next_request方法对下一次请求进行调度
    5.
    """
    def run(self):
        crawl_process = CrawlerProcess()
        spider_cls_path_list = ['spider.chouti.ChoutiSpider','spider.cnblogs.CnblogsSpider',]
        for spider_cls_path in spider_cls_path_list:
            crawl_process.crawl(spider_cls_path)
        crawl_process.start()


if __name__ == '__main__':
    cmd = Command()
    cmd.run()