5、爬蟲系列之scrapy框架

一 scrapy框架簡介

1 介紹

(1) 什么是Scrapy？

　　Scrapy是一個為了爬取網站數據，提取結構性數據而編寫的應用框架，非常出名，非常強悍。所謂的框架就是一個已經被集成了各種功能（高性能異步下載，隊列，分布式，解析，持久化等）的具有很強通用性的項目模板。對於框架的學習，重點是要學習其框架的特性、各個功能的用法即可。

Scrapy一個開源和協作的框架，其最初是為了頁面抓取 (更確切來說, 網絡抓取 )所設計的，使用它可以以快速、簡單、可擴展的方式從網站中提取所需的數據。但目前Scrapy的用途十分廣泛，可用於如數據挖掘、監測和自動化測試等領域，也可以應用在獲取API所返回的數據(例如 Amazon Associates Web Services ) 或者通用的網絡爬蟲。Scrapy 是基於twisted框架開發而來，twisted是一個流行的事件驅動的python網絡框架。因此Scrapy使用了一種非阻塞（又名異步）的代碼來實現並發。

整體架構大致如下：

 

'''
Components：

1、引擎(EGINE)
引擎負責控制系統所有組件之間的數據流，並在某些動作發生時觸發事件。有關詳細信息，請參見上面的數據流部分。

2、調度器(SCHEDULER)
用來接受引擎發過來的請求, 壓入隊列中, 並在引擎再次請求的時候返回. 可以想像成一個URL的優先級隊列, 由它來決定下一個要抓取的網址是什么, 同時去除重復的網址

3、下載器(DOWLOADER)
用於下載網頁內容, 並將網頁內容返回給EGINE，下載器是建立在twisted這個高效的異步模型上的

4、爬蟲(SPIDERS)
SPIDERS是開發人員自定義的類，用來解析responses，並且提取items，或者發送新的請求

5、項目管道(ITEM PIPLINES)
在items被提取后負責處理它們，主要包括清理、驗證、持久化（比如存到數據庫）等操作
下載器中間件(Downloader Middlewares)位於Scrapy引擎和下載器之間，主要用來處理從EGINE傳到DOWLOADER的請求request，已經從DOWNLOADER傳到EGINE的響應response，
你可用該中間件做以下幾件事：
  　　(1) process a request just before it is sent to the Downloader (i.e. right before Scrapy sends the request to the website);
  　　(2) change received response before passing it to a spider;
  　　(3) send a new Request instead of passing received response to a spider;
  　　(4) pass response to a spider without fetching a web page;
  　　(5) silently drop some requests.

6、爬蟲中間件(Spider Middlewares)
位於EGINE和SPIDERS之間，主要工作是處理SPIDERS的輸入（即responses）和輸出（即requests）
'''

官網鏈接

2 安裝

　　#Linux：

      pip3 install scrapy

　　#Windows：
 a. pip3 install wheel b. 下載twisted http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted  c. 進入下載目錄，執行 pip3 install Twisted‑17.1.0‑cp35‑cp35m‑win_amd64.whl d. pip3 install pywin32 e. pip3 install scrapy

3 命令行工具

# 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

4 目錄結構

'''
project_name/
   scrapy.cfg
   project_name/
       __init__.py
       items.py
       pipelines.py
       settings.py
       spiders/
           __init__.py
           爬蟲1.py
           爬蟲2.py
           爬蟲3.py

'''

文件說明：

• scrapy.cfg  項目的主配置信息，用來部署scrapy時使用，爬蟲相關的配置信息在settings.py文件中。
• items.py    設置數據存儲模板，用於結構化數據，如：Django的Model
• pipelines    數據處理行為，如：一般結構化的數據持久化
• settings.py 配置文件，如：遞歸的層數、並發數，延遲下載等。強調:配置文件的選項必須大寫否則視為無效，正確寫法USER_AGENT='xxxx'
• spiders      爬蟲目錄，如：創建文件，編寫爬蟲規則

注意：

