scrapy模拟登录

注意：模拟登陆时，必须保证settings.py里的COOKIES_ENABLED(Cookies中间件) 处于开启状态

COOKIES_ENABLED = True
或# COOKIES_ENABLED = False

策略一：直接POST数据（比如需要登陆的账户信息)

只要是需要提供post数据的，就可以用这种方法。下面示例里post的数据是账户密码：

可以使用yield scrapy.FormRequest(url, formdata, callback)方法发送POST请求。
如果希望程序执行一开始就发送POST请求，可以重写Spider类的start_requests(self)方法，并且不再调用start_urls里的url。

import scrapy

class MyrenrenSpider(scrapy.Spider):

    name = 'myrenren'

    allowed_domains = ['renren.com']

    # start_urls = ['http://renren.com/']

    #重写start_requests()方法，爬虫首先调用这个方法，

    # 程序不再调用start_urls里的url

    def start_requests(self):

        loginUrl = "http://www.renren.com/PLogin.do"

        # 表单数据提交

        # formdata 表单数据

        # callback 登录后回调

        yield scrapy.FormRequest(url=loginUrl,

                                 formdata={"email": "你的账号",

                                      "password": "你的密码"},

                                 callback=self.parse

                                 )

    def parse(self, response):

        print('*******',response.url)

        print(response.body.decode('utf-8'))

策略二：标准的模拟登陆步骤

正统模拟登录方法：

首先发送登录页面的get请求，获取到页面里的登录必须的参数（比如说zhihu登陆界面的 _xsrf）

然后和账户密码一起post到服务器，登录成功

使用FormRequest.from_response()方法[模拟用户登录]

模拟浏览器登录

start_requests()方法，可以返回一个请求给爬虫的起始网站，这个返回的请求相当于start_urls，start_requests()返回的请求会替代start_urls里的请求

Request()get请求，可以设置，url、cookie、回调函数

FormRequest.from_response()表单post提交，第一个必须参数，上一次响应cookie的response对象，其他参数，cookie、url、表单内容等

yield Request()可以将一个新的请求返回给爬虫执行

在发送请求时cookie的操作， meta={‘cookiejar’:1}表示开启cookie记录，首次请求时写在Request()里 meta={‘cookiejar’:response.meta[‘cookiejar’]}表示使用上一次response的cookie，写在FormRequest.from_response()里post授权 meta={‘cookiejar’:True}表示使用授权后的cookie访问需要登录查看的页面

正统模拟登录方法

范例：爬取人人网个人主页：

# -*- coding: utf-8 -*-

import scrapy

from scrapy.http import HtmlResponse

from scrapy.spiders import Rule, CrawlSpider

from scrapy.linkextractors import LinkExtractor

class MyrenrenSpider(CrawlSpider):

    name = 'myrenren2'

    allowed_domains = ['renren.com']

    #个人主页

    start_urls = ['http://www.renren.com/353111356/profile']

    #爬取多个人的主页

    rules = [Rule(LinkExtractor(allow=("(\d+)/profile")),callback="get_parse",follow=True)]

    # 爬虫开启时调用的第一个方法，只调用一次

    def start_requests(self):

        indexURL = "http://www.renren.com"

        # 表单数据提交

        # formdata 表单数据

        # callback 登录后回调

        yield scrapy.FormRequest(url=indexURL,

              # 开启cookie， 用来保存cookie,在setting把COOKIES_ENABLED设为True

                                 meta={"cookiejar":1},

                                 callback=self.login

                                 )

    def login(self,response):

        print('访问主页返回的的url',response.url)

        # 从响应里面获取认证牌

        loginUrl = "http://www.renren.com/PLogin.do"

        yield scrapy.FormRequest.from_response(response,#响应

                                               url=loginUrl,# 登录url

                                               #表单数据

                                               formdata={"email": "你的值",

                                                         "password": "你的密码",},

                                               meta={"cookiejar": response.meta['cookiejar']},  # 传递cookie

                                               callback=self.after_login

                                               )

    #登录后

    def after_login(self,response):

        print('登录后返回的url',response.url)

        for url in self.start_urls:

            yield scrapy.Request(url,meta={"cookiejar": response.meta['cookiejar']})

    # 重写CrawlSpider中_requests_to_follow()方法

    def _requests_to_follow(self, response):

        """重写加入cookiejar的更新"""

        print('跟踪的url',response.url)

        if not isinstance(response, HtmlResponse):

            return

        seen = set()

        for n, rule in enumerate(self._rules):

            links = [lnk for lnk in rule.link_extractor.extract_links(response)

                     if lnk not in seen]

            if links and rule.process_links:

                links = rule.process_links(links)

            for link in links:

                seen.add(link)

                r = self._build_request(n, link)

                # 更新cookie

                r.meta.update(rule=n, link_text=link.text, cookiejar=response.meta['cookiejar'])

                yield rule.process_request(r)

    #处理爬取得到的网页函数

    def get_parse(self, response):

        print('追踪后返回的url',response.url)

        print(response.body.decode('utf-8'))

