Scrapy框架——介绍、安装、命令行创建，启动、项目目录结构介绍、Spiders文件夹详解（包括去重规则）、Selectors解析页面、Items、pipelines（自定义pipeline）、下载中间件（Downloader Middleware）、爬虫中间件、信号

#Windows平台
    1、pip3 install wheel #安装后，便支持通过wheel文件安装软件，wheel文件官网：https://www.lfd.uci.edu/~gohlke/pythonlibs
    3、pip3 install lxml
    4、pip3 install pyopenssl
    5、下载并安装pywin32：https://sourceforge.net/projects/pywin32/files/pywin32/
    6、下载twisted的wheel文件：http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
    7、执行pip3 install 下载目录\Twisted-17.9.0-cp36-cp36m-win_amd64.whl
    8、pip3 install scrapy

#Linux平台
    1、pip3 install scrapy

#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

#1、执行全局命令：请确保不在某个项目的目录下，排除受该项目配置的影响
scrapy startproject MyProject  创建项目

cd MyProject
scrapy genspider baidu www.baidu.com  创建爬虫

scrapy settings --get XXX #如果切换到项目目录下，看到的则是该项目的配置

scrapy runspider baidu.py

scrapy shell https://www.baidu.com
    response
    response.status
    response.body
    view(response)
    
scrapy view https://www.taobao.com #如果页面显示内容不全，不全的内容则是ajax请求实现的，以此快速定位问题

scrapy fetch --nolog --headers https://www.taobao.com

scrapy version #scrapy的版本

scrapy version -v #依赖库的版本

#2、执行项目命令：切到项目目录下
scrapy crawl baidu  启动项目
scrapy check
scrapy list
scrapy parse http://quotes.toscrape.com/ --callback parse
scrapy bench

#在项目目录下新建：main.py
from scrapy.cmdline import execute
execute(['scrapy', 'crawl', 'cnblogs'])

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

#1、Spiders是由一系列类（定义了一个网址或一组网址将被爬取）组成，具体包括如何执行爬取任务并且如何从页面中提取结构化的数据。

#2、换句话说，Spiders是你为了一个特定的网址或一组网址自定义爬取和解析页面行为的地方

#1、生成初始的Requests来爬取第一个URLS，并且标识一个回调函数
第一个请求定义在start_requests()方法内默认从start_urls列表中获得url地址来生成Request请求，默认的回调函数是parse方法。回调函数在下载完成返回response时自动触发

#2、在回调函数中，解析response并且返回值（返回值就类似于请求页面的html，需要接着继续解析页面,解析页面在parse函数中完成）
返回值可以4种：
        包含解析数据的字典
        Item对象
        新的Request对象（新的Requests也需要指定一个回调函数,继续放到下一次请求去解析）
        或者是可迭代对象（包含Items或Request）

#3、在回调函数中解析页面内容
通常使用Scrapy自带的Selectors，但很明显你也可以使用Beutifulsoup，lxml或其他你爱用啥用啥。（通常解析使用css，xpath这些方式）

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

#1、scrapy.spiders.Spider      #scrapy.Spider等同于scrapy.spiders.Spider
#2、scrapy.spiders.CrawlSpider
#3、scrapy.spiders.XMLFeedSpider
#4、scrapy.spiders.CSVFeedSpider
#5、scrapy.spiders.SitemapSpider

import scrapy
from scrapy.spiders import Spider,CrawlSpider,XMLFeedSpider,CSVFeedSpider,SitemapSpider

class AmazonSpider(scrapy.Spider): #自定义类，继承Spiders提供的基类
    name = 'amazon'  #爬虫名，必须唯一
    allowed_domains = ['www.amazon.cn']   #允许的域名
    start_urls = ['http://www.amazon.cn/']  #起始路由
    
def parse(self, response):
    pass

class AmazonSpider(scrapy.Spider):
    name = 'amazon' 
    allowed_domains = ['www.amazon.cn'] 
    start_urls = ['https://www.amazon.cn/']

    def parse(self, response):
            pass    

#1、name = 'amazon'   (******)
定义爬虫名，scrapy会根据该值定位爬虫程序
所以它必须要有且必须唯一（In Python 2 this must be ASCII only.）

#2、allowed_domains = ['www.amazon.cn'] (******)
定义允许爬取的域名，如果OffsiteMiddleware启动（默认就启动），
那么不属于该列表的域名及其子域名都不允许爬取
如果爬取的网址为：https://www.example.com/1.html，那就添加'example.com'到列表.

