Scrapy-Redis分布式爬虫框架详解-邮乐网（ule.com）

最新推荐文章于 2024-06-23 16:01:36 发布
最新推荐文章于 2024-06-23 16:01:36 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： python 文章标签： redis 分布式 爬虫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012441595/article/details/121742519
版权

python编程快速上手（持续更新中…）

python爬虫从入门到精通

Scrapy爬虫框架

文章目录

一、scrapy_redis概念作用和流程

如果当前网站的数据比较庞大, 几十亿数据，明天交付，我们就需要使用分布式来更快的爬取数据

1. 分布式是什么

简单的说 分布式就是不同的节点（服务器，ip不同）共同完成一个任务

缺点：
加快运行速度，运行总资源不会少
分散，增加风险

2. scrapy_redis的概念

scrapy_redis是scrapy框架的基于redis的分布式组件

3. scrapy_redis的作用

Scrapy_redis在scrapy的基础上实现了更多，更强大的功能，具体体现在：
通过持久化请求队列和请求的指纹集合来实现：
断点续爬，记录
分布式快速抓取

4. scrapy_redis的原理

去重集合
任务队列
数据队列（存）
在这里插入图片描述

5. scrapy_redis的工作流程

5.1 回顾scrapy的流程

思考：那么，在这个基础上，如果需要实现分布式，即多台服务器同时完成一个爬虫，需要怎么做呢？

5.2 scrapy_redis的流程

在scrapy_redis中，所有的待抓取的request对象和指纹去重的request对象都存在所有的服务器公用的redis中

所有的服务器中的scrapy进程公用同一个redis中的request对象的队列

所有的request对象存入redis前，都会通过该redis中的request指纹集合进行判断，之前是否已经存入过

在默认情况下所有的数据会保存在redis中
在这里插入图片描述

二、scrapy_redis实现断点续爬

1. 下载github的demo代码

clone github scrapy-redis源码文件

git clone https://github.com/rolando/scrapy-redis.git

研究项目自带的demo
scrapy-redis/example-project/example

2. 观察dmoz文件

在domz爬虫文件中，实现方式就是之前的crawlspider类型的爬虫，修改allowed_domains与start_urls

from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule


class DmozSpider(CrawlSpider):
    """Follow categories and extract links."""
    name = 'dmoz'
    allowed_domains = ['dmoztools.net']
    start_urls = ['http://dmoztools.net/'] # 这里修改了url
    
    # 定义数据提取规则，使用了css选择器
    rules = [
        Rule(LinkExtractor(
            restrict_css=('.top-cat', '.sub-cat', '.cat-item')
        ), callback='parse_directory', follow=True),
    ]

    def parse_directory(self, response):
        for div in response.css('.title-and-desc'):
            yield {
                'name': div.css('.site-title::text').extract_first(),
                'description': div.css('.site-descr::text').extract_first().strip(),
                'link': div.css('a::attr(href)').extract_first(),
            }

但是在settings.py中多了以下内容,这几行表示scrapy_redis中重新实现的了去重的类，以及调度器，并且使用RedisPipeline管道类

SPIDER_MODULES = ['example.spiders']
NEWSPIDER_MODULE = 'example.spiders'

USER_AGENT = 'scrapy-redis (+https://github.com/rolando/scrapy-redis)'

# 设置重复过滤器的模块
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 设置调取器，scrap_redis中的调度器具备与数据库交互的功能
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 设置当爬虫结束的时候是否保持redis数据库中的去重集合与任务队列
SCHEDULER_PERSIST = True
#SCHEDULER_QUEUE_CLASS = "scrapy_redis.queue.SpiderPriorityQueue"
#SCHEDULER_QUEUE_CLASS = "scrapy_redis.queue.SpiderQueue"
#SCHEDULER_QUEUE_CLASS = "scrapy_redis.queue.SpiderStack"

ITEM_PIPELINES = {
    'example.pipelines.ExamplePipeline': 300,
    # 当开启该管道，该管道将会把数据存到Redis数据库中
    'scrapy_redis.pipelines.RedisPipeline': 400,
}
# 设置redis数据库
REDIS_URL = "redis://127.0.0.1:6379"

LOG_LEVEL = 'DEBUG'

# Introduce an artifical delay to make use of parallelism. to speed up the
# crawl.
DOWNLOAD_DELAY = 0.5

3. 运行dmoz爬虫，观察现象

安装
pip install scrapy_redis

运行

cd scrapy-redis/example-project
scrapy crawl dmoz

