爬虫之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也会重新下载

1. process_request(request, spider)
当每个request通过下载中间件时，该方法被调用，这里可以修改UA，代理，Refferer

2. process_response(request, response, spider)
这里可以看返回是否是200加入重试机制

3. process_exception(request, exception, spider)
这里可以处理超时

4. SpiderMiddleware主要处理解析Item的相关逻辑修正，比如数据不完整要添加默认，增加其他额外信息等
process_spider_input(response, spider)
当response通过spider中间件时，该方法被调用，处理该response。


rocess_spider_output(response, result, spider)
当Spider处理response返回result时，该方法被调用。

process_spider_exception(response, exception, spider)
当spider或(其他spider中间件的) process_spider_input()
抛出异常时， 该方法被调用。

1. Linux系统
    pip3 install scrapy  # 从官网下载
    pip3 install -i https://pypi.douban.com/simple/ scrapy  # 从豆瓣源下载


2. Windows
    1. pip install -i https://pypi.douban.com/simple/ wheel

    2. 下载twisted： http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted

    3. 进入下载目录，执行命令：pip3 install Twisted-18.9.0-cp36-cp36m-win_amd64.whl

    4. pip3 install -i https://pypi.douban.com/simple/ pywin32

    5. pip3 install -i https://pypi.douban.com/simple/ 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

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‘])

1、一般创建爬虫文件时，以网站域名命名
2、默认只能在终端执行命令，为了更便捷操作：
# 在项目根目录下新建：entrypoint.py
from scrapy.cmdline import execute
execute([‘scrapy‘, ‘crawl‘, ‘qsbk‘, ‘--nolog‘])

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自带的选择器，获取到的数据都是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对象的内容提取出来

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

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

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对象是用于收集抓取数据的简单容器。它们提供类似字典的 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

# 大概在settings的67行设置pipeline类，
ITEM_PIPELINES = {
   ‘Amazon.pipelines.AmazonPipeline‘: 300,
}

每个项管道组件都是一个以下方法的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的一种方式。

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

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. 把下载到的程序放到我们爬虫程序中
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

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