Comment analyser les requêtes Ajax pour les pages Web rendues par JS

Lorsque nous utilisons python pour explorer, nous avons peut-être constaté que le code HTML obtenu par requête directe à partir de certaines pages Web ne contient pas les données dont nous avons besoin, ce que nous voyons dans le navigateur.

Cela est dû au fait que les informations sont chargées via Ajax et générées via le rendu js. À ce stade, nous devons analyser la demande de cette page Web.

L'article précédent vous a expliqué ce qu'est le Cookie et le processus de fonctionnement de la connexion simulée Aujourd'hui, je vais vous montrer comment analyser la requête Ajax de la page Web.

Qu'est-ce qu'Ajax

AJAX est "Asynchronous Javascript And XML" (Javascript et XML asynchrones), qui fait référence à une création Technologie de développement Web pour applications Web interactives.
AJAX = Asynchronous JavaScript et XML (un sous-ensemble du Standard Universal Markup Language).
AJAX est une technologie permettant de créer des pages Web rapides et dynamiques.
AJAX est une technologie qui permet de mettre à jour des parties d'une page Web sans recharger la page entière.

Pour faire simple, la page web est chargée. L'URL dans la barre d'adresse du navigateur n'a pas changé. Il s'agit d'une page web chargée de manière asynchrone par javascript, qui devrait être ajax. AJAX envoie généralement des requêtes via l'interface objet XMLHttpRequest, et XMLHttpRequest est généralement abrégé en XHR.

Analyse du site Web Guoke.com

Notre site Web cible sera analysé à l'aide de Guoke.com.

Nous pouvons voir que cette page Web n'a pas de bouton de changement de page, et lorsque nous continuons à afficher la demande, la page Web chargera automatiquement plus de contenu pour nous. Cependant, lorsque nous observons l’URL de la page Web, nous constatons qu’elle ne change pas avec la demande de chargement de la page Web. Et lorsque l’on demande directement cette url, on ne peut évidemment obtenir que le contenu html de la première page.

Alors comment pouvons-nous obtenir les données de toutes les pages ?

Nous ouvrons les outils de développement (F12) dans Chrome. Nous cliquons sur Réseau et cliquons sur l'onglet XHR. Ensuite, nous actualisons la page Web et récupérons la demande. À ce stade, nous pouvons voir la balise XHR et une demande apparaîtra à chaque fois que la page Web est chargée.

Quand on clique sur la première requête, on peut voir ses paramètres :

retrieve_type:by_subject
limit:20
offset:18
-:1500265766286

Quand on clique sur la deuxième requête, les paramètres sont les suivants :

retrieve_type:by_subject
limit:20
offset:38
-:1500265766287

La limite Le paramètre est each La page limite le nombre d'articles chargés et offset est le nombre de pages. En regardant vers le bas, nous constaterons que le paramètre de décalage de chaque requête sera augmenté de 20.

Nous examinons ensuite le contenu de la réponse de chaque requête. Il s'agit de données dans un format. Lorsque nous cliquons sur le bouton de résultat, nous pouvons voir les informations sur les données de 20 articles. De cette façon, nous avons réussi à trouver l'emplacement des informations dont nous avons besoin. Nous pouvons voir l'adresse URL où les données json sont stockées dans l'en-tête de la requête. http://www.guokr.com/apis/minisite/article.json?retrieve_type=by_subject&limit=20&offset=18

Processus d'exploration

Analyser les requêtes Ajax pour obtenir les informations sur l'URL de l'article de chaque page ; analyser chaque article pour obtenir les données requises ; enregistrer les données obtenues dans la base de données ; un grand nombre de Pick.

Démarrer

Notre outil utilise toujours les requêtes et l'analyse BeautifulSoup.

Tout d'abord, nous devons analyser la requête Ajax pour obtenir les informations de toutes les pages. Grâce à l'analyse ci-dessus de la page Web, nous pouvons obtenir l'adresse URL des données json chargées par Ajax : http://www.guokr.com/apis/minisite/article.json?retrieve_type=by_subject&limit=20&offset=18

