1.Twisted是用Python实现的基于事件驱动的网络引擎框架。

事件驱动编程是一种编程范式,这里程序的执行流由外部事件来决定。它的特点是包含一个事件循环,当外部事件发生时使用回调机制来触发相应的处理。另外两种常见的编程范式是(单线程)同步以及多线程编程。

from twisted.internet import reactor   # 事件循环(终止条件,所有的socket都已经移除)
from twisted.web.client import getPage # socket对象(如果下载完成,自动从时间循环中移除...)
from twisted.internet import defer # defer.Deferred 特殊的socket对象 (不会发请求,手动移除)
1.利用getPage创建socket
2.将socket添加到事件循环中
3.开始事件循环(无法自动结束)
def response(content):
print(content) @defer.inlineCallbacks
def task():
url = "http://www.baidu.com"
d = getPage(url.encode('utf-8'))
d.addCallback(response)
yield d def done(*args,**kwargs):
reactor.stop()#在这里加上也无法自动结束 task()
reactor.run()
########################
1.利用getPage创建socket
2.将socket添加到事件循环中
3.开始事件循环(自动结束)
def response(content):
print(content) @defer.inlineCallbacks
def task():
url = "http://www.baidu.com"
d = getPage(url.encode('utf-8'))
d.addCallback(response)
yield d def done(*args,**kwargs):
reactor.stop() d = task()
dd = defer.DeferredList([d,])
dd.addBoth(done) reactor.run()

Twisted实现了设计模式中的反应堆(reactor)模式,这种模式在单线程环境中调度多个事件源产生的事件到它们各自的事件处理例程中去。

在异步版的URL获取器中,reactor.run()启动reactor事件循环。

Twisted的核心就是reactor事件循环。Reactor可以感知网络、文件系统以及定时器事件。它等待然后处理这些事件,从特定于平台的行为中抽象出来,并提供统一的接口,使得在网络协议栈的任何位置对事件做出响应都变得简单。

2.Deferred对象以抽象化的方式表达了一种思想,即结果还尚不存在。它同样能够帮助管理产生这个结果所需要的回调链。当从函数中返回时,Deferred对象承诺在某个时刻函数将产生一个结果。返回的Deferred对象中包含所有注册到事件上的回调引用,因此在函数间只需要传递这一个对象即可,跟踪这个对象比单独管理所有的回调要简单的多。

Deferred对象创建时包含两个添加回调的阶段。第一阶段,addCallbacks将response添加到归属的回调链中。然后addBoth再将done同时添加到这两个回调链上。

# 1.利用getPage创建socket
# 2.将socket添加到事件循环中
# 3.开始事件循环(自动结束)
def response(content):
print(content) @defer.inlineCallbacks
def task():
url = "http://www.baidu.com"
d = getPage(url.encode('utf-8'))
d.addCallback(response)
yield d
url = "http://www.baidu.com"
d = getPage(url.encode('utf-8'))
d.addCallback(response)
yield d def done(*args,**kwargs):
reactor.stop() li = []
for i in range(10):
d = task()
li.append(d)
dd = defer.DeferredList(li)
dd.addBoth(done)
reactor.run()
#########################
# 1.利用getPage创建socket
# 2.将socket添加到事件循环中
# 3.开始事件循环(自动结束)
def response(content):
print(content) @defer.inlineCallbacks
def task():
url = "http://www.baidu.com"
d1 = getPage(url.encode('utf-8'))
d1.addCallback(response) url = "http://www.baidu.com"
d2 = getPage(url.encode('utf-8'))
d2.addCallback(response) url = "http://www.baidu.com"
d3 = getPage(url.encode('utf-8'))
d3.addCallback(response)
yield defer.Deferred() def done(*args,**kwargs):
reactor.stop() d=task()
dd = defer.DeferredList([d,])
dd.addBoth(done)
reactor.run()

3.自定义scrapy框架

