爬虫之scrapy框架
一、scrapy框架介绍
1、介绍
Scrapy，Python开发的一个快速、高层次的屏幕抓取和web抓取框架，用于抓取web站点并从页面中提取结构化的数据。Scrapy用途广泛，可以用于数据挖掘、监测和自动化测试。
Scrapy吸引人的地方在于它是一个框架，任何人都可以根据需求方便的修改。它也提供了多种类型爬虫的基类，如BaseSpider、sitemap爬虫等，最新版本又提供了web2.0爬虫的支持。
Scrap，是碎片的意思，这个Python的爬虫框架叫Scrapy。
Scrapy 是基于twisted框架开发而来，twisted是一个流行的事件驱动的python网络框架。因此Scrapy使用了一种非阻塞（又名异步）的代码来实现并发。
2、scrapy架构图
1. 这是官方给出的架构图
2. 各个组件的作用
引擎(Engine)
引擎负责控制数据流在系统中所有组件中流动，并在相应动作发生时触发事件。
调度器(Scheduler)
用来接收引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 相当于一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
下载器(Downloader)
用于下载网页内容, 并将网页内容返回给EGINE，下载器是建立在twisted这个高效的异步模型上的
下载器中间件(Downloader middlewares)
下载器中间件是在引擎及下载器之间的特定钩子(specific hook)，处理Downloader传递给引擎的response（也包括引擎传递给下载器的Request）。 其提供了一个简便的机制，通过插入自定义代码来扩展Scrapy功能。
爬虫(Spiders)
Spider是Scrapy用户编写用于分析response并提取item(即获取到的item)或额外跟进的URL的类。 每个spider负责处理一个特定(或一些)网站
爬虫中间件(Spider middlewares)
Spider中间件是在引擎及Spider之间的特定钩子(specific hook)，处理spider的输入(response)和输出(items及requests)。 其提供了一个简便的机制，通过插入自定义代码来扩展Scrapy功能。
项目管道(Item Pipeline)
Item Pipeline负责处理被spider提取出来的item。典型的处理有清理、 验证及持久化(例如存取到数据库中)。
3、scrapy框架的基本流程
0. 程序开始运行 1. Spiders用yeild将url发送给Engine(引擎) 2. Engine把url发送给调度器(Scheduler) 3. 调度器(Scheduler)会将url生成request返回给Engine(引擎) 4. Engine(引擎)拿到request，通过下载器中间件(Downloader middlewares)进行层层过滤发送给下载器(Downloader) 5. 下载器(Downloader)在网上获取到response数据之后，又经过下载器中间件(Downloader middlewares)进行层层过滤发送给Engine(引擎) 6. Engine(引擎)获取到response数据之后，返回给Spiders，Spiders的parse()方法对获取到的response数据进行处理，解析出items或者requests 7. 将解析出来的items或者requests发送给Engine(引擎) 8. Engine(引擎)获取到items或者requests，将items发送给Item Pipeline进行数据的存储 9. 注意，只有当调度器中不存在任何request了，整个程序才会停止，也就是说，对于下载失败的URL，Scrapy也会重新下载
4、scrapy框架中间件
# 下载器中间件Downloader Middleware 1. process_request(request, spider) 当每个request通过下载中间件时，该方法被调用，这里可以修改UA，代理，Refferer 2. process_response(request, response, spider) 下载结果经过中间件时被此方法处理 3. process_exception(request, exception, spider) 下载过程中出现异常时被调用，这里可以处理超时 # 爬虫中间件Spider Middleware SpiderMiddleware主要处理解析Item的相关逻辑修正，比如数据不完整要添加默认，增加其他额外信息等 0. process_start_requests(start_requests, spider): 当spider发出请求时,被调用。 # Scheduler是scrapy官方结构图中的组件 运行流程：Spiders --> process_start_requests --> Scheduler 1. process_spider_input(response, spider) """参数 response(Response对象) - 被处理的response spider(Spider对象) - 该response对应的spider """ 当response通过spider中间件时，该方法被调用，处理该response。 # Downloader和Spiders是scrapy官方结构图中的组件，即上面那张图 运行流程：Downloader --> process_spider_input--> Spiders 2. process_spider_output(response, result, spider) """参数 response(Response对象) - 生成该输出的response result(包含Reques或Item对象的可迭代对象(iterable)) - spider返回的result spider(Spider对象) - 其结果被处理的spider """ 当Spider处理response返回result时，该方法被调用。 运行流程：Spiders --> process_spider_input--> Item Pipelines 3. process_spider_exception(response, exception, spider) 当spider或(其他spider中间件的) process_spider_input() """参数 response(Response对象) - 异常被抛出时被处理的response exception(Exception对象) - 被抛出的异常 spider(Spider对象) - 抛出异常的spider """ 抛出异常时， 该方法被调用。
二、scrapy的基础
1、安装
1. Linux系统 pip install scrapy # 从官网下载 pip install -i https://pypi.douban.com/simple/ scrapy # 从豆瓣源下载 2. Windows系统 1. pip install -i https://pypi.douban.com/simple/ wheel 2. pip install twisted 3. pip install -i https://pypi.douban.com/simple/ pywin32 4. pip install -i https://pypi.douban.com/simple/ scrapy
2、cmd下的命令行工具
1. 查看帮助 scrapy -h scrapy <command> -h 2. 有两种命令：其中Project-only必须切到项目文件夹下才能执行，而Global的命令则不需要 Global commands: startproject # 创建项目 genspider # 创建爬虫程序 settings # 如果是在项目目录下，则得到的是该项目的配置 runspider # 运行一个独立的python文件，不必创建项目 shell # scrapy shell url地址 在交互式调试，如选择器规则正确与否 fetch # 独立于程单纯地爬取一个页面，可以拿到请求头 view # 下载完毕后直接弹出浏览器，以此可以分辨出哪些数据是ajax请求 version # scrapy version 查看scrapy的版本，scrapy version -v查看scrapy依赖库的版本 Project-only commands: crawl # 运行爬虫，必须创建项目才行，确保配置文件中ROBOTSTXT_OBEY = False check # 检测项目中有无语法错误 list # 列出项目中所包含的爬虫名 edit # 编辑器，一般不用 parse # scrapy parse url地址 --callback 回调函数 #以此可以验证我们的回调函数是否正确 bench # scrapy bentch压力测试 3. 官网链接 https://docs.scrapy.org/en/latest/topics/commands.html
3、目录结构
project_name/ scrapy.cfg project_name/ __init__.py items.py middlewares.py pipelines.py settings.py spiders/ __init__.py 爬虫1.py 爬虫2.py 爬虫3.py 文件说明： scrapy.cfg 项目的主配置信息，用来部署scrapy时使用，爬虫相关的配置信息在settings.py文件中。 items.py 设置数据存储模板，用于结构化数据，如：Django的Model middlewares.py 中间件是处于引擎(crawler.engine)和下载器(crawler.engine.download())之间的一层组件 pipelines 数据处理行为，如：一般结构化的数据持久化 settings.py 配置文件，如：递归的层数、并发数，延迟下载等。强调:配置文件的选项必须大写否则视为无效 spiders 爬虫目录，如：创建文件，编写爬虫规则 注意： 1、一般创建爬虫文件时，以网站域名命名 2、默认只能在终端执行命令，为了更便捷操作： # 在项目根目录下新建：entrypoint.py from scrapy.cmdline import execute execute(['scrapy', 'crawl', 'qsbk', '--nolog'])
如何在pycharm中运行scrapy程序
1、一般创建爬虫文件时，以网站域名命名 2、默认只能在终端执行命令，为了更便捷操作： # 在项目根目录下新建：entrypoint.py from scrapy.cmdline import execute execute(['scrapy', 'crawl', 'qsbk', '--nolog'])
4、Spider主爬虫程序类
Spiders是定义如何抓取某个站点（或一组站点）的类，包括如何执行爬行（即跟随链接）以及如何从其页面中提取结构化数据（即抓取项目）。换句话说，Spiders是为特定站点（或者在某些情况下，一组站点）爬网和解析页面定义自定义行为的地方。 1. 生成初始的Requests来爬取第一个URLS，并且标识一个回调函数 第一个请求定义在start_requests()方法内默认从start_urls列表中获得url地址来生成Request请求， 默认的回调函数是parse方法。回调函数在下载完成返回response时自动触发 2. 在回调函数中，解析response并且返回值 返回值可以4种： 包含解析数据的字典 Item对象 新的Request对象（新的Requests也需要指定一个回调函数） 或者是可迭代对象（包含Items或Request） 3. 在回调函数中解析页面内容 通常使用Scrapy自带的Selectors，但很明显你也可以使用Beutifulsoup，lxml或其他你爱用啥用啥。 4. 最后，针对返回的Items对象将会被持久化到数据库 通过Item Pipeline组件存到数据库：https://docs.scrapy.org/en/latest/topics/item-pipeline.html#topics-item-pipeline） 或者导出到不同的文件（通过Feed exports：https://docs.scrapy.org/en/latest/topics/feed-exports.html#topics-feed-exports）
5、Scrapy自带的选择器Selectors(xpath)
使用Scrapy自带的选择器，获取到的数据都是Selectors对象， 需要使用extract方法把Selectors对象的内容提取出来。 1,div.xpath('.//div[@class="author clearfix"]/a/h2/text()') 结果是Selector对象组成的列表：[<Selector xpath='xxx' data='xxx'>,] 2,div.xpath('.//div[@class="author clearfix"]/a/h2/text()').extract() 把Selector对象的内容提取出来，还是列表：['data的内容',] 3,div.xpath('.//div[@class="author clearfix"]/a/h2/text()').extract()[0] 把提取出来的列表按索引取出某一个值，若只提取一个，也可以使用extract_first() div.xpath('.//div[@class="author clearfix"]/a/h2/text()').extract_first() 4,div.xpath('.//div[@class="author clearfix"]/a/h2/text()')[0].extract() 先在列表中取出某个Selector对象，在把Selector对象的内容提取出来
6、DupeFilter(去重)
1. 默认使用方式 DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter' Request(...,dont_filter=False) # 如果dont_filter=True则告诉Scrapy这个URL不参与去重。 2. 自定义去重规则 from scrapy.dupefilter import RFPDupeFilter，看源码，仿照BaseDupeFilter # 步骤一：在项目目录下自定义去重文件dup.py class UrlFilter(object): def __init__(self): self.visited = set() # 或者放到数据库 @classmethod def from_settings(cls, settings): return cls() def request_seen(self, request): if request.url in self.visited: return True self.visited.add(request.url) def open(self): # can return deferred pass def close(self, reason): # can return a deferred pass def log(self, request, spider): # log that a request has been filtered pass
三、scrapy的小Demo
1、创建并执行爬虫应用程序
1. 在cmd下输入命令 cd 工作目录 scrapy startproject 项目名 # 创建项目 cd 项目名 scrapy genspider 应用名称 爬取的起始url # 创建爬虫程序 scrapy crawl 应用名称 # 该种执行形式会显示执行的日志信息 scrapy crawl 应用名称 --nolog # 该种执行形式不会显示执行的日志信息 scrapy crawl 应用名称 -o xxx.xml # 存储数据文本格式 2. 示例 # 爬取糗事百科 cd E:\SpiderProject\爬虫\scrapy框架 # 进入工作目录 scrapy startproject QSBK # 创建一个名为QSBK的项目 cd QSBK # 进入项目目录 scrapy genspider qsbk www.qiushibaike.com # 创建爬虫程序(会在项目下的spiders目录下创建qsbk.py程序) scrapy crawl qsbk # 执行应用程序 scrapy crawl qsbk -o qsbk.xml # 将爬取到的数据解析后存储成xml格式的文件 3.spiders目录下创建的qsbk.py程序 # -*- coding: utf-8 -*- import scrapy class QsbkSpider(scrapy.Spider): name = 'qsbk' # 应用名称 # 允许爬取的域名（如果遇到非该域名的url则爬取不到数据） allowed_domains = ['www.qiushibaike.com'] # 起始爬取的url start_urls = ['http://www.qiushibaike.com/'] # 访问起始URL并获取结果后的回调函数，该函数的response参数就是向起始的url发送请求后，获取的响应对象. # 该函数返回值必须为可迭代对象或者NUll def parse(self, response): print(response.text) # 获取字符串类型的响应内容 print(response.body) # 获取字节类型的响应内容 4. 项目的配置文件(settings.py)相关配置 修改内容及其结果如下： 19行：伪装请求载体身份(伪装成浏览器) USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36' 22行：可以忽略或者不遵守robots协议 ROBOTSTXT_OBEY = False 注意：settings.py的配置项的名称都要大写 5. 爬取糗百首页中文字段子的内容和作者 对qsbk.py进行修改 """ 注意：记得修改settings.py的配置哦！！！ 类QsbkSpider是继承了scrapy.Spider这个类的， scrapy.Spider中的start_requests方法是我们爬虫主逻辑、策略， 因为start_requests方法默认只是做了一些简单的爬取措施， 如果要爬取的网页有了很强的反爬措施，此时就需要我们重写start_requests方法，破解反爬措施。 start_requests方法必须yield Request对象，因此需要导入 from scrapy import Request """ import scrapy from scrapy import Request # from scrapy.http import Request # 跟上面导入的Request是一样的 class QsbkSpider(scrapy.Spider): name = 'qsbk' # 应用名称 # 允许爬取的域名（如果遇到非该域名的url则爬取不到数据） allowed_domains = ['www.qiushibaike.com'] # 起始爬取的url start_urls = ['https://www.qiushibaike.com/text/'] def start_requests(self): # 爬虫主逻辑 策略 yield Request( url="https://www.qiushibaike.com/text/", callback=self.parse, # 定义回调函数，不写默认就是 parse ) def parse(self, response): # 用xpath或者BS或者 css selector进行数据解析 # 这里的response自带xpath方法，可以将xpath表达式直接作用于该函数中 odiv = response.xpath('//div[@id="content-left"]/div') content_list = [] # 用于存储解析到的数据 # xpath函数返回的为列表，列表中存放的数据为Selector类型的数据 # 我们解析到的内容被封装在了Selector对象中，需要调用extract()函数将解析的内容从Selecor中取出 for div in odiv: # 1.获取用户名author author = div.xpath('.//div[@class="author clearfix"]/a/h2/text()') if author: author = author[0].extract() else: author = "匿名用户" # 2.获取这个用户的段子的内容contents contents = div.xpath('.//div[@class="content"]/span/text()') # 遇到换行br就会生成一个Selector对象 content_list.append({ "author": author, "content": "".join([selector.extract().strip() for selector in contents]) }) print("content_list", content_list) return content_list
2、使用BeautifulSoup解析
""" 除了解析代码，其余代码跟上面的例子一样 """
from bs4 import BeautifulSoup
def parse(self, response): print(response.text) soup = BeautifulSoup(response.text, 'lxml') odiv = soup.find_all('div', class_='article') content_list = [] # 用于存储解析到的数据 for div in odiv: author = div.find('div', class_='author').text print(author) content = div.find('div', class_='content').text print(content) dic = { '作者': author, '内容': content } print(dic) # 将数据存储到content_list这个列表中 content_list.append(dic) return content_list
四、爬取亚马逊的iphoneXs商品
1.主爬虫程序 """ 登录亚马逊官方，搜索：iphone xs max 需要解析出来的数据：商品简介、价格、配送方 爬取前10页 注意在settings中设置UA反爬和不遵守robots """ import scrapy from scrapy import Request class AmazonSpider(scrapy.Spider): name = 'amazon' allowed_domains = ['www.amazon.cn'] start_urls = ['https://www.amazon.cn/'] def start_requests(self): yield Request( url="https://www.amazon.cn/s/ref=nb_sb_noss_1?__mk_zh_CN=%E4%BA%9A%E9%A9%AC%E9%80%8A%E7%BD%91%E7%AB%99&url=search-alias%3Daps&field-keywords=iphone+xs+max", callback=self.parse_index, dont_filter=True ) def parse_index(self, response): ''' 解析商品首页获取几十个商品详情的url，发请求 解析函数的返回值： （1） 字典或者迭代数据（比如列表套字典） （2） 请求Request对象 （3） item对象（通过pipeline做持久化的） ''' # 商品列表页的所有商品的URL detail_urls = response.xpath('//*[contains(@id,"result_")]/div/div[3]/div[1]/a/@href').extract() for detail_url in detail_urls: print("detail_url", detail_url) yield Request( url=detail_url, callback=self.parse_detail, # parse_detail解析详情页的函数 dont_filter=True ) # 解析一个下一页的URL，经过测试发现下面xpath解析出来的url是相对路径，因此需要我们拼接出完整的url # response.urljoin方法能帮我们把要爬取的网页域名和需要拼接的url进行拼接 next_url = response.urljoin(response.xpath('//*[@id="pagnNextLink"]/@href').extract_first()) yield Request( url=next_url, callback=self.parse_index, dont_filter=True ) def parse_detail(self, response): ''' response： 某一个商品详情页的响应体 ''' title = response.xpath('//*[@id="productTitle"]/text()')[0].extract().strip() price = response.xpath('//*[@id="priceblock_ourprice"]/text()')[0].extract().strip() delivery = response.xpath('//*[@id="ddmMerchantMessage"]/*[1]/text()').extract() print(title) print(price) print(delivery) 2.免费代理网站 http://www.goubanjia.com/ 3.设置代理池 当你的ip访问亚马逊太过频繁的时候，亚马逊会对你进行反爬(暂封你的ip)， 若你发现无法爬取亚马逊网页的时候，可设置代理池(下面会详细讲，现在先把网页爬下来) 步骤： 1. 在免费代理网站上找一个能用的代理ip 2. 在middlewares.py中找到AmazonDownloaderMiddleware类下的process_request方法 3. 在process_request中写入如下几行 proxy = 'http://77.70.115.104:8080' request.meta['download_timeout'] = 20 request.meta['proxy'] = proxy
五、Item
Item对象是用于收集抓取数据的简单容器。它们提供类似字典的 API，并具有用于声明其可用字段的方便语法。 Scrapy Items类似于Django Models，但是Scrapy Items更简单，因为没有不同字段类型的概念。 1.声明Item 在项目中找到items.py，使用简单的类定义语法和Field对象声明项目 import scrapy class AmazonItem(scrapy.Item): # define the fields for your item here like: title = scrapy.Field() price = scrapy.Field() delivery = scrapy.Field() 2.使用Item # 在需要使用的地方(爬虫主程序)导入这个类 from ..items import AmazonItem # 实例化对象并添加数据 item = AmazonItem() item["title"] = title item["price"] = price item["delivery"] = delivery 3. Demo # 上面亚马逊的parse_detail可以这样写(先实例化再设置数据) def parse_detail(self, response): ''' response： 某一个商品详情页的响应体 ''' title = response.xpath('//*[@id="productTitle"]/text()')[0].extract().strip() price = response.xpath('//*[@id="priceblock_ourprice"]/text()')[0].extract().strip() delivery = response.xpath('//*[@id="ddmMerchantMessage"]/*[1]/text()').extract() print(title) print(price) print(delivery) item = AmazonItem() # 先实例化 item["title"] = title # 再设置数据 item["price"] = price item["delivery"] = delivery return item # 还可以这样写(实例化的时候初始化数据) def parse_detail(self, response): ''' response： 某一个商品详情页的响应体 ''' title = response.xpath('//*[@id="productTitle"]/text()')[0].extract().strip() price = response.xpath('//*[@id="priceblock_ourprice"]/text()')[0].extract().strip() delivery = response.xpath('//*[@id="ddmMerchantMessage"]/*[1]/text()').extract() print(title) print(price) print(delivery) item = AmazonItem(title=title, price=price, delivery=delivery) # 实例化的时候初始化数据 # 获取字段值 print(item['title']) print(item.get('price')) # 访问所有键 print(item.keys()) # 访问所有的键值对 print(item.items()) return item
六、Item PipeLine
在一个项目被蜘蛛抓取之后，它被发送到项目管道，该项目管道通过顺序执行的几个组件处理它。
每个项目管道组件（有时简称为“项目管道”）是一个实现简单方法的Python类。他们收到一个项目并对其执行操作，同时决定该项目是否应该继续通过管道或被丢弃并且不再处理。
项目管道的典型用途是：
cleansing HTML data(清洗数据)
validating scraped data (checking that the items contain certain fields)(校验数据)
checking for duplicates (and dropping them)(去重)
storing the scraped item in a database(排序存储)
PipeLine只接收Item对象，PipeLine在项目中的pipelines.py里面定义。
定义好的PipeLine类需要在settings里面进行声明，只要在主程序中return item就会自动去settings中找到声明的PipeLine类，
然后对item进行处理，存储。
# 大概在settings的67行设置pipeline类， ITEM_PIPELINES = { 'Amazon.pipelines.AmazonPipeline': 300, }
1、编写自己的项目管道
每个项管道组件都是一个以下方法的Python类： # item进入pipeline前会调用这个方法 open_spider(self，蜘蛛) 打开蜘蛛时会调用此方法。 # 必须实现的方法，用来处理item数据的方法(核心方法) process_item(self，项目，蜘蛛) 为每个项目管道组件调用此方法。process_item() 返回带数据的dict，返回一个Item （或任何后代类）对象，返回Twisted Deferred或引发 DropItem异常。丢弃的项目不再由其他管道组件处理。 # item处理完毕后调用这个方法 close_spider(self，蜘蛛) 当蜘蛛关闭时调用此方法。 # 当pipeline类实例化的时候，如果有from_crawler方法会先执行这个方法，再执行init方法 # 参数crawler代表这个爬虫程序，可以在此拿到爬虫的名字、域名、配置参数等，都可以从这里拿到 from_crawler(cls，crawler) 如果存在，则调用此类方法以从a创建管道实例Crawler。它必须返回管道的新实例。Crawler对象提供对所有Scrapy核心组件的访问， 如设置和信号; 它是管道访问它们并将其功能挂钩到Scrapy的一种方式。
2、使用MongoDB存储item
1. settings中的配置 # 与Mongodb数据库相关配置 HOST = "127.0.0.1" PORT = 27017 USER = "root" PWD = "" DB = "amazon" TABLE = "goods" # 声明pipeline类 ITEM_PIPELINES = { 'Amazon.pipelines.MongodbPipeline': 300, } 2. 定义pipeline类 from pymongo import MongoClient class MongodbPipeline(object): def __init__(self, host, port, user, pwd, db, table): self.host = host self.port = port self.user = user self.pwd = pwd self.db = db self.table = table @classmethod def from_crawler(cls, crawler): """ Scrapy会先通过getattr判断我们是否自定义了from_crawler,有则调它来完成实例化 从爬虫程序crawler中的settings配置拿到我们需要的数据，返回给这个类，然后调用init实例化 """ HOST = crawler.settings.get('HOST') PORT = crawler.settings.get('PORT') USER = crawler.settings.get('USER') PWD = crawler.settings.get('PWD') DB = crawler.settings.get('DB') TABLE = crawler.settings.get('TABLE') # 必须返回这个类的对象 return cls(HOST, PORT, USER, PWD, DB, TABLE) def open_spider(self, spider): """ 爬虫刚启动时执行一次 """ # self.client = MongoClient('mongodb://%s:%s@%s:%s' %(self.user,self.pwd,self.host,self.port)) self.client = MongoClient(host=self.host, port=self.port) def close_spider(self, spider): """ 爬虫关闭时执行一次 """ self.client.close() def process_item(self, item, spider): # 操作并进行持久化 d = dict(item) # 把item转换成字典类型 if all(d.values()): # 当字典不为空的时候插入数据 self.client[self.db][self.table].save(d) # save方法也等于插入数据并保存 return item
3、item流向多个pipeline
1. 基于上面的settings再进行配置 # 声明pipeline类 ITEM_PIPELINES = { 'Amazon.pipelines.MongodbPipeline': 300, 'Amazon.pipelines.FilePipeline': 400, } 2. 再定义一个pipeline类 class FilePipeline(object): def open_spider(self, spider): """ 爬虫刚启动时执行一次 """ print("文件写入一个item") # self.client = MongoClient('mongodb://%s:%s@%s:%s' %(self.user,self.pwd,self.host,self.port)) self.file = open("file_pipeline.txt", "w") def close_spider(self, spider): """ 爬虫关闭时执行一次 """ self.file.close() def process_item(self, item, spider): # 操作并进行持久化 d = dict(item) import json self.file.write(json.dumps(d) + "\n") 3. 多个管道的流程 ITEM_PIPELINES = { 'Amazon.pipelines.MongodbPipeline': 300, 'Amazon.pipelines.FilePipeline': 400, } 300和400是权重，设置多少都行，看自己喜好，权重小的管道先执行， 因此MongodbPipeline先执行，执行完毕后，process_item方法必须return item， return item后会把item传给下一个管道FilePipeline进行处理。 如果你想处理完后不再给别人处理了，那么可以 from scrapy.exceptions import DropItem def process_item(self, item, spider): if 某种情况: raise DropItem("Duplicate item found: %s" % item)
七、下载中间件
scrapy的下载中间件个Django的中间件类似， process_request、process_response等方法也是类似的 不同的是： Django中process_request返回一个对象后，process_response是从process_request对应的process_response开始返回， 而scrapy的下载中间件process_request返回一个对象后，process_response是从第一个process_response开始返回， 1. settings中的配置 # 大概在settings的55行 DOWNLOADER_MIDDLEWARES = { 'Amazon.middlewares.MyDownMiddleware': 543, } 2. 权重 process_request权重小的先执行 process_response权重大的先执行 process_request权重小的先执行 3. 各个方法的作用 class MyDownMiddleware(object): def process_request(self, request, spider): """ 请求需要被下载时，经过所有下载器中间件的process_request调用 :param request: :param spider: :return: None,继续后续中间件去下载； Response对象，停止process_request的执行，开始执行process_response Request对象，停止中间件的执行，将Request重新调度 raise IgnoreRequest异常，停止process_request的执行，开始执行process_exception """ pass def process_response(self, request, response, spider): """ spider处理完成，返回时调用 :param response: :param result: :param spider: :return: Response 对象：转交给其他中间件process_response Request 对象：停止中间件，request会被重新调度下载 raise IgnoreRequest 异常：调用Request.errback """ print('response1') return response def process_exception(self, request, exception, spider): """ 当下载处理器(download handler)或 process_request() (下载中间件)抛出异常 :param response: :param exception: :param spider: :return: None：继续交给后续中间件处理异常； Response对象：停止后续process_exception方法 Request对象：停止中间件，request将会被重新调用下载 """ return None 因此我们更换代理的时候，应该放在process_exception中 def process_exception(self, request, exception, spider): # Called when a download handler or a process_request() # (from other downloader middleware) raises an exception. # Must either: # - return None: continue processing this exception # - return a Response object: stops process_exception() chain # - return a Request object: stops process_exception() chain proxy = 'http://77.70.115.104:8080' request.meta['download_timeout'] = 20 request.meta['proxy'] = proxy return request # 返回request，即把请求返回给调度器，调度器再重新去发请求
八、代理池
1、原理
我们跟换代理的时候，应该是在某个代理网站上，把可用的代理全部爬下来，
当出现异常的时候就去代理池中把真正能用的ip跟换到我的程序中，
因此还需要写一个爬代理ip网站的程序，这个不用担心，去github中搜就可以，
把搜到的应用结合到我们的爬虫程序中
2、步骤
1. 把下载到的程序放到我们爬虫程序中 2. 读README.md文件，根据步骤进行一些初始化配置 3. 把爬ip的程序启动后，把爬取到的代理ip存到MongoDB中 [DB] ;Configure the database information ;type: SSDB/MONGODB if use redis, only modify the host port，the type should be SSDB type = MONGODB host = 127.0.0.1 port = 27017 name = proxy 4. 如果要在爬虫代码中使用的话， 可以将此api封装成函数直接使用，例如： import requests def get_proxy(): return requests.get("http://127.0.0.1:5010/get/").content def delete_proxy(proxy): requests.get("http://127.0.0.1:5010/delete/?proxy={}".format(proxy)) 开发的api接口在这里设置 [API] # API config http://127.0.0.1:5010 # The ip specified when starting the web API ip = 0.0.0.0 # he port on which to run the web API port = 5010
3、代码实现
1. 首先确保已经把代理ip的那个网站爬下来了 2. 确保DB和API设置好了 3. 在我们的爬虫程序中新建一个proxy.py文件 代码如下： import requests def get_proxy(): return requests.get("http://127.0.0.1:5010/get/").content def delete_proxy(proxy): requests.get("http://127.0.0.1:5010/delete/?proxy={}".format(proxy)) 4. 我们爬虫程序的下载中间件代码 from .proxy import get_proxy,delete_proxy class AmazonDownloaderMiddleware(object): def process_exception(self, request, exception, spider): # Called when a download handler or a process_request() # (from other downloader middleware) raises an exception. # Must either: # - return None: continue processing this exception # - return a Response object: stops process_exception() chain # - return a Request object: stops process_exception() chain proxy = "http://"+get_proxy() request.meta['download_timeout'] = 20 request.meta["proxy"] = proxy return request