在这里插入图片描述
我们执行domz的爬虫，会发现redis中多了一下三个键：

中止进程后再次运行dmoz爬虫
继续执行程序，会发现程序在前一次的基础之上继续往后执行，所以domz爬虫是一个基于url地址的增量式的爬虫

4. scrapy_redis的原理分析

我们从settings.py中的三个配置来进行分析
分别是：
RedisPipeline # 管道类
RFPDupeFilter # 指纹去重类
Scheduler # 调度器类
SCHEDULER_PERSIST # 是否持久化请求队列和指纹集合

4.1 Scrapy_redis之RedisPipeline

RedisPipeline中观察process_item，进行数据的保存，存入了redis中

4.2 Scrapy_redis之RFPDupeFilter

RFPDupeFilter 实现了对request对象的加密

4.3 Scrapy_redis之Scheduler

scrapy_redis调度器的实现了决定什么时候把request对象加入带抓取的队列，同时把请求过的request对象过滤掉

4.4 由此可以总结出request对象入队的条件

request的指纹不在集合中
request的dont_filter为True，即不过滤
start_urls中的url地址会入队，因为他们默认是不过滤

4.5 实现单机断点续爬

改写网易招聘爬虫，该爬虫就是一个经典的基于url地址的增量式爬虫

5. 实现分布式爬虫

5.1 分析demo中代码

打开example-project项目中的myspider_redis.py文件

from scrapy_redis.spiders import RedisSpider


class MySpider(RedisSpider):
    """Spider that reads urls from redis queue (myspider:start_urls)."""
    name = 'myspider_redis'
    redis_key = 'py21'

    def __init__(self, *args, **kwargs):
        # Dynamically define the allowed domains list.
        domain = kwargs.pop('domain', '')
        self.allowed_domains = filter(None, domain.split(','))
        super(MySpider, self).__init__(*args, **kwargs)

    def parse(self, response):
        return {
            'name': response.css('title::text').extract_first(),
            'url': response.url,
        }

settings.py中关键的配置

DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
SCHEDULER_PERSIST = True

ITEM_PIPELINES = {
    'example.pipelines.ExamplePipeline': 300,
    'scrapy_redis.pipelines.RedisPipeline': 400,
}
REDIS_URL = "redis://127.0.0.1:6379"

打开3个窗口，分别运行

scrapy-redis\example-project\example\spiders
scrapy runspider myspider_redis.py

启用

lpush py21 http://www.badu.com

结果
在这里插入图片描述

开发步骤
1.继承自父类为RedisSpider
2.增加了一个redis_key的键，没有start_urls，因为分布式中，如果每台电脑都请求一次start_url就会重复
3.多了__init__方法，该方法不是必须的，可以手动指定allow_domains
4.启动方法：
在每个节点正确的目录下执行scrapy crawl 爬虫名，使该节点的scrapy_redis爬虫程序就位
在共用的redis中 lpush redis_key ‘start_url’，使全部节点真正的开始运行
5.settings.py中关键的配置

5.2 动手实现分布式爬虫步骤

在这里插入图片描述

三、爬取图书信息-邮乐网（https://ule.com）

1.全部商品分类-图书音像

首页
在这里插入图片描述
全部商品分类-图书/音像
在这里插入图片描述
计算机/网络
在这里插入图片描述
方案：涉及传参，使用spider爬虫

2.代码实现

A.创建项目

scrapy startproject ule

B.模型设计

class UleItem(scrapy.Item):
    # define the fields for your item here like:
    big_category = scrapy.Field()
    big_category_link = scrapy.Field()
    small_category = scrapy.Field()
    small_category_link = scrapy.Field()

    bookname = scrapy.Field()
    author = scrapy.Field()
    link = scrapy.Field()
    price = scrapy.Field()
    pass

C.创建爬虫

cd ule
scrapy genspider book ule.com

D.修改url：https://search.ule.com/

E.检查domain：ule.com

F.邮乐爬虫-大分类xpath

//*[@id=“fenlei10”]/div/div/div[1]/a

import scrapy


class BookSpider(scrapy.Spider):
    name = 'book'
    allowed_domains = ['ule.com']
    start_urls = ['https://search.ule.com/']

    def parse(self, response):
        # 获取所有图书大分类节点列表
        big_node_list = response.xpath('//*[@id="fenlei17"]/div/div/div[1]/a')

        for big_node in big_node_list:
            big_category = big_node.xpath('./text()').extract_first()
            big_category_link = response.urljoin(big_node.xpath('./@href').extract_first())
            print(big_category, big_category_link)