from twisted.internet import reactor   # 事件循环(终止条件,所有的socket都已经移除)
from twisted.web.client import getPage # socket对象(如果下载完成,自动从时间循环中移除...)
from twisted.internet import defer # defer.Deferred 特殊的socket对象 (不会发请求,手动移除) class Request(object):
def __init__(self,url,callback):
self.url = url
self.callback = callback class HttpResponse(object):
def __init__(self,content,request):
self.content = content
self.request = request
self.url = request.url
self.text = str(content,encoding='utf-8') class ChoutiSpider(object):
name = 'chouti'
def start_requests(self):
start_url = ['http://www.baidu.com','http://www.bing.com',]
for url in start_url:
yield Request(url,self.parse) def parse(self,response):
print('-----response----->',response) #response是下载的页面
yield Request('http://www.cnblogs.com',callback=self.parse)
#1 crawling移除
#2 获取parse yield值
#3 再次去队列中获取 import queue
Q = queue.Queue() class Engine(object):
def __init__(self):
self._close = None
self.max = 5
self.crawlling = [] def get_response_callback(self,content,request):
self.crawlling.remove(request)
rep = HttpResponse(content,request)
result = request.callback(rep)#content和request
# print(result)#<generator object ChoutiSpider.parse at 0x000001F694A2C9E8>
import types
if isinstance(result,types.GeneratorType):
for req in result:
# print('-------------->',req)
Q.put(req) def _next_request(self):
"""
去取request对象,并发送请求
最大并发数限制
:return:
"""
print('---->request',self.crawlling,Q.qsize())
if Q.qsize() == 0 and len(self.crawlling) == 0:
self._close.callback(None)
return if len(self.crawlling) >= self.max:
return
while len(self.crawlling) < self.max:
try:
req = Q.get(block=False)
self.crawlling.append(req)
d = getPage(req.url.encode('utf-8'))
# 页面下载完成,get_response_callback,调用用户spider中定义的parse方法,并且将新请求添加到调度器
d.addCallback(self.get_response_callback,req)
# 未达到最大并发数,可以再去调度器中获取Request
d.addCallback(lambda _:reactor.callLater(0, self._next_request))
except Exception as e:
# print(e)
return @defer.inlineCallbacks
def crawl(self,spider):
# 将初始Request对象添加到调度器
start_requests = iter(spider.start_requests())
while True:
try:
request = next(start_requests)
Q.put(request)
except StopIteration as e:
break # 去调度器中取request,并发送请求
# self._next_request()
reactor.callLater(0, self._next_request)
self._close = defer.Deferred()
yield self._close spider = ChoutiSpider()
_active = set()
engine = Engine()
d = engine.crawl(spider)
_active.add(d) dd = defer.DeferredList(_active)
dd.addBoth(lambda _:reactor.stop())
reactor.run()

4. 根据源码重写engine

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):
"""
用于封装用户请求相关信息
"""
def __init__(self,url,callback):
self.url = url
self.callback = callback class HttpResponse(object):
def __init__(self,content,request):
self.content = content
self.request = request class Scheduler(object):
"""
任务调度器
"""
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):
"""
引擎:所有调度
"""
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):
if self.scheduler.size() == 0 and len(self.crawlling) == 0:
self._close.callback(None)
return 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):
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):
"""
用户封装调度器以及引擎的...
"""
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)
yield engine.start() class CrawlerProcess(object):
"""
开启事件循环
"""
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 Commond(object):
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 = Commond()
cmd.run()

@defer.inlineCallbacks是一个装饰器并用来装饰生成器函数.inlineCallbacks 的主要的目的就是把一个生成器变成一系列的异步的callbacks.

当我们调用一个用inlineCallbacks 修饰的函数的时候,我们不需要调用下一个或者发送或者抛出我们自己.这个装饰器会帮我们完成这些并会确保我们的生成器会一直运行到底(假设它并没有抛出异常).

一个被inlineCallbacks修饰的函数会返回deferred.因为我们不知道生成器什么时候会停止运行,这个被修饰过的函数是一个异步的函数,最适合返回的是deferred.注意这个返回的deferred 不是yield 语句返回的deferred,它是这个生成器全部运行完毕之后才触发的deferred.

使用了callLater 在一段时间之后去触发deferred.这是一个很方便的把非阻塞的延迟放入callback 链的方法,一般来说,在我们的生成器中我们会不断的返回一个已经被触发过的deferred.

以上代码执行以下连个spider。

from engine import Request
class ChoutiSpider(object): name = 'chouti' def start_requests(self):
start_url = ['http://www.baidu.com','http://www.bing.com',]
for url in start_url:
yield Request(url,self.parse) def parse(self,response):
print(response) #response是下载的页面
yield Request('http://www.cnblogs.com',callback=self.parse)

spider1

from engine import Request
class CnblogsSpider(object): name = 'cnblogs' def start_requests(self):
start_url = ['http://www.cnblogs.com',]
for url in start_url:
yield Request(url,self.parse) def parse(self,response):
print(response) #response是下载的页面
yield Request('http://www.cnblogs.com',callback=self.parse)

spider2

