爬虫框架Scrapy笔记-反爬虫小结

随机变换User-Agent

实现思路

单一User-Agent：每次请求都使用相同的User-Agent的话，可以直接在settings.py文件中配置

不同User-Agent方法一：

维护一个包含很多User-Agent的列表。每次在Request yield时，使用random函数随机选一个User-Agent传入Request header

不同User-Agent方法二：

通过fake-useragent来随机获取要使用的User-Agent

写一个中间件实现每次请求时，给请求头配置一个随机的User-Agent

安装fake-useragent：pip install fake-useragent
修改middlewares.py文件，添加RandomUserAgentMiddlware

# ...
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执行的方法，默认是random，也可是ie、Firefox等等
        self.ua_type = crawler.settings.get("RANDOM_UA_TYPE", "random")

    # from_crawler():通过参数crawler可以拿到配置的信息，我们的User-Agent在配置文件里，所以我们需要获取到。方法名不可以修改
    @classmethod
    def from_crawler(cls, crawler):
        return cls(crawler)
    
    #更换用户代理逻辑在此方法中
    def process_request(self, request, spider):
        def get_ua():
            '''Gets random UA based on the type setting (random, firefox…)'''
            return getattr(self.ua, self.ua_type)

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

修改settings.py文件，开启自定义的Middleware。同时还要关闭scrapy自带的代理Middleware

# ...
DOWNLOADER_MIDDLEWARES = {
   'demo.middlewares.RandomUserAgentMiddlware': 543,
   'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}
# ...

这样每次请求的User-Agent已经可以随机更换了

设置代理IP

一个可行的自动更换代理的爬虫系统，应该有如下的3个功能。

有一个小爬虫ProxySpider去各大代理网站爬取免费代理并验证，将可以使用的代理IP保存到数据库中。

在ProxyMiddlerware的process_request中，每次从数据库里面随机选择一条代理IP地址使用。

周期性验证数据库中的无效代理，及时将其删除。

由于免费代理极其容易失效，因此如果有一定开发预算的话，建议购买专业代理机构的代理服务，高速而稳定。

设置ip代理：request.meta['proxy'] = 'http://xxx.xx.xx.xxx:xx'

为了获取代理ip，我们可以前往西刺网获取免费的来试用（正式爬取建议买付费的）

添加爬取代理ip列表的爬虫

# -*- coding: utf-8 -*-
import requests #用requests库来做简单的网络请求
import MySQLdb
from scrapy.selector import Selector
#从scrapy的settings中导入数据库配置
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):
    '''
    爬取一定页数上的所有代理ip,每爬完一页，就存入数据库
    :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))

        # 每页提取完后就存入数据库
        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):
      # 从数据库中随机获取一个可用的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则说明可用
        # 若不可用则从数据库中删除
        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):
        # 从数据库中删除无效的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()

修改middlewares.py文件，设置随机代理

from tools.crawl_ip import IPUtil
class RandomProxyMiddleware(object):
    # 动态设置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.py文件，使用Middleware

DOWNLOADER_MIDDLEWARES = {
    'demo.middlewares.RandomProxyMiddleware':542,
    'demo.middlewares.RandomUserAgentMiddlware': 543,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

开发Cookies中间件

思路

对于需要登录的网站，可以使用Cookies来保持登录状态

单独写一个小程序，用Selenium持续不断地用不同的账号登录网站，就可以得到很多不同的Cookies

把得到的Cookies放在Redis里面

当Scrapy爬虫请求网页时，可以从Redis中读取Cookies并给爬虫换上。这样爬虫就可以一直保持登录状态

新建一个helper.py文件，用于登录页面，拿到Cookies

import time
import json
import redis
from selenium import webdriver

client = redis.StrictRedis()
driver = webdriver.Chrome()
driver.get('http://exercise.kingname.info/exercise_login_success')
driver.find_element_by_xpath('//input[@name="username"]').send_keys('kingname')
driver.find_element_by_xpath('//input[@name="password"]').send_keys('genius')
driver.find_element_by_xpath('//input[@name="rememberme"]').click()
driver.find_element_by_xpath('//button[@class="login"]').click()
time.sleep(2)
cookies = driver.get_cookies()
client.lpush('cookies', json.dumps(cookies))
driver.quit()

修改middlewares.py，写一个中间件，从Redis中读取Cookies，并把这个Cookies给Scrapy使用

import json
import redis

class LoginMiddleware(object):
    def __init__(self):
        self.client = redis.StrictRedis()
    
    def process_request(self, request, spider):
        if spider.name == 'loginSpider':
            cookies = json.loads(self.client.lpop('cookies').decode())
            request.cookies = cookies

爬虫框架Scrapy笔记-反爬虫小结

随机变换User-Agent

设置代理IP

开发Cookies中间件

发表评论

热门标签

随便看看