G.运行

scrapy crawl book

H.邮乐爬虫-获取小分类
根据大分类xpath获取小分类，上级兄弟节点div下a标签

//*[@id=“fenlei17”]/div[1]/div/div[1]/a/…/following-sibling::div[1]/a

# 获取所有图书小分类节点列表
small_node_list = big_node.xpath('../following-sibling::div[1]/a')
print(len(small_node_list))
break

I.模拟点击小分类链接

# 模拟点击小分类链接
yield scrapy.Request(
    url=temp['small_category_link'],
    callback=self.parse_book_list,
    meta={"py21": temp}
)

J.获取图书节点

//*[@id=“wrapper”]/div/div[5]/div[3]/div/ul/li/div


def parse_book_list(self, response):
    temp = response.meta['py21']

    book_list = response.xpath('//*[@id="wrapper"]/div/div[5]/div[3]/div/ul/li/div')
    print(len(book_list))

    for book in book_list:
        item = UleItem()

        # item['big_category'] = temp['big_category']
        # item['big_category_link'] = temp['big_category_link']
        # item['small_category'] = temp['small_category']
        # item['small_category_link'] = temp['small_category_link']

        item['bookname'] = book.xpath('./p[2]/a/text()').extract_first().strip()
        item['store'] = book.xpath('./p[2]/a/text()').extract_first().strip()
        item['link'] = response.urljoin(book.xpath('./p[1]/a[1]/@href').extract_first())
        # strong标签获取不到值
        # item['price'] = book.xpath('./div/span/strong/text()').extract_first()
        print(item)

运行效果
在这里插入图片描述
K.邮乐爬虫-图书价格
strong标签获取不到值,extract

通过分析可以从去详情的json获取

https://item-service.ule.com/itemserviceweb/api/v1/price/queryListingPrice?listId=3767119

# strong标签获取不到值,extract
# item['price'] = book.xpath('./div/span/strong').strip()

# 获取图书编号
skuid = book.xpath('./p[1]/a[2]/@data-listingid').extract_first()
# print("1111111111111111111111: ", skuid)

pri_url = 'https://item-service.ule.com/itemserviceweb/api/v1/price/queryListingPrice?listId=' + skuid
yield scrapy.Request(url=pri_url, callback=self.parse_price, meta={'meta_1': item})
# print(item)


def parse_price(self, response):
    item = response.meta['meta_1']

    dict_data = json.loads(response.body)
    # print("222222222: ", dict_data)
    item['price'] = dict_data['ulePrice']
    yield item

3.邮乐爬虫-修改为分布式爬虫

A.导入分布爬虫类

from scrapy_redis.spiders import RedisSpider

B.继承分布式爬虫类

class BookSpider(RedisSpider):

C.注销 allowed_domains和start_urls

#allowed_domains = [‘ule.com’]
#start_urls = [‘https://search.ule.com/’]

D.设置redis_key

redis_key = ‘py21’

E.设置__init__

def __init__(self, *args, **kwargs):
    domain = kwargs.pop('domain', '')
    self.allowed_domains = list(filter(None, domain.split(',')))
    super(BookSpider, self).__init__(*args, **kwargs)

D.修改settings

SPIDER_MODULES = ['ule.spiders']
NEWSPIDER_MODULE = 'ule.spiders'

USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36'

# 设置重复过滤器的模块
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 设置调取器，scrap_redis中的调度器具备与数据库交互的功能
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 设置当爬虫结束的时候是否保持redis数据库中的去重集合与任务队列
SCHEDULER_PERSIST = True
#SCHEDULER_QUEUE_CLASS = "scrapy_redis.queue.SpiderPriorityQueue"
#SCHEDULER_QUEUE_CLASS = "scrapy_redis.queue.SpiderQueue"
#SCHEDULER_QUEUE_CLASS = "scrapy_redis.queue.SpiderStack"

ITEM_PIPELINES = {
    # 'ule.pipelines.ExamplePipeline': 300,
    # 当开启该管道，该管道将会把数据存到Redis数据库中
    'scrapy_redis.pipelines.RedisPipeline': 400,
}
# 设置redis数据库
REDIS_URL = "redis://172.16.123.223:6379"

# LOG_LEVEL = 'DEBUG'

# Introduce an artifical delay to make use of parallelism. to speed up the
# crawl.
DOWNLOAD_DELAY = 1

运行：

cd ule\spiders
scrapy runspider book.py

测试：

lpush py21 https://search.ule.com/