Twisted使用和scrapy源码剖析的更多相关文章

  1. Python twisted事件驱动网络框架 源码剖析

    一.Twisted简介 Twisted是一个事件驱动的网络框架,其中包含了诸多功能,例如:网络协议.线程.数据库管理.网络操作.电子邮件等. 事件驱动简而言之,事件驱动分为二个部分:第一,注册事件:第 ...

  2. jQuery之Deferred源码剖析

    一.前言 大约在夏季,我们谈过ES6的Promise(详见here),其实在ES6前jQuery早就有了Promise,也就是我们所知道的Deferred对象,宗旨当然也和ES6的Promise一样, ...

  3. Nodejs事件引擎libuv源码剖析之:高效线程池(threadpool)的实现

    声明:本文为原创博文,转载请注明出处. Nodejs编程是全异步的,这就意味着我们不必每次都阻塞等待该次操作的结果,而事件完成(就绪)时会主动回调通知我们.在网络编程中,一般都是基于Reactor线程 ...

  4. Apache Spark源码剖析

    Apache Spark源码剖析(全面系统介绍Spark源码,提供分析源码的实用技巧和合理的阅读顺序,充分了解Spark的设计思想和运行机理) 许鹏 著   ISBN 978-7-121-25420- ...

  5. 基于mybatis-generator-core 1.3.5项目的修订版以及源码剖析

    项目简单说明 mybatis-generator,是根据数据库表.字段反向生成实体类等代码文件.我在国庆时候,没事剖析了mybatis-generator-core源码,写了相当详细的中文注释,可以去 ...

  6. STL"源码"剖析-重点知识总结

    STL是C++重要的组件之一,大学时看过<STL源码剖析>这本书,这几天复习了一下,总结出以下LZ认为比较重要的知识点,内容有点略多 :) 1.STL概述 STL提供六大组件,彼此可以组合 ...

  7. SpringMVC源码剖析(四)- DispatcherServlet请求转发的实现

    SpringMVC完成初始化流程之后,就进入Servlet标准生命周期的第二个阶段,即“service”阶段.在“service”阶段中,每一次Http请求到来,容器都会启动一个请求线程,通过serv ...

  8. 自己实现多线程的socket,socketserver源码剖析

    1,IO多路复用 三种多路复用的机制:select.poll.epoll 用的多的两个:select和epoll 简单的说就是:1,select和poll所有平台都支持,epoll只有linux支持2 ...

  9. Java多线程9:ThreadLocal源码剖析

    ThreadLocal源码剖析 ThreadLocal其实比较简单,因为类里就三个public方法:set(T value).get().remove().先剖析源码清楚地知道ThreadLocal是 ...

随机推荐

  1. Android Static分析

    1.static的变量或者方法会放在内存的一个方法区内 2.static变量会在该变量所属的类从内存中释放掉之后. 才会释放掉而类释放的条件是非常苛刻的. 必需要该类相应的全部对象被释放掉. 同一时候 ...

  2. 495A - Digital Counter

    A. Digital Counter time limit per test 1 second memory limit per test 256 megabytes input standard i ...

  3. POJ 3616 Milking Time DP题解

    典型的给出区间任务和效益值,然后求最大效益值的任务取法. 属于一维DP了. 一维table记录的数据含义:到当前任务的截止时间前的最大效益值是多少. 注意. 这表示当前任务一定要选择,可是终于结果是不 ...

  4. hdu 5635 LCP Array(BC第一题)

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5635 LCP Array Time Limit: 4000/2000 MS (Java/Others) ...

  5. 自学Zabbix2.6-zabbix升级

    如果你从zabbix 1.6升级到1.8或者zabbix 1.8升级到zbbix 2.0,那么你需要额外执行sql文件(path.sql): 但是在2.0之后这些步骤都不需要手动做,如果你的版本很低, ...

  6. springMVC学习总结(一)快速入门

    springMVC学习总结(一)快速入门 一.初步认识 springMVC执行流程 主要组件 DispatcherServlet(中央控制器) 配置在web.xml中的前端控制器,客户端请求的入口,调 ...

  7. dubbo服务治理中间件,zookeeper注册中心

    对传统项目架构进行拆分: 集群概念: 面向服务分布式架构: 服务层提供被注册的对象需要实现序列化接口Serializable: 配置表现层和服务层: 依赖包: 服务层: <!-- 定义dubbo ...

  8. SpringBoot学习笔记

    SpringBoot个人感觉比SpringMVC还要好用的一个框架,很多注解配置可以非常灵活的在代码中运用起来: springBoot学习笔记: .一.aop: 新建一个类HttpAspect,类上添 ...

  9. 引言关于本博客的ES6

    本博客ES6全部取自于阮一峰的<ES6标准入门>里面掺杂着一些node.js,写这些东西是为了让大家更好的去理解这本书,其实更像是一个教材参考,里面有一些是阮一峰先生可能没有考虑到新手的某 ...

  10. S7-200以太网通信

    一.西门子网络系统 二.s7-200通过以太网模块接入以太网 三.S7-200可以接入的以太网系统 四.S7-200以太网通讯实验 五.实验硬件系统组成 六.S7-200作为服务器的配置 1.进入以太 ...