scrapy学习之爬虫练习平台4

前言

上一篇文章讲了如何使用 scrapy 和 selenium 搭配来爬取数据,这篇文章来写一下如何用 selenium 来爬取使用 Ajax 加载数据的网站并且过掉反爬。

环境配置

本篇文章中所用到的环境都已经在上篇文章中配置好了,不知道如何使用的小伙伴可以移步上一篇文章

开始爬取

antispider1

antispider1 说明如下:

对接 WebDriver 反爬,检测到使用 WebDriver 就不显示页面,适合用作 WebDriver 反爬练习。

WebDriver 反爬,说明使用 selenium 会被检测到。

先使用上篇文章中提到的方法来尝试下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import scrapy
from scrapy_selenium import SeleniumRequest
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC


class AntiSpider(scrapy.Spider):
name = 'antispider1'

def start_requests(self):
urls = ['https://antispider1.scrape.center/']
for a in urls:
yield SeleniumRequest(url=a, callback=self.parse, wait_time=8, wait_until=EC.presence_of_element_located(
(By.CLASS_NAME, 'm-b-sm')))

def parse(self, response, **kwargs):
print(response.text)
input()

运行代码,selenium 会抛出一个超时异常,因为在指定的时间内未搜索到指定的标签,所以报了超时错误。

1
selenium.common.exceptions.TimeoutException: Message: 

同时查看页面,很明显被检测到了,页面内容都被 JS 删掉了,接下来查找检测点,过掉反爬。

先删除 selenium 等待元素的代码,防止抛异常导致浏览器退出,让程序无限等待在 input 函数上,爬虫不会退出,浏览器也不会被关掉,方便调试。

因为这种反爬检测没有比较好的入手点,所以直接打开浏览器控制台,全局搜索字符串 Webdriver Forbidden,只找到了一处。

看样子是一个三元运算符,通过判断 window.navigator.webdriver 的值来确定是显示反爬界面还是正常加载数据。

执行 window.navigator.webdriver 可以看到它的值为 true,有两个方法可以修改它的返回值:

  • 通过 window.navigator.webdriver = undefined
  • Object.defineProperties(navigator, {webdriver:{get:()=>undefined}});

在最新版的 Chrome 上测试过这两种方法都已经失效了,直接赋值的方法虽然执行成功但是并不能修改返回值,通过修改属性的方式虽然可以修改返回值,但是在新建页面或者访问一个新的 URL 时 window.navigator.webdriver 会自动变回 true,需要在每个页面加载前执行才可以,所以问题就变成了如何在页面加载之前执行自定义的命令。

在 selenium 中可以使用 CDP(即 Chrome Devtools-Protocol)Chrome 开发工具协议可以解决这个问题,CDP 命令可以在每个页面加载前加载自定义的代码,在 CDP 中这个命令叫做 Page.addScriptToEvaluateOnNewDocument

通过 execute_cdp_cmd 函数执行 CDP 命令,代码为:

