有條件的請支持慕課實戰(zhàn)正版課程，本blog僅僅是歸納總結，自用。

一、爬蟲與反爬蟲基本概念

爬蟲與反爬蟲基本概念

• 誤傷：由于學校、網吧等等用的是同一個公網ip，而內部使用局域網，所以如果封禁了此ip，會導致大量用戶的流失，同時還有動態(tài)ip分配的存在，所以在反爬蟲中，封禁ip的策略一般網站不會使用，最多是封禁ip一小段時間。

二、反爬目的

反爬蟲目的

三、爬蟲與反爬的對抗史

對抗史

四、scrapy架構

新版官方的架構圖

• spider出去的鏈接會先經過scheduler，才會到downloader中。

• site-package/scrapy/core源碼中，只有engine、scheduler、downloader三個核心組件，其余的都是我們程序員要寫的。

• 注意4、5步驟中的middleware，這是我們的重點關注對象。

五、突破反爬取的策略

5.1 隨機切換用戶代理User-Agent

• 簡單實現(xiàn)：
  維護一個包含很多User-Agent的列表，每次在Request yield時，使用random函數(shù)隨機選一個User-Agent傳入Request header。但是這種方法冗余度高，不利于復用。

• Middleware實現(xiàn)：
  自定義一個Downloader Middleware，可以做到每次請求時，攔截一下，給請求頭自動隨機更換User-Agent。

注意參考上面的結構圖，scrapy里有兩個Middleware，我們要自定義的是右邊的Downloader Middleware

• 首先為了方便獲得用戶代理的列表，我們安裝fake-useragent這個開源庫,具體用法github上有寫，不再贅述：

pip install fake-useragent

注意，fake-useragent庫維護的user-agent列表存放在在線網頁上，過低版本依賴的列表網頁可能就會403，所以請記得更新fake-useragent

• 接下來我們參考一下源碼自帶的用戶代理Downloader Middleware：

"""Set User-Agent header per spider or use a default value from settings"""

from scrapy import signals


class UserAgentMiddleware(object):
    """This middleware allows spiders to override the user_agent"""
    
    #缺省使用'Scrapy'作為用戶代理，這很糟糕
    def __init__(self, user_agent='Scrapy'):
        self.user_agent = user_agent

    @classmethod
    def from_crawler(cls, crawler):
        o = cls(crawler.settings['USER_AGENT'])
        crawler.signals.connect(o.spider_opened, signal=signals.spider_opened)
        return o

    def spider_opened(self, spider):
        self.user_agent = getattr(spider, 'user_agent', self.user_agent)
    
    #此方法是關鍵，會給我們的請求加上默認的user-agent
    def process_request(self, request, spider):
        if self.user_agent:
            request.headers.setdefault(b'User-Agent', self.user_agent)

• 下一步就是模仿它，寫一個我們自己的隨機更換的Downloader Middleware，middlewares.py中加入：

from fake_useragent import UserAgent
class RandomUserAgentMiddlware(object):
    '''
    隨機更換user-agent
    模仿并替換site-package/scrapy/downloadermiddlewares源代碼中的
    useragent.py中的UserAgentMiddleware類
    '''

    def __init__(self, crawler):
        super(RandomUserAgentMiddlware, self).__init__()
        self.ua = UserAgent()
        #可讀取在settings文件中的配置，來決定開源庫ua執(zhí)行的方法，默認是random，也可是ie、Firefox等等
        self.ua_type = crawler.settings.get("RANDOM_UA_TYPE", "random")

    @classmethod
    def from_crawler(cls, crawler):
        return cls(crawler)
    
    #更換用戶代理邏輯在此方法中
    def process_request(self, request, spider):
        def get_ua():
            return getattr(self.ua, self.ua_type)

        print  get_ua()
        request.headers.setdefault('User-Agent', get_ua())

• 最后不能忘記，在settings.py中開啟我們的Middleware，同時還要關閉scrapy自帶的代理Middleware：