#3、start_urls = ['http://www.amazon.cn/']  (******)
如果没有指定url，就从该列表中读取url来生成第一个请求

#4、custom_settings
值为一个字典，定义一些配置信息，在运行爬虫程序时，这些配置会覆盖项目级别的配置
所以custom_settings必须被定义成一个类属性，由于settings会在类实例化前被加载

#5、settings
通过self.settings['配置项的名字']可以访问settings.py中的配置，如果自己定义了custom_settings还是以自己的为准

#6、logger
日志名默认为spider的名字
self.logger.debug('=============>%s' %self.settings['BOT_NAME'])

#5、crawler：了解
该属性必须被定义到类方法from_crawler中

#6、from_crawler(crawler, *args, **kwargs)：了解
You probably won’t need to override this directly  because the default implementation acts as a proxy to the __init__() method, calling it with the given arguments args and named arguments kwargs.

#7、start_requests()  (爬虫的入口)
该方法用来发起第一个Requests请求，且必须返回一个可迭代(yield)的对象。它在爬虫程序打开时就被Scrapy调用，Scrapy只调用它一次。
默认从start_urls里取出每个url来生成Request(url, dont_filter=True)

#针对参数dont_filter,请看自定义去重规则  #默认是去重的

如果你想要改变起始爬取的Requests，你就需要覆盖这个方法，例如你想要起始发送一个POST请求，如下
class MySpider(scrapy.Spider):
    name = 'myspider'


　　def start_requests(self):
    　　return [scrapy.FormRequest("http://www.example.com/login",
                               formdata={'user': 'john', 'pass': 'secret'},
                               callback=self.logged_in)]

　　def logged_in(self, response):
    　　# here you would extract links to follow and return Requests for
    　　# each of them, with another callback
    　　pass#8、parse(response)
这是默认的回调函数，所有的回调函数必须返回an iterable of Request and/or dicts or Item objects.

#9、log(message[, level, component])：了解
Wrapper that sends a log message through the Spider’s logger, kept for backwards compatibility. For more information see Logging from Spiders.

#10、closed(reason)
爬虫程序结束时自动触发

方法一：
把url放在集合中去重
方法二：
scrapy自带去重功能 RFPDupeFilter
from scrapy.dupefilters import RFPDupeFilter
只需要我们指定Request(...dont_filter=False)(默认是False),如果dont_filter=True则告诉scrapy这个URL不参与去重。（******）

仿照RFPDupeFilter自定义去重规则

from scrapy.dupefilters import RFPDupeFilter,看源码，仿照BaseDupeFilter

步骤一：在项目根目录下创建自定义去重文件dupefilters.py
from scrapy.dupefilters import  BaseDupeFilter
#自己定制去重方案
class MyDupeFilter(BaseDupeFilter):

    def __init__(self, path=None, debug=False):
       self.aa=set()

    def request_seen(self, request):   #自定义去重规则在这个函数中写
        if request.url in self.aa:
            return True

    def close(self, reason):
         pass

    def log(self, request, spider):  #日志
         pass

　步骤二：配置文件settings.py
   DUPEFILTER_CLASS = '项目名.dupefilters.MyDupeFilter'   #具体路径看你这个文件的位置在哪

我们可能需要在命令行为爬虫程序传递参数，比如传递初始的url，像这样
#命令行执行
scrapy crawl myspider -a category=electronics

#在__init__方法中可以接收外部传进来的参数
import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'def __init__(self, category=None, *args, **kwargs):
    super(MySpider, self).__init__(*args, **kwargs)
    self.start_urls = ['http://www.example.com/categories/%s' % category]
    #...
​        
#注意接收的参数全都是字符串，如果想要结构化的数据，你需要用类似json.loads的方法

#1 //与/
#2 text
#3、extract与extract_first:从selector对象中解出内容
#4、属性：xpath的属性加前缀@
#4、嵌套查找
#5、设置默认值
#4、按照属性查找
#5、按照属性模糊查找
#6、正则表达式
#7、xpath相对路径
#8、带变量的xpath

import scrapy

class ArticleItem(scrapy.Item):
    article_name = scrapy.Field()
    article_url = scrapy.Field()
    auther_name = scrapy.Field()
    commit_count = scrapy.Field()

import scrapy