策略三：直接使用保存登录状态的Cookie模拟登录

如果实在没办法了，可以用这种方法模拟登录，虽然麻烦一点，但是成功率100%

先登录网页，获取cookie,然后转化为字典，保存在settings.py中的COOKIES池中，使用中间件用cookie登录。

1、cookie,转化为字典

def cookieChangeToDict(cookie):

    '''

    将cookie字符串转换成字典

    :param cookie: 登录后的cookie

    :return:字典

    '''

    cookieList = cookie.split(';')

    cookieDict = {}

    for cookie in cookieList:

        name = cookie.split('=', maxsplit=1)[0].strip()

        value = cookie.split('=', maxsplit=1)[1].strip()

        cookieDict[name] = value

    return cookieDict

if __name__ == '__main__':

    cookie = """

    你的cookie

    """

    print(cookieChangeToDict(cookie))

#把打印出的cookie放到settings.py中自定义的COOKIES=[]中

2、使用登录后的cookie发送请求

方式一：

# 可以重写Spider类的start_requests方法，附带Cookie值，发送POST请求

    def start_requests(self):

        url= ''

        return [scrapy.FormRequest(url, cookies = self.cookies, callback = self.parse)]

方式2：使用中间件：

from scrapy import signals

from scrapy.downloadermiddlewares.cookies import CookiesMiddleware

import random

from renren.settings import COOKIES

class RandomCookieMiddleware(CookiesMiddleware):

    '''

    随机cookie池

    '''

    def process_request(self, request, spider):

        cookie = random.choice(COOKIES)

        request.cookies = cookie

在settings.py中设置：



ROBOTSTXT_OBEY = False

COOKIES_ENABLED = True

#启用中间件

DOWNLOADER_MIDDLEWARES = {

   'renren.middlewares.RandomCookieMiddleware': 543,

}

# COOKIES池

COOKIES = [

]

策略四：使用selenium插件

1、模拟pc端登录CSDN

爬虫：

class CSDNSpider(scrapy.Spider):

    name = 'myCSDN'

    allowed_domains = ['csdn.net']

    start_urls = ['http://passport.csdn.net/account/login',

                  'http://my.csdn.net/my/account/changepwd']

    def __init__(self):

        super().__init__()

        driver = None  # 实例selenium

        cookies = None  # 用来保存cookie

    def parse(self, response):

        print(response.url)

        print(response.body.decode('utf-8'))

中间件：

class LoginMiddleware(object):

    # type()元类，object 基类

    def process_request(self, request, spider):

        '''

        :param request: 请求

        :param spider: 爬虫名

        :return:

        '''

        # 判断是哪个爬虫

        if spider.name == 'myCSDN':

            # 判断是否是登陆

            if request.url.find('login') != -1:

                spider.driver = webdriver.Chrome()

                spider.driver.get(request.url)

                spider.driver.find_element_by_xpath('/html/body/div[3]/div/div/div[2]/div/h3/a').click()

                time.sleep(2)

                #模拟输入账号密码

                username = spider.driver.find_element_by_xpath('//*[@id="username"]')

                password = spider.driver.find_element_by_xpath('//*[@id="password"]')

                username.send_keys('18588403840')

                password.send_keys('Changeme_123')

                #模拟点击“登录”按钮

                spider.driver.find_element_by_xpath('//*[@id="fm1"]/input[8]').click()

                time.sleep(3)

                spider.cookies = spider.driver.get_cookies()

                return HtmlResponse(url=spider.driver.current_url,  # 登录后的url

                                    body=spider.driver.page_source,  # html源码

                                    encoding='utf-8')

            # 不是登录

            else:

                # 使用session保存cookie

                session = request.session()

                for cookie in spider.cookies:

                    session.cookies.set(cookie['name'], cookie['value'])

                # 清空头

                session.headers.clear()

                response = session.get(request.url)

                return HtmlResponse(url=response.url,

                                    body=response.text,

                                    encoding='utf-8')