# Enable or disable downloader middlewares
# See http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html
DOWNLOADER_MIDDLEWARES = {
   'JobSpider.middlewares.RandomUserAgentMiddlware': 543,
   'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

• 至此，每次請求的user-agent已隨機更換

5.2 隨機更換代理ip策略

• 目前，很多小區(qū)、公共wifi的ip是動態(tài)分配的，當重啟路由器、光貓后，本機的對外ip可能會發(fā)生改變。所以，若本機ip被封，可重啟以求換ip。對外ip可直接百度查看：

查看本機對外ip

5.2.1 ip代理概念

• 直接訪問網站

直接訪問

• 使用ip代理之后訪問網站，可避免本機的ip暴露：

通過代理服務器中轉

• 設置ip代理很簡單,一行搞定：

request.meta['proxy'] = 'xxx.xx.xx.xxx:xx'

• 為了獲取代理ip，我們可以前往西刺網獲取免費的來試用（正式爬取建議買付費的）。

高匿代理：能將我們的本機ip完全隱藏，普通代理可能還是會將本機ip帶給服務器

5.2.2 編寫爬取西刺代理腳本

• 目的是通過小型爬蟲，預先爬取西刺的免費代理ip后全部存入數(shù)據(jù)庫，并且存在一個方法能從數(shù)據(jù)庫中隨機選取一個代理ip，供給我們的爬蟲使用。

#!/usr/bin/env python
# encoding: utf-8
"""
@author: yousheng
@contact: 1197993367@qq.com
@site: http://youyuge.cn

@version: 1.0
@license: Apache Licence
@file: crawl_ip.py
@time: 17/9/27 下午3:06

"""

import requests #用requests庫來做簡單的網絡請求
import MySQLdb
from scrapy.selector import Selector
#從scrapy的settings中導入數(shù)據(jù)庫配置
from JobSpider.settings import MYSQL_HOST, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DBNAME

conn = MySQLdb.connect(host=MYSQL_HOST, user=MYSQL_USER, passwd=MYSQL_PASSWORD,
                       db=MYSQL_DBNAME, charset='utf8')
cursor = conn.cursor()


def clear_table():
    # 清空表內容
    cursor.execute('truncate table proxy_ip')
    conn.commit()


def crawl_xici_ip(pages):
    '''
    爬取一定頁數(shù)上的所有代理ip,每爬完一頁，就存入數(shù)據(jù)庫
    :return:
    '''
    clear_table()
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0"}
    for i in range(1, pages):
        response = requests.get(url='http://www.xicidaili.com/nn/{0}'.format(i), headers=headers)

        all_trs = Selector(text=response.text).css('#ip_list tr')

        ip_list = []
        for tr in all_trs[1:]:
            ip = tr.xpath('td[2]/text()').extract_first().encode('utf8')
            port = tr.xpath('td[3]/text()').extract_first().encode('utf8')
            ip_type = tr.xpath('td[6]/text()').extract_first().encode('utf8')
            ip_speed = tr.xpath('td[7]/div/@title').extract_first()
            if ip_speed:
                ip_speed = float(ip_speed.split(u'秒')[0])
            ip_alive = tr.xpath('td[9]/text()').extract_first().encode('utf8')

            ip_list.append((ip, port, ip_type, ip_speed, ip_alive))

        # 每頁提取完后就存入數(shù)據(jù)庫
        for ip_info in ip_list:
            cursor.execute(
                "insert proxy_ip(ip, port, type, speed, alive) VALUES('{0}', '{1}', '{2}', {3}, '{4}')".format(
                    ip_info[0], ip_info[1], ip_info[2], ip_info[3], ip_info[4]
                )
            )

            conn.commit()


# ip的管理類
class IPUtil(object):
    # noinspection SqlDialectInspection
    def get_random_ip(self):
        # 從數(shù)據(jù)庫中隨機獲取一個可用的ip
        random_sql = """
              SELECT ip, port, type FROM proxy_ip
            ORDER BY RAND()
            LIMIT 1
            """

        result = cursor.execute(random_sql)
        for ip_info in cursor.fetchall():
            ip = ip_info[0]
            port = ip_info[1]
            ip_type = ip_info[2]

            judge_re = self.judge_ip(ip, port, ip_type)
            if judge_re:
                return "{2}://{0}:{1}".format(ip, port, str(ip_type).lower())
            else:
                return self.get_random_ip()

    def judge_ip(self, ip, port, ip_type):
        # 判斷ip是否可用，如果通過代理ip訪問百度，返回code200則說明可用
        # 若不可用則從數(shù)據(jù)庫中刪除
        print 'begin judging ---->', ip, port, ip_type
        http_url = "https://www.baidu.com"
        proxy_url = "{2}://{0}:{1}".format(ip, port, str(ip_type).lower())
        try:
            proxy_dict = {
                "http": proxy_url,
            }
            response = requests.get(http_url, proxies=proxy_dict)
        except Exception as e:
            print "invalid ip and port,cannot connect baidu"
            self.delete_ip(ip)
            return False
        else:
            code = response.status_code
            if code >= 200 and code < 300:
                print "effective ip"
                return True
            else:
                print  "invalid ip and port,code is " + code
                self.delete_ip(ip)
                return False

    # noinspection SqlDialectInspection
    def delete_ip(self, ip):
        # 從數(shù)據(jù)庫中刪除無效的ip
        delete_sql = """
            delete from proxy_ip where ip='{0}'
        """.format(ip)
        cursor.execute(delete_sql)
        conn.commit()
        return True

if __name__ == '__main__':
    crawl_xici_ip(pages=3)
    # ip = IPUtil()
    # for i in range(20):
    #     print ip.get_random_ip()

• 接著我們就可編寫我們的隨機代理ip Middleware了：

from tools.crawl_ip import IPUtil
class RandomProxyMiddleware(object):
    # 動態(tài)設置ip代理
    def process_request(self, request, spider):
        ip_util = IPUtil()
        proxy_ip = ip_util.get_random_ip()
        print 'using ip proxy:', proxy_ip
        request.meta["proxy"] = proxy_ip

• 最后，別忘了在settings中進行配置Downloader Middleware

六、第三方庫推薦

scrapy-proxies：封裝好的ip代理工具
crawlera：官方ip代理插件，需要去官網購買key，可靠穩(wěn)定，強大
tor洋蔥網絡 : 匿名發(fā)送數(shù)據(jù)，需要翻墻,穩(wěn)定性非常高