Comment créer rapidement votre propre système de robot d'exploration Web en utilisant PHP et Selenium

Ces dernières années, avec la popularisation d'Internet, les robots d'exploration Web sont progressivement devenus l'un des principaux moyens de collecte d'informations. Cependant, la technologie des robots d'exploration conventionnelle est instable et difficile à maintenir. Les robots d'exploration Web purs sur le marché ne peuvent fonctionner que sur des bases statiques. pages fonctionnent. PHP combiné avec Selenium peut obtenir l'effet de robots d'exploration dynamiques. Il présente les avantages d'une grande stabilité et d'une collecte de données complète, et est largement utilisé dans le développement de robots. Cet article explique comment créer rapidement votre propre système de robot d'exploration Web à l'aide de PHP et Selenium.

1. Installation de Selenium et ChromeDriver

Selenium est un outil de test automatisé qui peut effectuer des tests automatisés d'applications Web. Il gère le navigateur et le système d'exploitation séparément, sans forcer l'insertion de code pour obtenir le rendu des pages. ChromeDriver est le pilote de Selenium qui appelle le navigateur Chrome, ce qui permet à Selenium d'exploiter directement Chrome pour explorer les pages dynamiques.

Vous devez d’abord installer le navigateur Chrome et l’environnement PHP localement. Ensuite, nous devons installer la version correspondante de Selenium et ChromeDriver. Entrez le code suivant dans la ligne de commande pour installer :

composer require facebook/webdriver

Puis placez le fichier binaire ChromeDriver (téléchargez la version correspondante de ChromeDrive en fonction de votre version locale de Chrome) dans le dossier. Environnement variable du chemin système, le code est le suivant :

$webdriver = FacebookWebDriverRemoteRemoteWebDriver::create(
    'http://localhost:9515', FacebookWebDriverChromeChromeOptions::class
);

2. Construisez la classe d'encapsulation de Selenium et ChromeDriver

La classe d'encapsulation Selenium est principalement utilisée pour maintenir Selenium et ChromeDriver afin d'éviter la création et la destruction répétées. Le code est le suivant. :

class Selenium
{
    private static $driver;
    private static $selenium;

    public static function getInstance()
    {
        if (null === self::$selenium) {
            $options = new ChromeOptions();
            $options->addArguments(['--no-sandbox','--disable-extensions','--headless','--disable-gpu']);
            self::$driver = RemoteWebDriver::create(
                'http://localhost:9515',
                DesiredCapabilities::chrome()->setCapability(
                    ChromeOptions::CAPABILITY,
                    $options
                )
            );
            self::$selenium = new self();
        }

        return self::$selenium;
    }

    public function __destruct()
    {
        self::$driver->quit();
        self::$selenium = null;
    }

    public function getDriver()
    {
        return self::$driver;
    }
}

Notez que les ChromeOptions dans les paramètres sont principalement destinées à fonctionner de manière stable sans GUI (interface graphique), le paramètre --no-sandbox sert à éviter les erreurs lors de l'exécution sous un système Linux.

3. Créer une classe d'analyse du code source de page Web

Le cœur du système d'exploration est d'analyser les pages non statiques. Ici, vous devez créer une classe d'analyse du code source et utiliser des expressions régulières ou des expressions XPath pour localiser et obtenir la cible. informations sur le nœud.

class PageParser
{
    private $pageSource;

    public function __construct(string $pageSource)
    {
        $this->pageSource = $pageSource;
    }

    public function parse(string $expression, $list = false)
    {
        if ($list) {
            return $this->parseList($expression);
        }
        return $this->parseSingle($expression);
    }

    private function parseList(string $expression)
    {
        $domXpath = new DOMXPath(@DOMDocument::loadHTML($this->pageSource));
        $items = $domXpath->query($expression);
        $result = [];
        foreach ($items as $item) {
            array_push($result,trim($item->nodeValue));
        }
        return $result;
    }

    private function parseSingle(string $expression)
    {
        $domXpath = new DOMXPath(@DOMDocument::loadHTML($this->pageSource));
        $item = $domXpath->query($expression)->item(0);
        if ($item) {
            return trim($item->nodeValue);
        }
        return '';
    }
}

Les classes DOMXPath et DOMDocument sont principalement utilisées ici pour analyser les nœuds HTML de la page, et les méthodes parseList et parseSingle sont utilisées pour localiser et obtenir le contenu de plusieurs nœuds cibles respectivement.

4. Créer une classe d'exploration

Enfin, nous devons créer une classe d'exploration spécifiquement pour explorer le contenu des pages. Le code est le suivant :

class Spider
{
    private $selenium;
    private $url;

    public function __construct($url)
    {
        $this->selenium = Selenium::getInstance();
        $this->url = $url;
        $this->selenium->getDriver()->get($url);
        sleep(1);
    }

    public function __destruct()
    {
        $this->selenium->getDriver()->close();
        $this->selenium = null;
    }

    public function getContent($expression, $list = false)
    {
        $pageSource = $this->selenium->getDriver()->getPageSource();
        $parser = new PageParser($pageSource);
        return $parser->parse($expression, $list);
    }
}

La méthode getContent de cette classe reçoit deux paramètres, l'un est l'expression XPath de. le nœud cible, et l'autre est de savoir s'il faut obtenir plusieurs contenus. La fonction getModelContent demande l'URL et analyse les nœuds pour obtenir le contenu requis. Une fois la fonction terminée, le processus du navigateur est fermé.

5. Exemples d'utilisation

Enfin, nous utilisons des exemples pratiques pour illustrer comment utiliser cette classe de robot. Supposons que nous devions explorer l'attribut href et les informations textuelles dans la balise a à partir d'une page Web comportant plusieurs balises a. Nous pouvons y parvenir grâce au code suivant :

$spider = new Spider('https://www.example.com');
$aTags = $spider->getContent('//a', true);
foreach ($aTags as $a) {
    $href = $a->getAttribute('href');
    $text = $a->nodeValue;
    echo "$href -> $text
";
}

Dans le code ci-dessus, utilisez d'abord la classe Spider pour obtenir le code source de la page, puis obtenez les informations de nœud de plusieurs balises a via des expressions XPath, et enfin obtenez les informations de nœud de chaque une balise via les méthodes getAttribute et nodeValue et le texte.

6. Résumé

Pour résumer, cet article présente comment utiliser PHP et Selenium pour créer un système de robot d'exploration Web et utilise des exemples pratiques pour illustrer comment obtenir des informations sur les nœuds dans la page. et la collecte de données complète, a une certaine valeur d'application. Mais en même temps, il convient de noter que lors de l’exploration de données, vous devez prêter attention à la légalité et à l’éthique, et vous conformer aux lois et réglementations en vigueur.

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!