1、一般創建爬蟲文件時，以網站域名命名

2、默認只能在終端執行命令，為了更便捷操作：

#在項目根目錄下新建：entrypoint.py
from scrapy.cmdline import execute
execute(['scrapy', 'crawl', 'xiaohua'])

框架基礎：spider類，選擇器

5 牛刀小試

1.創建爬蟲應用程序　

cd project_name（進入項目目錄）
scrapy genspider 應用名稱 爬取網頁的起始url （例如：scrapy genspider qiubai www.qiushibaike.com）

2 編寫爬蟲文件:在步驟2執行完畢后，會在項目的spiders中生成一個應用名的py爬蟲文件，文件源碼如下：

# -*- coding: utf-8 -*-
import scrapy

class QiubaiSpider(scrapy.Spider):
    name = 'qiubai' #應用名稱
    #允許爬取的域名（如果遇到非該域名的url則爬取不到數據）
    allowed_domains = ['https://www.qiushibaike.com/']
    #起始爬取的url
    start_urls = ['https://www.qiushibaike.com/']

     #訪問起始URL並獲取結果后的回調函數，該函數的response參數就是向起始的url發送請求后，獲取的響應對象.該函數返回值必須為可迭代對象或者NUll 
     def parse(self, response):
        print(response.text) #獲取字符串類型的響應內容
        print(response.body)#獲取字節類型的相應內容　

3 設置修改settings.py配置文件相關配置

修改內容及其結果如下：
19行：USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36' #偽裝請求載體身份

22行：ROBOTSTXT_OBEY = False  #可以忽略或者不遵守robots協議

4 執行爬蟲程序：

scrapy crawl  應用名稱

5 將糗百首頁中段子的內容和標題進行爬取

# -*- coding: utf-8 -*-
import scrapy

class QiubaiSpider(scrapy.Spider):
    name = 'qiubai'
    allowed_domains = ['https://www.qiushibaike.com/']
    start_urls = ['https://www.qiushibaike.com/']

    def parse(self, response):
        #xpath為response中的方法，可以將xpath表達式直接作用於該函數中
        odiv = response.xpath('//div[@id="content-left"]/div')
        content_list = [] #用於存儲解析到的數據
        for div in odiv:
            #xpath函數返回的為列表，列表中存放的數據為Selector類型的數據。我們解析到的內容被封裝在了Selector對象中，需要調用extract()函數將解析的內容從Selecor中取出。
            author = div.xpath('.//div[@class="author clearfix"]/a/h2/text()')[0].extract()
            content=div.xpath('.//div[@class="content"]/span/text()')[0].extract()

            #將解析到的內容封裝到字典中
            dic={
                '作者':author,
                '內容':content
            }
            #將數據存儲到content_list這個列表中
            content_list.append(dic)

        return content_list

執行爬蟲程序：

    scrapy crawl 爬蟲名稱 ：該種執行形式會顯示執行的日志信息
    scrapy crawl 爬蟲名稱 --nolog：該種執行形式不會顯示執行的日志信息

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