Nous devons construire cette URL.

# 导入可能要用到的模块
import requests
from urllib.parse import urlencode
from requests.exceptions import ConnectionError
 
# 获得索引页的信息
def get_index(offset):
    base_url = 'http://www.guokr.com/apis/minisite/article.json?'
    data = {
        'retrieve_type': "by_subject",
        'limit': "20",
        'offset': offset
    }
    params = urlencode(data)
    url = base_url + params
 
    try:
        resp = requests.get(url)
        if resp.status_code == 200:
            return resp.text
        return None
    except ConnectionError:
        print('Error.')
        return None

Nous construisons les paramètres de requête obtenus à partir de la page d'analyse ci-dessus dans les données d'un dictionnaire, puis nous pouvons construire manuellement l'URL, mais la bibliothèque urllib nous a fourni une méthode d'encodage. Utilisez-le directement pour construire une URL complète. Ensuite, il existe des requêtes standard pour demander le contenu de la page.

import json
 
# 解析json，获得文章url
def parse_json(text):
    try:
        result = json.loads(text)
        if result:
            for i in result.get('result'):
                # print(i.get('url'))
                yield i.get('url')
    except:
        pass

Nous utilisons la méthode josn.loads pour analyser json et le convertir en objet json. Obtenez ensuite directement l'adresse URL de l'article via l'opération du dictionnaire. Le rendement est utilisé ici et chaque requête renvoie une URL pour réduire la consommation de mémoire. Depuis que j'ai eu une erreur d'analyse json lorsque je l'ai récupéré plus tard, je l'ai simplement filtré ici.

Ici, nous pouvons essayer d'imprimer et voir si cela fonctionne avec succès.

既然获得了文章的url，那么对于获得文章的数据就显得很简单了。这里不在进行详细的叙述。我们的目标是获得文章的标题，作者和内容。
由于有的文章里面包含一些图片，我们直接过滤掉文章内容里的图片就好了。

from bs4 import BeautifulSoup
 
# 解析文章页
def parse_page(text):
    try:
        soup = BeautifulSoup(text, 'lxml')
        content = soup.find('div', class_="content")
        title = content.find('h1', id="articleTitle").get_text()
        author = content.find('div', class_="content-th-info").find('a').get_text()
        article_content = content.find('div', class_="document").find_all('p')
        all_p = [i.get_text() for i in article_content if not i.find('img') and not i.find('a')]
        article = '\n'.join(all_p)
        # print(title,'\n',author,'\n',article)
        data = {
            'title': title,
            'author': author,
            'article': article
        }
        return data
    except:
        pass

   

这里在进行多进程抓取的时候，BeautifulSoup也会出现一个错误，依然直接过滤。我们把得到的数据保存为字典的形式，方便保存数据库。

接下来就是保存数据库的操作了，这里我们使用Mongodb进行数据的存储。

import pymongo
from config import *
 
client = pymongo.MongoClient(MONGO_URL, 27017)
db = client[MONGO_DB]
 
def save_database(data):
    if db[MONGO_TABLE].insert(data):
        print('Save to Database successful', data)
        return True
    return False

我们把数据库的名字，和表名保存到config配置文件中，在把配置信息导入文件，这样会方便代码的管理。

最后呢，由于果壳网数据还是比较多的，如果想要大量的抓取，我们可以使用多进程。

from multiprocessing import Pool
 
# 定义一个主函数
def main(offset):
    text = get_index(offset)
    all_url = parse_json(text)
    for url in all_url:
        resp = get_page(url)
        data = parse_page(resp)
        if data:
            save_database(data)
 
if __name__ == '__main__':
    pool = Pool()
    offsets = ([0] + [i*20+18 for i in range(500)])
    pool.map(main, offsets)
    pool.close()
    pool.join()

   

函数的参数offset就是页数了。经过我的观察，果壳网最后一页页码是 12758，有 637 页。这里我们就抓取 500 页。进程池的map方法和Python内置的map方法使用类似。

好了，对于一些使用Ajax加载的网页，我们就可以这么抓取了。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!