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

python编程快速上手(持续更新中…)

python爬虫从入门到精通

Scrapy爬虫框架


文章目录

  • python编程快速上手(持续更新中…)
  • python爬虫从入门到精通
  • Scrapy爬虫框架
    • 一、scrapy_redis概念作用和流程
      • 1. 分布式是什么
      • 2. scrapy_redis的概念
      • 3. scrapy_redis的作用
      • 4. scrapy_redis的原理
      • 5. scrapy_redis的工作流程
        • 5.1 回顾scrapy的流程
        • 5.2 scrapy_redis的流程
    • 二、scrapy_redis实现断点续爬
      • 1. 下载github的demo代码
      • 2. 观察dmoz文件
      • 3. 运行dmoz爬虫,观察现象
      • 4. scrapy_redis的原理分析
        • 4.1 Scrapy_redis之RedisPipeline
        • 4.2 Scrapy_redis之RFPDupeFilter
        • 4.3 Scrapy_redis之Scheduler
        • 4.4 由此可以总结出request对象入队的条件
        • 4.5 实现单机断点续爬
      • 5. 实现分布式爬虫
        • 5.1 分析demo中代码
        • 5.2 动手实现分布式爬虫步骤
    • 三、爬取图书信息-邮乐网(https://ule.com)
      • 1.全部商品分类-图书音像
      • 2.代码实现
      • 3.邮乐爬虫-修改为分布式爬虫

一、scrapy_redis概念作用和流程

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

1. 分布式是什么

简单的说 分布式就是不同的节点(服务器,ip不同)共同完成一个任务

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

2. scrapy_redis的概念

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

3. scrapy_redis的作用

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

4. scrapy_redis的原理

去重集合
任务队列
数据队列(存)
Scrapy-Redis分布式爬虫框架详解-邮乐网(ule.com)_第1张图片

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分布式爬虫框架详解-邮乐网(ule.com)_第2张图片

二、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

Scrapy-Redis分布式爬虫框架详解-邮乐网(ule.com)_第3张图片
我们执行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 动手实现分布式爬虫步骤

Scrapy-Redis分布式爬虫框架详解-邮乐网(ule.com)_第4张图片

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

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

首页

全部商品分类-图书/音像
Scrapy-Redis分布式爬虫框架详解-邮乐网(ule.com)_第5张图片
计算机/网络
Scrapy-Redis分布式爬虫框架详解-邮乐网(ule.com)_第6张图片
方案:涉及传参,使用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)


运行效果
Scrapy-Redis分布式爬虫框架详解-邮乐网(ule.com)_第7张图片
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/

你可能感兴趣的:(python,redis,分布式,爬虫)