'''

三 選擇器

為了解釋如何使用選擇器，我們將使用Scrapy shell（提供交互式測試）和Scrapy文檔服務器中的示例頁面，

這是它的HTML代碼：

<html>
 <head>
  <base href='http://example.com/' />
  <title>Example website</title>
 </head>
 <body>
  <div id='images'>
   <a href='image1.html'>Name: My image 1 <br /><img src='image1_thumb.jpg' /></a>
   <a href='image2.html'>Name: My image 2 <br /><img src='image2_thumb.jpg' /></a>
   <a href='image3.html'>Name: My image 3 <br /><img src='image3_thumb.jpg' /></a>
   <a href='image4.html'>Name: My image 4 <br /><img src='image4_thumb.jpg' /></a>
   <a href='image5.html'>Name: My image 5 <br /><img src='image5_thumb.jpg' /></a>
  </div>
 </body>
</html>

首先，讓我們打開shell：

1 scrapy shell https://doc.scrapy.org/en/latest/_static/selectors-sample1.html
然后，在shell加載之后，您將獲得響應作為response shell變量，並在response.selector屬性中附加選擇器。

讓我們構建一個XPath來選擇title標簽內的文本：


>>> response.selector.xpath('//title/text()')
[<Selector (text) xpath=//title/text()>]
使用XPath和CSS查詢響應非常常見，響應包括兩個便捷快捷方式：response.xpath()和response.css()：


>>> response.xpath('//title/text()')
[<Selector (text) xpath=//title/text()>]
>>> response.css('title::text')
[<Selector (text) xpath=//title/text()>]
正如你所看到的，.xpath()並且.css()方法返回一個 SelectorList實例，這是新的選擇列表。此API可用於快速選擇嵌套數據：


>>> response.css('img').xpath('@src').extract()
[u'image1_thumb.jpg',
 u'image2_thumb.jpg',
 u'image3_thumb.jpg',
 u'image4_thumb.jpg',
 u'image5_thumb.jpg']
要實際提取文本數據，必須調用selector .extract() 方法，如下所示：


>>> response.xpath('//title/text()').extract()
[u'Example website']
如果只想提取第一個匹配的元素，可以調用選擇器 .extract_first()

>>> response.xpath('//div[@id="images"]/a/text()').extract_first()
u'Name: My image 1 '
現在我們將獲得基本URL和一些圖像鏈接：

>>> response.xpath('//base/@href').extract()
[u'http://example.com/']
 
>>> response.css('base::attr(href)').extract()
[u'http://example.com/']
 
>>> response.xpath('//a[contains(@href, "image")]/@href').extract()
[u'image1.html',
 u'image2.html',
 u'image3.html',
 u'image4.html',
 u'image5.html']
 
>>> response.css('a[href*=image]::attr(href)').extract()
[u'image1.html',
 u'image2.html',
 u'image3.html',
 u'image4.html',
 u'image5.html']
 
>>> response.xpath('//a[contains(@href, "image")]/img/@src').extract()
[u'image1_thumb.jpg',
 u'image2_thumb.jpg',
 u'image3_thumb.jpg',
 u'image4_thumb.jpg',
 u'image5_thumb.jpg']
 
>>> response.css('a[href*=image] img::attr(src)').extract()
[u'image1_thumb.jpg',
 u'image2_thumb.jpg',
 u'image3_thumb.jpg',
 u'image4_thumb.jpg',
 u'image5_thumb.jpg']

四 DupeFilter(去重)

默認使用方式：

DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter'
Request(...,dont_filter=False) ，如果dont_filter=True則告訴Scrapy這個URL不參與去重。

源碼解析：

from scrapy.core.scheduler import Scheduler
見Scheduler下的enqueue_request方法：self.df.request_seen(request)　　

自定義去重規則：

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

五 Item(項目)

抓取的主要目標是從非結構化源（通常是網頁）中提取結構化數據。Scrapy蜘蛛可以像Python一樣返回提取的數據。雖然方便和熟悉，但P很容易在字段名稱中輸入拼寫錯誤或返回不一致的數據，尤其是在具有許多蜘蛛的較大項目中。

為了定義通用輸出數據格式，Scrapy提供了Item類。 Item對象是用於收集抓取數據的簡單容器。它們提供類似字典的 API，並具有用於聲明其可用字段的方便語法。

1 聲明項目

使用簡單的類定義語法和Field 對象聲明項。這是一個例子：

import scrapy

class Product(scrapy.Item):
name = scrapy.Field()
price = scrapy.Field()
stock = scrapy.Field()
last_updated = scrapy.Field(serializer=str)

注意那些熟悉Django的人會注意到Scrapy Items被宣告類似於Django Models，除了Scrapy Items更簡單，因為沒有不同字段類型的概念。

2 項目字段

Field對象用於指定每個字段的元數據。例如，last_updated上面示例中說明的字段的序列化函數。

您可以為每個字段指定任何類型的元數據。Field對象接受的值沒有限制。出於同樣的原因，沒有所有可用元數據鍵的參考列表。

Field對象中定義的每個鍵可以由不同的組件使用，只有那些組件知道它。您也可以根據Field自己的需要定義和使用項目中的任何其他鍵。

Field對象的主要目標是提供一種在一個地方定義所有字段元數據的方法。通常，行為取決於每個字段的那些組件使用某些字段鍵來配置該行為。

3 使用項目

以下是使用上面聲明的Product項目對項目執行的常見任務的一些示例 。您會注意到API與dict API非常相似。

創建項目
>>> product = Product(name='Desktop PC', price=1000)
>>> print product
Product(name='Desktop PC', price=1000)
獲取字段值
>>> product['name']
Desktop PC
>>> product.get('name')
Desktop PC

>>> product['price']
1000

>>> product['last_updated']
Traceback (most recent call last):
...
KeyError: 'last_updated'

>>> product.get('last_updated', 'not set')
not set

>>> product['lala'] # getting unknown field
Traceback (most recent call last):
...
KeyError: 'lala'

>>> product.get('lala', 'unknown field')
'unknown field'

>>> 'name' in product # is name field populated?
True

>>> 'last_updated' in product # is last_updated populated?
False

>>> 'last_updated' in product.fields # is last_updated a declared field?
True

>>> 'lala' in product.fields # is lala a declared field?
False
設定字段值
>>> product['last_updated'] = 'today'
>>> product['last_updated']
today

>>> product['lala'] = 'test' # setting unknown field
Traceback (most recent call last):
...
KeyError: 'Product does not support field: lala'
訪問所有填充值
要訪問所有填充值，只需使用典型的dict API：

>>> product.keys()
['price', 'name']

>>> product.items()
[('price', 1000), ('name', 'Desktop PC')]
其他常見任務
復制項目：

>>> product2 = Product(product)
>>> print product2
Product(name='Desktop PC', price=1000)

>>> product3 = product2.copy()
>>> print product3
Product(name='Desktop PC', price=1000)
從項目創建dicts：

>>> dict(product) # create a dict from all populated values
{'price': 1000, 'name': 'Desktop PC'}
從dicts創建項目：

>>> Product({'name': 'Laptop PC', 'price': 1500})
Product(price=1500, name='Laptop PC')

>>> Product({'name': 'Laptop PC', 'lala': 1500}) # warning: unknown field in dict
Traceback (most recent call last):
...
KeyError: 'Product does not support field: lala'

4 擴展項目

您可以通過聲明原始Item的子類來擴展Items（以添加更多字段或更改某些字段的某些元數據）。

例如：

class DiscountedProduct(Product):
      discount_percent = scrapy.Field(serializer=str)
      discount_expiration_date = scrapy.Field()

六 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

1 編寫自己的項目管道

'''
每個項管道組件都是一個必須實現以下方法的Python類：

