scrapy之Request对象

我们在使用scrapy框架的时候，会经常疑惑，数据流是怎么样在各个组件中间传递的。最近经常用scrapy+selenium爬取淘宝，又因为今天周五心情好，本宝宝决定梳理一下这方面知识。

scrapy中各个组件相互通信的方式是通过request对象和response对象来完成的。也就是说spider和middleware之间的数据传递时通过这两个对象传递的。request对象是在spider中产生的，看代码：

from scrapyseleniumtest.items import ProductItem

class TaobaoSpider(Spider):
    name = ‘taobao‘
    allowed_domains = [‘www.taobao.com‘]
    base_url = ‘https://s.taobao.com/search?q=‘

    def start_requests(self):
        for keyword in self.settings.get(‘KEYWORDS‘):
            for page in range(1, self.settings.get(‘MAX_PAGE‘) + 1):
                url = self.base_url + quote(keyword)
                yield Request(url=url, callback=self.parse, meta={‘page‘: page}, dont_filter=True)

这个是scrapy中的spider，大家看最后的yield Request(url=url, callback=self.parse, meta={‘page‘: page}, dont_filter=True)，这就是将Request类实例化了一个request对象，通过request对象来传递数据。比如在middleware.py中

class SeleniumMiddleware():
    def __init__(self, timeout=None, service_args=[]):
        self.logger = getLogger(__name__)
        self.timeout = timeout
        self.browser = webdriver.Firefox(executable_path="geckodriver.exe")
        self.browser.set_window_size(1400, 700)
        self.browser.set_page_load_timeout(self.timeout)
        self.wait = WebDriverWait(self.browser, self.timeout)

    def __del__(self):
        self.browser.close()

    def process_request(self, request, spider):
        """
        用PhantomJS抓取页面
        :param request: Request对象
        :param spider: Spider对象
        :return: HtmlResponse
        """
        self.logger.debug(‘PhantomJS is Starting‘)
        page = request.meta.get(‘page‘, 1)

　　在process_request(self, request, spider)中，我们看到了第二个参数是request，这个就是request对象，一个request对象代表一个HTTP请求，通常有Spider产生，经Downloader执行从而产生一个Response。但是呢，这里我们使用了selenium，这个reponse就不是Downloader执行产生的了，而是由火狐浏览器对象browser代替Downloader完成了下载(页面加载)，然后构筑了一个HtmlResponse对象，返回给了spider进行解析，request对象到这里也就不在继续处理了。看downloadmiddleware的完整代码：

from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from scrapy.http import HtmlResponse
from logging import getLogger

