Scrapy-Framework und Datenbankintegration: Wie implementiert man eine dynamische Datenspeicherung?

Angesichts der zunehmenden Menge an Internetdaten ist die Frage, wie Daten schnell und genau gecrawlt, verarbeitet und gespeichert werden können, zu einem zentralen Thema bei der Entwicklung von Internetanwendungen geworden. Als effizientes Crawler-Framework wird das Scrapy-Framework aufgrund seiner flexiblen und schnellen Crawling-Methoden häufig in verschiedenen Daten-Crawling-Szenarien eingesetzt.

Das bloße Speichern der gecrawlten Daten in einer Datei kann jedoch die Anforderungen der meisten Anwendungen nicht erfüllen. Denn in aktuellen Anwendungen werden die meisten Daten über Datenbanken gespeichert, abgerufen und bearbeitet. Daher ist die Integration des Scrapy-Frameworks in die Datenbank zur Erzielung einer schnellen und dynamischen Datenspeicherung zu einer neuen Herausforderung geworden.

In diesem Artikel wird anhand konkreter Fälle vorgestellt, wie das Scrapy-Framework Datenbanken integriert und eine dynamische Datenspeicherung als Referenz für bedürftige Leser implementiert.

1. Vorbereitung

Vor der Einführung wird davon ausgegangen, dass die Leser dieses Artikels bereits die Grundkenntnisse der Python-Sprache und einiger Methoden zur Verwendung des Scrapy-Frameworks verstanden haben und die Python-Sprache zum Ausführen einfacher Datenbankoperationen verwenden können. Wenn Sie damit nicht vertraut sind, empfiehlt es sich, sich zunächst die entsprechenden Kenntnisse anzueignen und dann diesen Artikel zu lesen.

2. Wählen Sie die Datenbank aus

Bevor wir mit der Integration des Scrapy-Frameworks in die Datenbank beginnen, müssen wir zunächst eine geeignete Datenbank zum Speichern der von uns gecrawlten Daten auswählen. Zu den derzeit am häufigsten verwendeten Datenbanken gehören MySQL, PostgreSQL, MongoDB und viele andere Optionen.

Diese Datenbanken haben jeweils ihre eigenen Vor- und Nachteile. Wählen Sie sie entsprechend Ihren Anforderungen aus. Wenn beispielsweise die Datenmenge gering ist, ist es bequemer, die MySQL-Datenbank zu verwenden, und wenn eine große Datenspeicherung erforderlich ist, ist die Dokumentendatenbank von MongoDB besser geeignet.

3. Datenbankverbindungsinformationen konfigurieren

Vor dem spezifischen Vorgang müssen wir die Datenbankverbindungsinformationen konfigurieren. Am Beispiel der MySQL-Datenbank können Sie zum Herstellen einer Verbindung die Pymysql-Bibliothek in Python verwenden.

In Scrapy konfigurieren wir es normalerweise in Settings.py:

MYSQL_HOST = 'localhost'
MYSQL_PORT = 3306
MYSQL_USER = 'root'
MYSQL_PASSWORD = '123456'
MYSQL_DBNAME = 'scrapy_demo'

In der obigen Konfiguration haben wir den Hostnamen, die Portnummer, den Benutzernamen, das Passwort und den Datenbanknamen konfiguriert, in dem sich die MySQL-Datenbank befindet. Diese Informationen müssen geändert werden je nach tatsächlicher Situation.

4. Schreiben Sie die Datenspeicherpipeline

In Scrapy ist die Datenspeicherpipeline der Schlüssel zur Realisierung der Datenspeicherung. Wir müssen eine Pipeline-Klasse schreiben und sie dann in der Scrapy-Konfigurationsdatei festlegen, um Daten zu speichern.

Am Beispiel der Speicherung in MySQL können wir eine MySQLPipeline-Klasse wie folgt schreiben:

import pymysql

class MySQLPipeline(object):

    def open_spider(self, spider):
        self.conn = pymysql.connect(host=spider.settings.get('MYSQL_HOST'),
                                    port=spider.settings.get('MYSQL_PORT'),
                                    user=spider.settings.get('MYSQL_USER'),
                                    password=spider.settings.get('MYSQL_PASSWORD'),
                                    db=spider.settings.get('MYSQL_DBNAME'))
        self.cur = self.conn.cursor()

    def close_spider(self, spider):
        self.conn.close()

    def process_item(self, item, spider):
        sql = 'INSERT INTO articles(title, url, content) VALUES(%s, %s, %s)'
        self.cur.execute(sql, (item['title'], item['url'], item['content']))
        self.conn.commit()

        return item