class ArticleItem(scrapy.Item):
    article_name = scrapy.Field()
    article_url = scrapy.Field()
    auther_name = scrapy.Field()
    commit_count = scrapy.Field()

    def parse(self, response):
        div_list = response.css('.post_item')  #获取每篇文章
        for div in div_list:
            url=div.css('.post_item_body a::attr(href)').extract_first()
            article_name=div.css('.titlelnk::text').extract_first()
            auther_name=div.css('.post_item_foot a::text').extract_first()
            commit_count=div.css('.post_item_foot span a::text').extract_first()
            article_item=ArticleItem()  #定义的items
            #把地址存入数据库，yield item对象
            article_item['article_name']=article_name
            article_item['article_url']=url
            article_item['auther_name']=auther_name
            article_item['commit_count']=commit_count
            yield article_item  #需要yield item对象才会存入到pipelines存入数据库

        next_url = response.css('.pager a:last-child::attr(href)').extract_first()
        print('https://www.cnblogs.com'+next_url)
        #dont_filter=True 表示不去重，默认去重
        yield Request('https://www.cnblogs.com'+next_url)  #继续请求下一页爬取数据

from pymongo import MongoClient
class ArticleMongodbPipeline(object):
    def process_item(self, item, spider):
        #连接
        client = MongoClient('localhost', 27017)
        #创建article数据库，如果没有叫创建，如果有，叫使用
        db = client['article']
        #如果有使用articleinfo，如果没有，创建这个表
        article_info=db['articleinfo']
        article_info.insert(dict(item))  #插入item数据，可以使用insert或者save方法
        # article_info.save({'article_name':item['article_name'],'aritcle_url':item['article_url']})
        # 如果retrun None ，下一个就取不到item了，取到的就是None

ITEM_PIPELINES = {
   'myproject.pipelines.ArticleMongodbPipeline': 300,  #数字越小越先执行
}

一：可以在pipeline.py中写多个Pipeline类
1、如果优先级高的Pipeline的process_item返回一个值或者None，会自动传给下一个pipline的process_item,
2、如果只想让第一个Pipeline执行，那得让第一个pipline的process_item抛出异常raise DropItem()
3、可以用spider.name == '爬虫名' 来控制哪些爬虫用哪些pipeline

#1、settings.py  （settings中配置数据库的信息）
HOST="127.0.0.1"
PORT=27017
USER="root"
PWD="123"
DB="amazon"
TABLE="goods"



ITEM_PIPELINES = {
   'Amazon.pipelines.CustomPipeline': 200,
}

#2、pipelines.py
class CustomPipeline(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):  #通过from_crawler控制类的创建过程
    　　"""
    　　Scrapy会先通过getattr判断我们是否自定义了from_crawler,有则调它来完成实例化，如果类中有这个函数会先执行这个函数,来控制类的创建过程
    　　"""
    　　HOST = crawler.settings.get('HOST')  #从settings配置文件中获取数据库信息
    　　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)  #类实例化走__init__方法
　　
　　def open_spider(self,spider):  #创建数据库链接
    　　"""
    　　爬虫刚启动时执行一次
    　　"""
    　　self.client = MongoClient('mongodb://%s:%s@%s:%s' %(self.user,self.pwd,self.host,self.port))

　　def close_spider(self,spider):   #数据库连接关闭
    　　"""
    　　爬虫关闭时执行一次
    　　"""
    　　self.client.close()

　　def process_item(self, item, spider):  #进行持久化操作，写入数据库（相当于mogodb数据库中insert步骤）
    　　# 操作并进行持久化

        self.client[self.db][self.table].save(dict(item))  #return返回值如果是item,下一个pipeline能继续能到，如果return None,下一个拿不到

下载中间件的用途：
　　 提供在爬虫过程中修改Request和Response,用于扩展scrapy的功能
    1、在process_request内，自定义下载中间件。
    2、对请求进行二次加工，比如
        设置请求头
        设置cookie
        添加代理
            scrapy自带的代理组件：
                from scrapy.downloadermiddlewares.httpproxy import HttpProxyMiddleware
                from urllib.request import getproxies
　　3、在请求之后，回包需要解压等处理