class SeleniumMiddleware():
    def __init__(self, timeout=None, service_args=[]):
        self.logger = getLogger(__name__)
        self.timeout = timeout
        self.browser = webdriver.Firefox(executable_path="geckodriver.exe")
        self.browser.set_window_size(1400, 700)
        self.browser.set_page_load_timeout(self.timeout)
        self.wait = WebDriverWait(self.browser, self.timeout)

    def __del__(self):
        self.browser.close()

    def process_request(self, request, spider):
        """
        用PhantomJS抓取页面
        :param request: Request对象
        :param spider: Spider对象
        :return: HtmlResponse
        """
        self.logger.debug(‘PhantomJS is Starting‘)
        page = request.meta.get(‘page‘, 1)
        try:
            self.browser.get(request.url)
            if page > 1:
                input = self.wait.until(
                    EC.presence_of_element_located((By.CSS_SELECTOR, ‘#mainsrp-pager div.form > input‘)))
                submit = self.wait.until(
                    EC.element_to_be_clickable((By.CSS_SELECTOR, ‘#mainsrp-pager div.form > span.btn.J_Submit‘)))
                input.clear()
                input.send_keys(page)
                submit.click()
            self.wait.until(
                EC.text_to_be_present_in_element((By.CSS_SELECTOR, ‘#mainsrp-pager li.item.active > span‘), str(page)))
            self.wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ‘.m-itemlist .items .item‘)))
            return HtmlResponse(url=request.url, body=self.browser.page_source, request=request, encoding=‘utf-8‘,
                                status=200)
        except TimeoutException:
            return HtmlResponse(url=request.url, status=500, request=request)

    @classmethod
    def from_crawler(cls, crawler):
        return cls(timeout=crawler.settings.get(‘SELENIUM_TIMEOUT‘),
                   service_args=crawler.settings.get(‘PHANTOMJS_SERVICE_ARGS‘))

然后根据scrapy官方文档的解释，看看request对象的一些具体参数：

1,Request objects

class scrapy.http.Request(url[, callback, method=‘GET‘, headers, body, cookies, meta, encoding=‘utf-8‘, priority=0, dont_filter=False, errback])

一个request对象代表一个HTTP请求，通常有Spider产生，经Downloader执行从而产生一个Response。

Paremeters:     url(string): 用于请求的URL

callback(callable):指定一个回调函数，该回调函数以这个request是的response作为第一个参数。如果未指定callback，

则默认使用spider的parse()方法。

method(string):HTTP请求的方法，默认为GET（看到GET你应该明白了，过不不明白建议先学习urllib或者requets模块）

meta(dict):指定Request.meta属性的初始值。如果给了该参数，dict将会浅拷贝。(浅拷贝不懂的赶紧回炉)

body(str):the request body.(这个没有理解，若有哪位大神明白，请指教，谢谢）

headers(dict):request的头信息。

cookies(dict or list):cookie有两种格式。

1、使用dict:

request_with_cookies = Request(url="http://www.example.com", cookies={‘currency‘: ‘USD‘, ‘country‘: ‘UY‘})

2、使用字典的list

request_with_cookies = Request(url="http://www.example.com",
                               cookies=[{‘name‘: ‘currency‘,
                                        ‘value‘: ‘USD‘,
                                        ‘domain‘: ‘example.com‘,
                                        ‘path‘: ‘/currency‘}])

后面这种形式可以定制cookie的domain和path属性，只有cookies为接下来的请求保存的时候才有用。

当网站在response中返回cookie时，这些cookie将被保存以便未来的访问请求。这是常规浏览器的行为。如果你想避免修改当前

正在使用的cookie,你可以通过设置Request.meta中的dont_merge_cookies为True来实现。

request_with_cookies = Request(url="http://www.example.com",
                               cookies={‘currency‘: ‘USD‘, ‘country‘: ‘UY‘},
                               meta={‘dont_merge_cookies‘: True})

encoding(string):请求的编码， 默认为utf-8

priority(int):请求的优先级

dont_filter(boolean):指定该请求是否被 Scheduler过滤。该参数可以是request重复使用（Scheduler默认过滤重复请求）。谨慎使用！！

errback(callable):处理异常的回调函数。

属性和方法：

url: 包含request的URL的字符串

method: 代表HTTP的请求方法的字符串，例如‘GET‘, ‘POST‘...

headers: request的头信息

body: 请求体

meta: 一个dict，包含request的任意元数据。该dict在新Requests中为空，当Scrapy的其他扩展启用的时候填充数据。dict在传输是浅拷贝。

copy(): 拷贝当前Request

replace([url, method, headers, body, cookies, meta, encoding, dont_filter, callback, errback]): 返回一个参数相同的Request，

可以为参数指定新数据。

给回调函数传递数据

当request的response被下载是，就会调用回调函数，并以response对象为第一个参数

def parse_page1(self, response):
    return scrapy.Request("http://www.example.com/some_page.html",
                          callback=self.parse_page2)

def parse_page2(self, response):
    # this would log http://www.example.com/some_page.html
    self.logger.info("Visited %s", response.url)

example

在某些情况下，你希望在回调函数们之间传递参数，可以使用Request.meta。（其实有点类似全局变量的赶脚）

def parse_page1(self, response):
    item = MyItem()
    item[‘main_url‘] = response.url
    request = scrapy.Request("http://www.example.com/some_page.html",
                             callback=self.parse_page2)
    request.meta[‘item‘] = item
    yield request

def parse_page2(self, response):
    item = response.meta[‘item‘]
    item[‘other_url‘] = response.url
    yield item

使用errback来捕获请求执行中的异常

当request执行时有异常抛出将会调用errback回调函数。

它接收一个Twisted Failure实例作为第一个参数，并被用来回溯连接超时或DNS错误等。

 1 import scrapy
 2
 3 from scrapy.spidermiddlewares.httperror import HttpError
 4 from twisted.internet.error import DNSLookupError
 5 from twisted.internet.error import TimeoutError, TCPTimedOutError
 6
 7 class ErrbackSpider(scrapy.Spider):
 8     name = "errback_example"
 9     start_urls = [
10         "http://www.httpbin.org/",              # HTTP 200 expected
11         "http://www.httpbin.org/status/404",    # Not found error
12         "http://www.httpbin.org/status/500",    # server issue
13         "http://www.httpbin.org:12345/",        # non-responding host, timeout expected
14         "http://www.httphttpbinbin.org/",       # DNS error expected
15     ]
16
17     def start_requests(self):
18         for u in self.start_urls:
19             yield scrapy.Request(u, callback=self.parse_httpbin,
20                                     errback=self.errback_httpbin,
21                                     dont_filter=True)
22
23     def parse_httpbin(self, response):
24         self.logger.info(‘Got successful response from {}‘.format(response.url))
25         # do something useful here...
26
27     def errback_httpbin(self, failure):
28         # log all failures
29         self.logger.error(repr(failure))
30
31         # in case you want to do something special for some errors,
32         # you may need the failure‘s type:
33
34         if failure.check(HttpError):
35             # these exceptions come from HttpError spider middleware
36             # you can get the non-200 response
37             response = failure.value.response
38             self.logger.error(‘HttpError on %s‘, response.url)
39
40         elif failure.check(DNSLookupError):
41             # this is the original request
42             request = failure.request
43             self.logger.error(‘DNSLookupError on %s‘, request.url)
44
45         elif failure.check(TimeoutError, TCPTimedOutError):
46             request = failure.request
47             self.logger.error(‘TimeoutError on %s‘, request.url)

example

Request.meta的特殊关键字

Request.meta可以包含任意的数据，但Scrapy和内置扩展提供了一些特殊的关键字

  • dont_redirect             （其实dont就是don‘t,嗯哼~）
  • dont_retry
  • handle_httpstatus_list
  • handle_httpstatus_all
  • dont_merge_cookies (see cookies parameter of Request constructor)
  • cookiejar
  • dont_cache
  • redirect_urls
  • bindaddress
  • dont_obey_robotstxt
  • download_timeout(下载超时)
  • download_maxsize
  • download_latency(下载延时)
  • proxy

原文地址：https://www.cnblogs.com/chaojiyingxiong/p/10220511.html

时间： 2024-11-02 07:58:06

scrapy之Request对象的相关文章

Scrapy源码 Request对象

Scrapy源码 Request对象 """This module implements the Request class which is used to represent HTTPrequests in Scrapy. See documentation in docs/topics/request-response.rst"""import sixfrom w3lib.url import safe_url_string from sc

Webform 内置对象 Response对象、Request对象，QueryString

Request对象:获取请求Request["key"]来获取传递过来的值 QueryString:地址栏数据传递 ?key=value&key=value注意事项:不需要保密的东西可以传不要传过长东西,因为长度有限,过长会造成数据丢失 Response对象:响应请求Response.Write("<script>alert('添加成功!')</script>");Response.Redirect("Default.asp

Filter中request对象强转问题

以下为过滤器doFIlter方法的源代码: public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest req = (HttpServletRequest)request; HttpServletResponse res = (HttpServletRespons

Request 对象

Request 对象用于检索从浏览器向服务器发送的请求中的信息. 1.使用Request对象的Browser属性,可以访问HttpBrowserCapabilities属性获得当前正在使用哪种类型的浏览器浏览页面,并可以获得该浏览器是否支持某些特定功能. protected void Page_Load(object sender, EventArgs e) { HttpBrowserCapabilities b = Request.Browser; Response.Write("客户端浏览器

在SpringMVC中获取request对象的几种方式

1.最简单的方式(注解法) 1 2 @Autowired private  HttpServletRequest request; 2.最麻烦的方法 a. 在web.xml中配置一个监听 <listener> <listener-class> org.springframework.web.context.request.RequestContextListener </listener-class> </listener> b.之后在程序里可以用 Http

调用Request对象的post方法把RequestBody传入进去

通过调用登录接口发送一个post请求.跟get不一样的地方就是传参数不一样,post请求需要把参数封装到RequestBody对象,调用Request对象的post方法把RequestBody传入进去.最后调用execute方法执行请求,这个方法前面get请求的时候讲过. http://bbs.guilinlife.com/thread-9125238-1-1.htmlhttp://bbs.guilinlife.com/thread-9125240-1-1.htmlhttp://bbs.guil

request对象和response对象

Request 和 Response 对象起到了服务器与客户机之间的信息传递作用.Request 对象用于接收客户端浏览器提交的数据,而 Response 对象的功能则是将服务器端的数据发送到客户端浏览器. web服务器收到客户端的HTTP请求,会针对每一次请求分别创建一个用于代表请求的request对象和代表响应的response对象. 1.要得到客户机提交过来的数据,只需要找request对象就行. 2.要向客户机输出数据,只需要找response对象就行. response.setChar

重温Servlet学习笔记--request对象

request和response是一对搭档,一个负责请求一个负责响应,都是Servlet.service()方法的参数,response的知识点前面梳理过了,这里只说一下request,在客户端发出每个请求时,服务器都会创建一个request对象,把请求的数据封装到request中,然后在调用Servlet.service()中传递进去.我们在创建一个servlet时通常会使用doGet或者doPost方法,并没有看到service()方法,就是因为父类的service方法已经读取到了reque

Servlet中的request对象、重定向和转发的差别（6）

1.这里所说的request对象指的是HttpServletRequest对象,它代表client的请求,当client通过HTTP协议訪问server时.HTTP请求头中的全部信息都封装在这个对象中.我们通过request对象调用里面的方法,能够获得客户发送给webserver的各种信息. 2.request的经常用法 (1)获得客户机信息     getRequestURL方法返回client发出请求时的完整URL.(                                比如:ur