process_item（self，項目，蜘蛛）
為每個項目管道組件調用此方法。process_item() 

必須要么：返回帶數據的dict，返回一個Item （或任何后代類）對象，返回Twisted Deferred或引發 DropItem異常。丟棄的項目不再由其他管道組件處理。

此外，他們還可以實現以下方法：

open_spider（self，蜘蛛）
打開蜘蛛時會調用此方法。

close_spider（self，蜘蛛）
當蜘蛛關閉時調用此方法。

from_crawler（cls，crawler ）
如果存在，則調用此類方法以從a創建管道實例Crawler。它必須返回管道的新實例。Crawler對象提供對所有Scrapy核心組件的訪問，
如設置和信號; 它是管道訪問它們並將其功能掛鈎到Scrapy的一種方式。
'''

2 項目管道示例

(1) 價格驗證和丟棄物品沒有價格

讓我們看看下面的假設管道，它調整 price那些不包含增值稅（price_excludes_vat屬性）的項目的屬性，並刪除那些不包含價格的項目：

from scrapy.exceptions import DropItem

class PricePipeline(object):

    vat_factor = 1.15

    def process_item(self, item, spider):
        if item['price']:
            if item['price_excludes_vat']:
                item['price'] = item['price'] * self.vat_factor
            return item
        else:
            raise DropItem("Missing price in %s" % item)

(2) 將項目寫入JSON文件

以下管道將所有已刪除的項目（來自所有蜘蛛）存儲到一個items.jl文件中，每行包含一個以JSON格式序列化的項目：

import json

class JsonWriterPipeline(object):

    def open_spider(self, spider):
        self.file = open('items.jl', 'w')

    def close_spider(self, spider):
        self.file.close()

    def process_item(self, item, spider):
        line = json.dumps(dict(item)) + "\n"
        self.file.write(line)
        return item

注意JsonWriterPipeline的目的只是介紹如何編寫項目管道。如果您確實要將所有已刪除的項目存儲到JSON文件中，則應使用Feed導出。

(3) 將項目寫入數據庫

在這個例子中，我們將使用pymongo將項目寫入MongoDB。MongoDB地址和數據庫名稱在Scrapy設置中指定; MongoDB集合以item類命名。

這個例子的要點是展示如何使用from_crawler() 方法以及如何正確地清理資源：

import pymongo

class MongoPipeline(object):

    collection_name = 'scrapy_items'

    def __init__(self, mongo_uri, mongo_db):
        self.mongo_uri = mongo_uri
        self.mongo_db = mongo_db

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            mongo_uri=crawler.settings.get('MONGO_URI'),
            mongo_db=crawler.settings.get('MONGO_DATABASE', 'items')
        )

    def open_spider(self, spider):
        self.client = pymongo.MongoClient(self.mongo_uri)
        self.db = self.client[self.mongo_db]

    def close_spider(self, spider):
        self.client.close()

    def process_item(self, item, spider):
        self.db[self.collection_name].insert_one(dict(item))
        return item

(4) 重復過濾

一個過濾器，用於查找重復項目，並刪除已處理的項目。假設我們的項目具有唯一ID，但我們的蜘蛛會返回具有相同ID的多個項目：

from scrapy.exceptions import DropItem

class DuplicatesPipeline(object):

    def __init__(self):
        self.ids_seen = set()

    def process_item(self, item, spider):
        if item['id'] in self.ids_seen:
            raise DropItem("Duplicate item found: %s" % item)
        else:
            self.ids_seen.add(item['id'])
            return item

3 激活項目管道組件

要激活Item Pipeline組件，必須將其類添加到 ITEM_PIPELINES設置中，如下例所示：

ITEM_PIPELINES = {
    'myproject.pipelines.PricePipeline': 300,
    'myproject.pipelines.JsonWriterPipeline': 800,
}

您在此設置中為類分配的整數值決定了它們運行的​​順序：項目從較低值到較高值類進行。習慣上在0-1000范圍內定義這些數字。

七 下載中間件

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

八 基於scrapy-redis實現分布式爬蟲

 Scrapy-Redis則是一個基於Redis的Scrapy分布式組件。它利用Redis對用於爬取的請求(Requests)進行存儲和調度(Schedule)，並對爬取產生的項目(items)存儲以供后續處理使用。scrapy-redi重寫了scrapy一些比較關鍵的代碼，將scrapy變成一個可以在多個主機上同時運行的分布式爬蟲。

單機玩法：

按照正常流程就是大家都會進行重復的采集;我們都知道進程之間內存中的數據不可共享的，那么你在開啟多個Scrapy的時候，它們相互之間並不知道對方采集了些什么那些沒有沒采集。那就大家伙兒自己玩自己的了。完全沒沒有效率的提升啊！

怎么解決呢？

這就是我們Scrapy-Redis解決的問題了，不能協作不就是因為請求和去重這兩個不能共享嗎？

那我把這兩個獨立出來好了。

將Scrapy中的調度器組件獨立放到大家都能訪問的地方不就OK啦！加上scrapy，Redis的后流程圖就應該變成這樣了

分布式玩法：

 

 1 redis連接

配置scrapy使用redis提供的共享去重隊列

# 在settings.py中配置鏈接Redis
REDIS_HOST = 'localhost'                            # 主機名
REDIS_PORT = 6379                                   # 端口
REDIS_URL = 'redis://user:pass@hostname:9001'       # 連接URL（優先於以上配置）
REDIS_PARAMS  = {}                                  # Redis連接參數
REDIS_PARAMS['redis_cls'] = 'myproject.RedisClient' # 指定連接Redis的Python模塊
REDIS_ENCODING = "utf-8"                            # redis編碼類型  
# 默認配置：\python3.6\Lib\site-packages\scrapy_redis\defaults.py

2 dupefilter

DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
#使用scrapy-redis提供的去重功能，查看源碼會發現是基於Redis的集合實現的


# 需要指定Redis中集合的key名，key=存放不重復Request字符串的集合
DUPEFILTER_KEY = 'dupefilter:%(timestamp)s'
#源碼：dupefilter.py內一行代碼key = defaults.DUPEFILTER_KEY % {'timestamp': int(time.time())}

3 Scheduler

#1、源碼：\python3.6\Lib\site-packages\scrapy_redis\scheduler.py


#2、settings.py配置

# Enables scheduling storing requests queue in redis.
SCHEDULER = "scrapy_redis.scheduler.Scheduler"       

# 調度器將不重復的任務用pickle序列化后放入共享任務隊列，默認使用優先級隊列（默認），其他：PriorityQueue（有序集合），FifoQueue（列表）、LifoQueue（列表）               
SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'          

# 對保存到redis中的request對象進行序列化，默認使用pickle
SCHEDULER_SERIALIZER = "scrapy_redis.picklecompat"   

# 調度器中請求任務序列化后存放在redis中的key               
SCHEDULER_QUEUE_KEY = '%(spider)s:requests'    

# 是否在關閉時候保留原來的調度器和去重記錄，True=保留，False=清空                     
SCHEDULER_PERSIST = True       

# 是否在開始之前清空 調度器和去重記錄，True=清空，False=不清空                                     
SCHEDULER_FLUSH_ON_START = False    

# 去調度器中獲取數據時，如果為空，最多等待時間（最后沒數據，未獲取到）。如果沒有則立刻返回會造成空循環次數過多，cpu占用率飆升                                
SCHEDULER_IDLE_BEFORE_CLOSE = 10           

# 去重規則，在redis中保存時對應的key                         
SCHEDULER_DUPEFILTER_KEY = '%(spider)s:dupefilter'      

# 去重規則對應處理的類，將任務request_fingerprint(request)得到的字符串放入去重隊列            
SCHEDULER_DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'

3 RedisPipeline(持久化)

 ITEM_PIPELINES = {   'scrapy_redis.pipelines.RedisPipeline': 300, }

#將item持久化到redis時，指定key和序列化函數
     
 REDIS_ITEMS_KEY = '%(spider)s:items'
 REDIS_ITEMS_SERIALIZER = 'json.dumps'

4 從Redis中獲取起始URL

scrapy程序爬取目標站點，一旦爬取完畢后就結束了，如果目標站點更新內容了，我們想重新爬取，那么只能再重新啟動scrapy，非常麻煩
scrapy-redis提供了一種供，讓scrapy從redis中獲取起始url，如果沒有scrapy則過一段時間再來取而不會關閉
這樣我們就只需要寫一個簡單的腳本程序，定期往redis隊列里放入一個起始url。

#具體配置如下

#1、編寫爬蟲時，起始URL從redis的Key中獲取
REDIS_START_URLS_KEY = '%(name)s:start_urls'
    
#2、獲取起始URL時，去集合中獲取還是去列表中獲取？True，集合；False，列表
REDIS_START_URLS_AS_SET = False    # 獲取起始URL時，如果為True，則使用self.server.spop；如果為False，則使用self.server.lpop 

九 項目代碼 

下載項目代碼