Im obigen Code definieren wir eine MySQLPipeline-Klasse, um das Andocken an die MySQL-Datenbank zu implementieren, und definieren drei Methoden „open_spider“, „close_spider“ und „process_item“.

Unter anderem wird die open_spider-Methode aufgerufen, wenn der gesamte Crawler ausgeführt wird, um die Datenbankverbindung zu initialisieren. Die close_spider-Methode wird aufgerufen, wenn der Crawler endet, um die Datenbankverbindung zu schließen. Process_item ist die Methode, die jedes Mal aufgerufen wird, wenn die Daten gecrawlt werden, um die Daten in der Datenbank zu speichern.

5. Pipeline aktivieren

Nach Abschluss des Schreibens von Pipeline müssen wir es auch in Scrapys Konfigurationsdatei „settings.py“ aktivieren. Fügen Sie einfach die Pipeline-Klasse zur Variablen ITEM_PIPELINES hinzu, wie unten gezeigt:

ITEM_PIPELINES = {
    'myproject.pipelines.MySQLPipeline': 300,
}

Im obigen Code haben wir die MySQLPipeline-Klasse zur Variablen ITEM_PIPELINES hinzugefügt und die Priorität auf 300 gesetzt, was bedeutet, dass bei der Verarbeitung von Item die Pipeline Die Klasse wird Sei der Dritte, der berufen wird.

6. Test und Betrieb

Nach Abschluss aller Konfigurationen können wir den Scrapy-Crawler ausführen und die erfassten Daten in der MySQL-Datenbank speichern. Die spezifischen Schritte und Befehle lauten wie folgt:

1. Geben Sie das Verzeichnis ein, in dem sich das Scrapy-Projekt befindet, und führen Sie den folgenden Befehl aus, um ein Scrapy-Projekt zu erstellen:

scrapy startproject myproject

2 Framework und crawlen Sie den Datenspeicher in der Datenbank. Führen Sie den folgenden Befehl im Verzeichnis myproject aus:

scrapy genspider test_spider baidu.com

Der obige Befehl generiert einen Spider namens test_spider, um Baidu zu crawlen.

3. Schreiben Sie den Spider-Code, öffnen Sie test_sprider.py und schreiben Sie den Crawler-Code:

import scrapy
from myproject.items import ArticleItem

class TestSpider(scrapy.Spider):
    name = "test"
    allowed_domains = ["baidu.com"]
    start_urls = [
        "https://www.baidu.com",
    ]

    def parse(self, response):
        item = ArticleItem()
        item['title'] = 'MySQL Pipeline测试'
        item['url'] = response.url
        item['content'] = 'Scrapy框架与MySQL数据库整合测试'
        yield item

Im obigen Code definieren wir eine TestSpider-Klasse, die von der kommenden Spider-Klasse erbt mit Scrapy. Behandeln Sie die Crawler-Logik. In der Parse-Methode erstellen wir ein Item-Objekt und legen die drei Schlüsselwörter „content“, „url“ und „title“ fest.

4. Erstellen Sie eine Artikeldatei im myproject-Verzeichnis, um das Datenmodell zu definieren:

import scrapy

class ArticleItem(scrapy.Item):
    title = scrapy.Field()
    url = scrapy.Field()
    content = scrapy.Field()

Im obigen Code definieren wir eine ArticleItem-Klasse, um die gecrawlten Artikeldaten zu speichern.

5. Testcode:

Führen Sie im Verzeichnis test_spider den folgenden Befehl aus, um Ihren Code zu testen:

scrapy crawl test

Nach der Ausführung des obigen Befehls startet Scrapy den TestSpider-Crawler und speichert die von der Baidu-Homepage erfassten Daten in MySQL Datenbank.

7. Zusammenfassung

In diesem Artikel wird kurz vorgestellt, wie das Scrapy-Framework in die Datenbank integriert wird und eine dynamische Datenspeicherung implementiert. Ich hoffe, dass dieser Artikel bedürftigen Lesern helfen kann, und ich hoffe auch, dass sich Leser entsprechend ihren tatsächlichen Bedürfnissen weiterentwickeln können, um effizientere und schnellere dynamische Datenspeicherfunktionen zu erreichen.

Das obige ist der detaillierte Inhalt vonScrapy-Framework und Datenbankintegration: Wie implementiert man eine dynamische Datenspeicherung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!