IT瘾君
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scrapy-Redis简单使用
dandanfengyun的博客
02-07 1898
首先，官方GitHub地址 https://github.com/rmax/scrapy-redis 特征 1。分布式抓取/抓取 您可以启动共享单个redis队列的多个spider实例。Y适合广泛的多域抓取。 2。分布式后处理 Scraped项目被推送到redis排队，这意味着您可以在共享项目队列的所需后处理过程中启动。 3。Scrapy即插即用组件 调度程序+复制过滤器，项目管道，基础蜘蛛。 使...
Python基于Scrapy-Redis分布式爬虫设计毕业源码(毕设项目).zip
06-08
程序采用 python 开发的 Scrapy 框架来开发，使用 Xpath 技术对下载的网页进行提取解析，运用 Redis 数据库做分布式， 设计并实现了针对当当图书网的分布式爬虫程序，scrapy-redis是一个基于redis的scrapy组件，...
scrapy-redis
cristianoxm的博客
12-02 501
是 Scrapy 框架的一个扩展，它提供了对 Redis 数据库的支持，用于实现分布式爬取。通过使用 Scrapy-Redis，你可以将多个 Scrapy 进程连接到同一个 Redis 服务器，共享任务队列和去重集，从而实现爬虫的分布式调度。主要特点和功能包括：分布式爬取支持： Scrapy-Redis 允许多个 Scrapy进程协同工作，它们可以在不同的机器上运行，共享任务队列和去重集，提高爬取效率。
scrapy_redis
探测???
06-23 641
使用hashlib模块生成指纹 import hashlib f = hashlib.sha1() text = 'http://www.baidu.com' f.update(text.encode()) # 需要将字符串进行编码 f.hexdigest() # '633a42441e296c9004a78abe0b2ee3b37559d32f' 继承 RedisSpider 类实现分布式 ...
Python基于Scrapy-Redis分布式爬虫设计毕业源码案例设计完整
10-08
程序采用 python 开发的 Scrapy 框架来开发，使用 Xpath 技术对下载的网页进行提取解析，运用 Redis 数据库做分布式， 设计并实现了针对当当图书网的分布式爬虫程序，scrapy-redis是一个基于redis的scrapy组件，...
scrapy-redis分布式爬虫实现案例
05-31
Scrapy-Redis是一个强大的工具，它扩展了Scrapy框架，使其能够处理分布式爬虫的场景。这个案例将向我们展示如何利用Scrapy-Redis在多台机器上部署爬虫，以实现高效的数据抓取。 首先，我们要理解Scrapy。Scrapy是一...
基于Python的Scrapy爬虫框架与Scrapy-Redis分布式爬虫设计源码
04-06
本资源提供了一套基于Python的Scrapy爬虫框架与Scrapy-Redis分布式爬虫的设计源码，包含61个文件，其中包括51个Python源代码文件，7个配置文件，以及1个Git忽略文件。此外，还包括1个文本文件和1个Markdown文档。...
毕业设计 - 基于Scrapy-Redis分布式爬虫设计（python）
04-04
程序采用 python 开发的 Scrapy 框架来开发，使用 Xpath 技术对下载的网页进行提取解析，运用 Redis 数据库做分布式， 设计并实现了针对当当图书网的分布式爬虫程序，scrapy-redis是一个基于redis的scrapy组件，通过...
scrapy -redis
mongodb数据库知识点
03-19 343
scrapy_redis如何进行去重 使用sha1，加密了请求方法，请求url地址，请求体，得到16进制字符串，存入redis的集合中 后续新来一个request对象，同样方法生成指纹，判断是否存在redis的集合中，存在就不放入 判断数据是否存在redis的集合中，同时要把数据存入该集合，怎么做 added = self.server.sadd(self.key, fp) re...
python——scrapy-redis分布式组件
weixin_30500663的博客
12-16 466
爬虫的自我修养_7 一、scrapy-redis架构 scrapy-redis在scrapy的架构上增加了redis，基于redis的特性拓展了如下组件： Scheduler： Scrapy改造了python本来的collection.deque(双向队列)形成了自己的Scrapy queue(https://github.com/scrapy/queuelib/blob/master...
scrapy-redis(分布式爬虫)
lemonguess的博客
08-02 992
一、概念 概念：多台机器对一个项目进行分部联合爬取。 作用：增加工作单位，提升爬取效率。 前提：每一台工作机器都需要scrapy的运行环境。
scrapy -redis分布式爬虫
Great Expectations的博客
09-12 484
settings 配置文件： # 使用scrapy-redis里的去重组件，不使用scrapy默认的去重方式 DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter" # 使用scrapy-redis里的调度器组件，不使用默认的调度器 SCHEDULER = "scrapy_redis.scheduler.Scheduler" # ...
Scrapy与redis的结合（Scrapy 分布式）
qq_45451647的博客
03-10 1244
一 ，Scrapy-分布式 （1）什么是scrapy_redis scrapy_redis:Redis-based components for scrapy github地址:https://github.com/rmax/scrapy-redis （2）Scrapy和Scrapy-redis 有什么区别？ 1.Scrapy是爬虫的一个框架 爬取效率非常高 具有高度的可定制性 不支持分布式 2.Scrapy-redis 它是基于redis数据库 运行在scrapy框架之上的一个组件
Scrapy Redis实现分布式爬取与缓存管理
积跬步，至千里。
04-09 753
Scrapy Redis是Scrapy框架基于redis分布式的一个组件，用于在分布式环境下使用Redis作为共享的调度器和去重器。它可以让多个Scrapy爬虫共享同一个Redis数据库，从而实现高效的分布式爬取。
Scrapy-Redis分布式爬虫
最新发布
wujddjdjndn的博客
06-23 1459
当我们了解了Scrapy爬虫框架的用法过后，这些框架都是在同一台主机上运行的，爬取效率比较有限。如果能够用多台主机协同爬取，那么爬取效率必然会成倍增长，这就是分布式爬虫的优势。这里我们就来了解一下分布式爬虫的基本原理，以及 Scrapy 实现分布式爬虫的流程。
scrapy-redis详解
wangjiakang12306的博客
09-20 3440
scrapy是一个工业化的爬虫框架，应用广泛，功能强大，scrapy-redis作为scrapy功能的增加，主要多的功能是让scrapy支持了分布式，增加了持续去重，增加了断点续爬，增量爬取等功能。最近学习了scrapy-redis的去重方式的源码，这里做一个简单的总结。 这个图片是scrapy-redis的源码的文件结构。从名字中就可以看出大概的作用。connection,从名字中就可以看出来...
scrapy-redis 框架
何必说
08-14 1239
scrapy-redis简介：Scrapy-redis 是为了更方便地实现 Scrapy 分布式爬取，而提供了一些以 redis 为基础的 组件(仅有组件)。主体还是是 redis 和 scrapy 两个库，Scrapy-redis 像胶水一样，把这两个插件粘结了起来。 scrapy-redis特点：1能实现分布式爬取 2可实现去重 3持续性爬取，可实现增量式爬虫 4遵守 Rule 规则，可以实...
python scrapy-redis分布式爬虫
05-24
Scrapy-Redis是一个基于Scrapy框架的分布式爬虫解决方案，它使用Redis作为分布式队列和去重集合，实现了多个爬虫节点共享一个Redis队列和去重集合，从而实现了高效的分布式爬取。 使用Scrapy-Redis，你可以很容易地将一个单机版的Scrapy爬虫转换成一个分布式爬虫。下面是简单的步骤： 1. 安装Redis和Scrapy-Redis 首先需要安装Redis，并且确保Redis服务正常运行。另外，需要安装Scrapy-Redis库，可以通过pip命令来进行安装： ``` pip install scrapy-redis ``` 2. 修改爬虫设置 在Scrapy爬虫的settings.py文件中，需要添加如下配置： ``` # 启用Redis调度器 SCHEDULER = "scrapy_redis.scheduler.Scheduler" # 启用Redis去重过滤器 DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter" # 设置Redis为调度器和去重过滤器的数据存储位置 REDIS_URL = 'redis://localhost:6379' ``` 3. 修改爬虫代码 在Scrapy爬虫的代码中，需要将原来的start_urls修改为redis_key，例如： ``` class MySpider(RedisSpider): name = 'myspider' redis_key = 'myspider:start_urls' ``` 另外，需要将原来的parse方法改为如下形式： ``` def parse(self, response): # 爬虫代码 yield scrapy.Request(url, callback=self.parse_item) ``` 4. 运行爬虫 在启动爬虫之前，需要先往Redis队列中添加起始URL，例如： ``` redis-cli lpush myspider:start_urls http://www.example.com ``` 然后在命令行中启动分布式爬虫，例如： ``` scrapy crawl myspider ``` 这样就可以启动一个分布式的Scrapy爬虫了。在多个爬虫节点共享同一个Redis队列和去重集合的情况下，可以大大提高爬取效率和速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值