class DownMiddleware1(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处理完成，返回时调用，当每个Response经过下载中间件会被调用，优先级越高的中间件，越晚被调用
    　　:param response:
    　　:param result:
    　　:param spider:
    　　:return: 
        　　Response 对象：转交给其他中间件process_response
        　　Request 对象：停止中间件，request会被重新调度下载
        　　raise IgnoreRequest 异常：调用Request.errback
    　　"""
    　　return response

　　def process_exception(self, request, exception, spider):
    　　"""
    　　当下载处理器(download handler)或 process_request()和process_response() (下载中间件)抛出异常时会被调用。
    　　:param response:
    　　:param exception:
    　　:param spider:
    　　:return: 
        　　None：继续交给后续中间件处理异常；
        　　Response对象：停止后续process_exception方法
       　　 Request对象：停止中间件，request将会被重新调用下载
    　　"""
    　　return None

#1、与middlewares.py同级目录下新建proxy_handle.py
import requests

def get_proxy():
    return requests.get("http://127.0.0.1:5010/get/").text   #从这个地址获取代理

def delete_proxy(proxy):
    requests.get("http://127.0.0.1:5010/delete/?proxy={}".format(proxy))
    
#2、middlewares.py
from Amazon.proxy_handle import get_proxy,delete_proxy

class DownMiddleware1(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
        """
        proxy="http://" + get_proxy()
        request.meta['download_timeout']=20
        request.meta["proxy"] = proxy
        print('为%s 添加代理%s ' % (request.url, proxy),end='')
        print('元数据为',request.meta)


　　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('返回状态吗',response.status)
    　　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将会被重新调用下载
    　　"""
    　　print('代理%s，访问%s出现异常:%s' %(request.meta['proxy'],request.url,exception))
    　　import time
    　　time.sleep(5)
    　　delete_proxy(request.meta['proxy'].split("//")[-1])
    　　request.meta['proxy']='http://'+get_proxy()

    　　return request

DOWNLOADER_MIDDLEWARES = {
                   'myscrapy.middlewares.DownloaderMiddleware': 543,  #数字越小越先执行
                }

from scrapy import signals

class SpiderMiddleware(object):
    # Not all methods need to be defined. If a method is not defined,
    # scrapy acts as if the spider middleware does not modify the
    # passed objects.

    @classmethod
    def from_crawler(cls, crawler):
        # This method is used by Scrapy to create your spiders.
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened) #当前爬虫执行时触发spider_opened
        return s

　　def spider_opened(self, spider):
    　　# spider.logger.info('我是egon派来的爬虫1: %s' % spider.name)
    　　print('我是egon派来的爬虫1: %s' % spider.name)

　　def process_start_requests(self, start_requests, spider):
    　　# Called with the start requests of the spider, and works
    　　# similarly to the process_spider_output() method, except
    　　# that it doesn’t have a response associated.

    　　# Must return only requests (not items).
    　　print('start_requests1')
    　　for r in start_requests:
        　　yield r

　　def process_spider_input(self, response, spider):
    　　# Called for each response that goes through the spider
    　　# middleware and into the spider.
    　　# 每个response经过爬虫中间件进入spider时调用

    　　# 返回值：Should return None or raise an exception.
    　　#1、None: 继续执行其他中间件的process_spider_input
    　　#2、抛出异常：
    　　# 一旦抛出异常则不再执行其他中间件的process_spider_input
    　　# 并且触发request绑定的errback
    　　# errback的返回值倒着传给中间件的process_spider_output
    　　# 如果未找到errback，则倒着执行中间件的process_spider_exception

    　　print("input1")
    　　return None

　　def process_spider_output(self, response, result, spider):
    　　# Called with the results returned from the Spider, after
    　　# it has processed the response.

    　　# Must return an iterable of Request, dict or Item objects.
    　　print('output1')

    　　# 用yield返回多次，与return返回一次是一个道理
    　　# 如果生成器掌握不好（函数内有yield执行函数得到的是生成器而并不会立刻执行），生成器的形式会容易误导你对中间件执行顺序的理解
    　　# for i in result:
    　　#     yield i
    　　return result

　　def process_spider_exception(self, response, exception, spider):
    　　# Called when a spider or process_spider_input() method
    　　# (from other spider middleware) raises an exception.

    　　# Should return either None or an iterable of Response, dict
    　　# or Item objects.
    　　print('exception1')

from scrapy import signals


class MyExtension(object):

    @classmethod
    def from_crawler(cls, crawler):
        # val = crawler.settings.getint('MMMM')
        obj = cls()

        crawler.signals.connect(obj.spider_opened, signal=signals.spider_opened)
        crawler.signals.connect(obj.spider_closed, signal=signals.spider_closed)

        return obj

    def spider_opened(self, spider):
        print('=============>open')

    def spider_closed(self, spider):
        print('=============>close')

EXTENSIONS = {
               'extentions.MyExtension': 100,
            }