So erstellen Sie schnell Ihr eigenes Webcrawler-System mit PHP und Selenium

Mit der Popularisierung des Internets sind Webcrawler nach und nach zu einem der wichtigsten Mittel zur Informationssammlung geworden. Allerdings ist die herkömmliche Crawler-Technologie auf dem Markt instabil und kann nur schwer gewartet werden Seiten. In Kombination mit Selenium kann PHP den Effekt eines dynamischen Crawlers erzielen. Es bietet die Vorteile einer hohen Stabilität und einer umfassenden Datenerfassung und wird häufig in der Crawler-Entwicklung eingesetzt. In diesem Artikel erfahren Sie, wie Sie mit PHP und Selenium schnell Ihr eigenes Webcrawler-System erstellen. 1. Installation von Selenium und ChromeDriver ChromeDriver ist der Treiber in Selenium, der den Chrome-Browser aufruft, sodass Selenium Chrome direkt zum Crawlen dynamischer Seiten bedienen kann.

Zuerst müssen Sie den Chrome-Browser und die PHP-Umgebung lokal installieren. Als nächstes müssen wir die entsprechende Version von Selenium und ChromeDriver installieren. Geben Sie zur Installation den folgenden Code in die Befehlszeile ein:

composer require facebook/webdriver

Dann legen Sie die ChromeDriver-Binärdatei (laden Sie die entsprechende Version von ChromeDrive entsprechend Ihrer lokalen Chrome-Version herunter) ab Systempfadvariablenumgebung, der Code lautet wie folgt:

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

2. Erstellen Sie die Kapselungsklasse von Selenium und ChromeDriver.

Die Selenium-Kapselungsklasse wird hauptsächlich zur Verwaltung von Selenium und ChromeDriver verwendet, um wiederholte Erstellung und Zerstörung zu vermeiden :

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;
    }
}

Beachten Sie, dass es sich bei den ChromeOptions in den Parametern hauptsächlich um einen stabilen Betrieb ohne GUI (grafische Oberfläche) handelt. Der Parameter --no-sandbox dient dazu, Fehler bei der Ausführung unter einem Linux-System zu verhindern.

3. Erstellen Sie eine Quellcode-Parsing-Klasse für Webseiten. Der Kern des Crawler-Systems besteht darin, nicht statische Seiten zu analysieren und reguläre Ausdrücke oder XPath-Ausdrücke zu verwenden, um das Ziel zu finden Knoteninformationen.

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 '';
    }
}

Die DOMXPath-Klasse und die DOMDocument-Klasse werden hier hauptsächlich zum Parsen der HTML-Knoten auf der Seite verwendet, und die Methoden parseList und parseSingle werden zum Suchen und Abrufen des Inhalts mehrerer bzw. eines Zielknotens verwendet.

4. Erstellen Sie eine Crawler-Klasse

Abschließend müssen wir eine Crawler-Klasse speziell für das Crawlen von Seiteninhalten erstellen. Der Code lautet wie folgt:

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);
    }
}

Die getContent-Methode dieser Klasse empfängt zwei Parameter, einer davon ist der XPath-Ausdruck Der Zielknoten und der andere ist, ob mehrere Inhalte abgerufen werden sollen. Die getModelContent-Funktion fordert die URL an und analysiert die Knoten, um den erforderlichen Inhalt zu erhalten. Nach Abschluss der Funktion wird der Browserprozess geschlossen.

5. Anwendungsbeispiele

Abschließend veranschaulichen wir anhand praktischer Beispiele, wie diese Crawler-Klasse verwendet wird. Angenommen, wir müssen das href-Attribut und die Textinformationen im a-Tag von einer Webseite mit mehreren a-Tags crawlen. Wir können dies durch den folgenden Code erreichen:

$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
";
}

Im obigen Code verwenden wir zuerst die Spider-Klasse, um den Seitenquellcode abzurufen, dann die Knoteninformationen mehrerer a-Tags über XPath-Ausdrücke abzurufen und schließlich die Knoteninformationen jedes einzelnen Tags abzurufen ein Tag über die Methoden getAttribute und nodeValue Attribut und Text.

VI. Zusammenfassung

Zusammenfassend stellt dieser Artikel vor, wie man PHP und Selenium zum Aufbau eines Web-Crawler-Systems verwendet, und veranschaulicht anhand praktischer Beispiele, wie man Knoteninformationen auf der Seite erhält und umfassende Datenerfassung hat einen gewissen Anwendungswert. Gleichzeitig ist jedoch zu beachten, dass beim Crawlen von Daten auf Rechtmäßigkeit und Ethik geachtet und die einschlägigen Gesetze und Vorschriften eingehalten werden müssen.

Das obige ist der detaillierte Inhalt vonSo erstellen Sie schnell Ihr eigenes Webcrawler-System mit PHP und Selenium. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!