1
2
3
4
5
6
driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'webdriver', {
get: () => undefined
})"""
})

这样只需要执行一次,Chrome 就会在每次加载页面前自动执行提前定义好的指令了。

方法有了,如何集成到现有的框架中呢?因为现在使用了第三方包集成 selenium,不能直接修改第三方包的代码,而 driver 对象又掌管在第三方包中,我们可能拿不到这个对象,怎么才能执行 CDP 命令呢?

这时候就需要去翻阅第三方包的代码,看看作者将 driver 对象保存到了哪里,如何才能获取到它。

先看第一个文件(scrapy_selenium/http.py)

1
2
3
4
5
6
7
8
9
10
11
class SeleniumRequest(Request):
"""Scrapy ``Request`` subclass providing additional arguments"""

def __init__(self, wait_time=None, wait_until=None, screenshot=False, script=None, *args, **kwargs):
# 为了便于便于查看删除了注释
self.wait_time = wait_time
self.wait_until = wait_until
self.screenshot = screenshot
self.script = script

super().__init__(*args, **kwargs)

只是继承了 scrapy 的 Request 类,是为了方便传递四个参数给到 driver 对象,再来看另一个文件(scrapy_selenium/middlewares.py)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
class SeleniumMiddleware:
"""Scrapy middleware handling the requests using selenium"""

def __init__(self, driver_name, driver_executable_path, driver_arguments,
browser_executable_path):
# 为了便于便于查看删除了注释
webdriver_base_path = f'selenium.webdriver.{driver_name}'

driver_klass_module = import_module(f'{webdriver_base_path}.webdriver')
driver_klass = getattr(driver_klass_module, 'WebDriver')

driver_options_module = import_module(f'{webdriver_base_path}.options')
driver_options_klass = getattr(driver_options_module, 'Options')

driver_options = driver_options_klass()
if browser_executable_path:
driver_options.binary_location = browser_executable_path
for argument in driver_arguments:
driver_options.add_argument(argument)

driver_kwargs = {
'executable_path': driver_executable_path,
f'{driver_name}_options': driver_options
}

self.driver = driver_klass(**driver_kwargs)

@classmethod
def from_crawler(cls, crawler):
"""Initialize the middleware with the crawler settings"""

driver_name = crawler.settings.get('SELENIUM_DRIVER_NAME')
driver_executable_path = crawler.settings.get('SELENIUM_DRIVER_EXECUTABLE_PATH')
browser_executable_path = crawler.settings.get('SELENIUM_BROWSER_EXECUTABLE_PATH')
driver_arguments = crawler.settings.get('SELENIUM_DRIVER_ARGUMENTS')

if not driver_name or not driver_executable_path:
raise NotConfigured(
'SELENIUM_DRIVER_NAME and SELENIUM_DRIVER_EXECUTABLE_PATH must be set'
)

middleware = cls(
driver_name=driver_name,
driver_executable_path=driver_executable_path,
driver_arguments=driver_arguments,
browser_executable_path=browser_executable_path
)

crawler.signals.connect(middleware.spider_closed, signals.spider_closed)

return middleware

def process_request(self, request, spider):
"""Process a request using the selenium driver if applicable"""

if not isinstance(request, SeleniumRequest):
return None

self.driver.get(request.url)

for cookie_name, cookie_value in request.cookies.items():
self.driver.add_cookie(
{
'name': cookie_name,
'value': cookie_value
}
)

if request.wait_until:
WebDriverWait(self.driver, request.wait_time).until(
request.wait_until
)

if request.screenshot:
request.meta['screenshot'] = self.driver.get_screenshot_as_png()

if request.script:
self.driver.execute_script(request.script)

body = str.encode(self.driver.page_source)

# Expose the driver via the "meta" attribute
request.meta.update({'driver': self.driver})

return HtmlResponse(
self.driver.current_url,
body=body,
encoding='utf-8',
request=request
)

def spider_closed(self):
"""Shutdown the driver when spider is closed"""

self.driver.quit()

是一个下载中间件的类,代码比较长,一块一块的看。

先来看 from_crawler 方法,通过配置文件获取到定义好的配置,然后创建当前类的对象,将爬虫关闭的信号连接到 spider_closed 方法上, 在爬虫关闭时及时执行 quit 方法关闭浏览器。

再来看初始化方法,接受四个参数,通过接收到的参数使用 import_module 方法来导入类,最后添加一些参数创建 driver 对象赋值给 self.driver,到这里就找到了 driver,可以想办法执行 CDP 方法了。

最后就是 process_request 方法,使用 get 方法来获取网页源代码,将 request 对象的 cookie 都添加到 driver 对象中,根据参数值的不同执行不同的动作,等待、截图、执行代码等等,通过 meta 属性公开了 driver 对象,方便在请求完页面数据后使用其他中间件来进行点击、滑动、翻页等等动作,最后返回一个 THML 响应对象。

虽然最后通过 meta 属性公开了 driver 对象,但这是在获取到网页源代码之后了,我们需要在网页加载前执行对应 CDP 命令才可以。

为了在页面加载之前执行命令,所以我们需要自定义一个自己的下载中间件,继承 SeleniumMiddleware 类,修改父类初始化方法。

middlewares.py 文件中添加以下代码,别忘了导入 SeleniumMiddleware

1
2
3
4
5
6
7
8
9
10
11
class MyDownloadMiddleware(SeleniumMiddleware):
def __init__(self, driver_name, driver_executable_path, driver_arguments,
browser_executable_path):
super(MyDownloadMiddleware, self).__init__(driver_name, driver_executable_path, driver_arguments,
browser_executable_path)
self.driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
"source": """
Object.defineProperty(navigator, 'webdriver', {
get: () => undefined
})"""
})

先执行 super 方法初始化父类,再使用父类创建好的 driver 对象执行 CDP 命令。别忘了去 settings.py 中修改下载中间件的值为:

1
2
3
DOWNLOADER_MIDDLEWARES = {
'learnscrapy.middlewares.MyDownloadMiddleware': 800 # 这里的数值要大一些,因为中间件返回响应后对象后就不会调用后续的下载中间件了
}

重新运行爬虫,应该可以看到页面正常加载了,并且网页源代码也可以正常获取到了,之后再补充上具体的解析代码即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class AntiSpider(scrapy.Spider):
name = 'antispider1'

def start_requests(self):
urls = ['https://antispider1.scrape.center/']
for a in urls:
yield SeleniumRequest(url=a, callback=self.parse, wait_time=3, wait_until=EC.presence_of_element_located(
(By.CLASS_NAME, 'm-b-sm')))

def parse(self, response, **kwargs):
result = response.xpath('//div[@class="el-card item m-t is-hover-shadow"]')
for a in result:
item = SSR1ScrapyItem()
item['title'] = a.xpath('.//h2[@class="m-b-sm"]/text()').get()
item['fraction'] = a.xpath('.//p[@class="score m-t-md m-b-n-sm"]/text()').get().strip()
item['country'] = a.xpath('.//div[@class="m-v-sm info"]/span[1]/text()').get()
item['time'] = a.xpath('.//div[@class="m-v-sm info"]/span[3]/text()').get()
item['date'] = a.xpath('.//div[@class="m-v-sm info"][2]/span/text()').get()
url = a.xpath('.//a[@class="name"]/@href').get()
print(response.urljoin(url))
yield SeleniumRequest(url=response.urljoin(url), callback=self.parse_person, meta={'item': item},
wait_time=3, wait_until=EC.presence_of_element_located((By.CLASS_NAME, 'm-b-sm')))

def parse_person(self, response):
item = response.meta['item']
item['director'] = response.xpath(
'//div[@class="directors el-row"]//p[@class="name text-center m-b-none m-t-xs"]/text()').get()
yield item

完整代码详见https://github.com/libra146/learnscrapy/tree/antispider1

其实在页面加载之前执行自定义的 JS 代码还有另外一种方法,那就是 Chrome 拓展,可以使用类似于油猴插件的拓展来实现,限于篇幅问题这里就不演示了。

antispider2

antispider2 说明如下:

对接 User-Agent 反爬,检测到常见爬虫 User-Agent 就会拒绝响应,适合用作 User-Agent 反爬练习。

既然是 User-Agent 反爬,那么就使用正常的 User-Agent 就可以了,暂时不需要用到 selenium。

本来是想用 fake-useragent 的,后来看了下项目两年多没更新了,而且不是随机生成,只是从网上下载一些 UA,然后随机选取而已,这样的话没必要引入一个依赖了,自己将 UA 爬下来然后随机取就好了。

在下载中间件中添加以下代码:

1
2
3
4
5
6
7
8
class Antispider2DownloaderMiddleware(LearnscrapyDownloaderMiddleware):
def __init__(self):
super(Antispider2DownloaderMiddleware, self).__init__()
with open('ua.json', 'r') as f:
self.ua = json.load(f)

def process_request(self, request, spider):
request.headers.update({'User-Agent': random.choice(self.ua)})

读取本地文件,然后在 process_request 函数中每次随机去一个 UA 更新默认的 UA 即可。

完整代码详见https://github.com/libra146/learnscrapy/tree/antispider2

antispider3

antispider3 说明如下:

对接文字偏移反爬,所见顺序并不一定和源码顺序一致,适合用作文字偏移反爬练习。

网站使用到了文字偏移反爬,猜测应该使用了 CSS 控制网页文字的位置来达到反爬的目的。

看了下渲染后的网页源代码,的确是通过改变 style 的值来使文字发生偏移的,处理方法就是将文字和 style属性一起获取,然后按照 style 升序排列就可以得到正确的结果:思维改变生活。往下看了看有的文字有偏移有的文字没有偏移,需要在代码里进行判断。

开始写代码,解析 HTML,获取数据,顺便获取对应的 style,处理后得到顺序正确的数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class AntiSpider(scrapy.Spider):
name = 'antispider3'

def start_requests(self):
urls = ['https://antispider3.scrape.center/']
for a in urls:
yield SeleniumRequest(url=a, callback=self.parse, wait_time=3, wait_until=EC.presence_of_element_located(
(By.CLASS_NAME, 'm-b-sm')))

def parse(self, response, **kwargs):
result = response.xpath('//div[@class="el-card__body"]')
for a in result:
item = Antispider3ScrapyItem()
chars = {}
# 有反爬
if r := a.xpath('.//h3[@class="m-b-sm name"]//span'):
for b in r:
chars[b.xpath('.//@style').re(r'\d\d?')[0]] = b.xpath('.//text()').get().strip()
# 先用sorted函数来排序,使用lambda指定索引值为0的值,也就是根据key值来排序,排序后使用zip函数来将所有的字符串放到
# 同一个元组中,list函数用来将生成器转成列表,之后使用索引值选择title所在的元组,使用join函数连接所有的字符串即为标题字符串
item['title'] = ''.join(list(zip(*sorted(chars.items(), key=lambda i: i[0])))[1])
else:
# 没有反爬
item['title'] = a.xpath('.//h3[@class="name whole"]/text()').get()
item['author'] = a.xpath('.//p[@class="authors"]/text()').get().strip()
url = a.xpath('.//a/@href').get()
print(response.urljoin(url))
yield SeleniumRequest(url=response.urljoin(url), callback=self.parse_person, meta={'item': item},
wait_time=3, wait_until=EC.presence_of_element_located((By.CLASS_NAME, 'm-b-sm')))

def parse_person(self, response):
item = response.meta['item']
item['price'] = response.xpath('//p[@class="price"]/span/text()').get()
item['time'] = response.xpath('//p[@class="published-at"]/text()').get()
item['press'] = response.xpath('//p[@class="publisher"]/text()').get()
item['page'] = response.xpath('//p[@class="page-number"]/text()').get()
item['isbm'] = response.xpath('//p[@class="isbn"]/text()').get()
yield item

通过判断对应元素是否存在的方式来判断 title 是否被反爬,在判断分支中进行不同的处理。

由于时间关系代码中只爬取了一页数据,证明方法可行就可以。

有个插曲,其实这个网站的数据也是通过 Ajax 请求的, 也就是说直接从接口请求就可以获取到数据,不用处理反爬措施,这里是为了学习文字偏移反爬才从 HTML 中获取数据。

完整代码详见https://github.com/libra146/learnscrapy/tree/antispider3

antispider4

antispider4 说明如下:

对接字体文件反爬,显示的内容并不在 HTML 内,而是隐藏在字体文件,设置了文字映射表,适合用作字体反爬练习。

字体反爬,这种情况下需要先找到字体映射表,并且解析字体映射表中的文字和代码的对应关系才可以正常爬取。

但是我在看到这里之后我发现这好像不是字体反爬😂(虽然这个网站的确有一个单独的字体文件),数字内容被放在了 CSS 样式表文件中,虽然我是第一次见到这种反爬措施,但是我认为叫它 CSS 反爬好像更合理一些。

不知道是不是作者搞错了的原因,这里暂且当作 CSS 反爬来处理吧。

这种反爬措施需要将 HTML 源码中对应数字的 class 的值都抓出来,然后将 CSS 文件中对应的 value 替换就可以了,所以首先需要处理的是 CSS 文件,而不是 HTML。

查了下,这种使用方式叫隐式 Style–CSS.

CSS中,::before 创建一个伪元素,其将成为匹配选中的元素的第一个子元素。常通过 content 属性来为一个元素添加修饰性的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class AntiSpider(scrapy.Spider):
name = 'antispider4'
css = {}

def start_requests(self):
urls = ['https://antispider4.scrape.center/css/app.654ba59e.css']
for a in urls:
# 解析css
yield Request(url=a, callback=self.parse_css)

def parse_css(self, response):
# 根据规律使用正则找到所有需要用到的属性,由于这里只反爬了分数,所以只需要匹配少量的数字和点即可。
result = re.findall(r'\.(icon-\d*?):before{content:"(.*?)"}', response.text)
for key, value in result:
self.css[key] = value
print(self.css)
# 访问主页
yield SeleniumRequest(url='https://antispider4.scrape.center/', callback=self.parse_data,
wait_time=3, wait_until=EC.presence_of_element_located((By.CLASS_NAME, 'm-b-sm')))

def parse_data(self, response):
result = response.xpath('//div[@class="el-card item m-t is-hover-shadow"]')
for a in result:
item = Antispider4ScrapyItem()
item['title'] = a.xpath('.//h2[@class="m-b-sm"]/text()').get()
if r := a.xpath('.//p[@class="score m-t-md m-b-n-sm"]//i'):
item['fraction'] = ''.join([self.css.get(b.xpath('.//@class').get()[5:], '') for b in r])
item['country'] = a.xpath('.//div[@class="m-v-sm info"]/span[1]/text()').get()
item['time'] = a.xpath('.//div[@class="m-v-sm info"]/span[3]/text()').get()
item['date'] = a.xpath('.//div[@class="m-v-sm info"][2]/span/text()').get()
url = a.xpath('.//a[@class="name"]/@href').get()
print(response.urljoin(url))
yield SeleniumRequest(url=response.urljoin(url), callback=self.parse, meta={'item': item},
wait_time=3, wait_until=EC.presence_of_element_located((By.CLASS_NAME, 'm-b-sm')))

def parse(self, response, **kwargs):
item = response.meta['item']
item['director'] = response.xpath(
'//div[@class="directors el-row"]//p[@class="name text-center m-b-none m-t-xs"]/text()').get()
yield item

处理方式就是先将 CSS 文件中所需要用到的内容使用正则匹配出来,在需要替换的地方直接替换就可以得到正确的分数数据了。

完整代码详见https://github.com/libra146/learnscrapy/tree/antispider4

总结

本篇文章只写针对 selenium 出现的各种反爬措施,针对 IP 地址或者账号进行的反爬的内容下篇文章来写。

网页获取数据的方式无外乎就那几种,HTML,JS,CSS,Ajax等,所以在遇到反爬时先找数据是怎么被渲染出来的,剩下的问题就是处理数据,根据数据的来源进行针对性的处理。

本文章首发于个人博客 LLLibra146’s blog
本文作者:LLLibra146
版权声明:本博客所有文章除特别声明外,均采用 © BY-NC-ND 许可协议。非商用转载请注明出处!严禁商业转载!
本文链接https://blog.d77.xyz/archives/f10ab485.html