Web Scraping in Java und Spring Boot 2025

In diesem Java-Tutorial zum Web Scraping beschäftigen wir uns mit Deep Crawling: einer fortgeschrittenen Form des Web Scraping. In diesem umfassenden Leitfaden zum Web Scraping in Java wird Deep Crawling mit Java Spring Boot zum Scrapen des Webs verwendet.

Durch Deep Crawling werden selbst die entlegensten Bereiche einer Website zugänglich und es werden Daten sichtbar, die sonst möglicherweise unbemerkt bleiben würden.

Und das Beste ist, dass wir nicht nur über Theorie reden, sondern Ihnen zeigen, wie es geht. Java Spring Boot und der Crawlbase Java-Bibliothek, wir zeigen Ihnen, wie Sie Deep Crawling in die Tat umsetzen. Wir helfen Ihnen beim Einrichten Ihrer Tools, erklären den Unterschied zwischen Shallow und Deep Crawling (es ist nicht so kompliziert, wie es klingt!) und zeigen Ihnen, wie Sie Informationen aus verschiedenen Webseiten extrahieren und auf Ihrer Seite speichern.

Um den Codierungsteil von Web Scraping Java zu verstehen, müssen Sie über grundlegende Kenntnisse von Java Spring Boot und MySQL-Datenbanken verfügen. Beginnen wir mit der Erstellung eines Web Scrapers in Java.

Deep Crawling verstehen: Das Tor zu Webdaten
Warum müssen Sie einen Java Web Scraper erstellen?
So funktioniert Web Scraping in Java
Die Bühne bereiten: Ihre Umgebung vorbereiten
Vereinfachen Sie die Einrichtung von Spring Boot-Projekten mit Spring Initializr
Importieren des Starterprojekts in die Spring Tool Suite
Den Entwurf Ihres Projekts verstehen: Ein Blick in die Projektstruktur
Beginnen Sie Ihre Codierungsreise
Ausführen des Projekts und Starten des Deep Crawlings
Analysieren der Ausgabe in der Datenbank
Schlussfolgerung
Häufig gestellte Fragen

Deep Crawling in Java.

Deep Crawling, auch Web Scraping genannt, ist wie das tiefe Graben im Internet, um viele wertvolle Informationen zu finden. In diesem Teil sprechen wir darüber, was Deep Crawling ist, wie es sich vom bloßen Überfliegen der Oberfläche von Websites unterscheidet und warum es für das Erhalten von Daten wichtig ist.

Im Grunde ist Deep Crawling eine intelligente Methode, um Websites zu durchsuchen und bestimmte Informationen aus verschiedenen Teilen dieser Websites zu erfassen. Im Gegensatz zum Shallow Crawling, bei dem nur die Oberfläche betrachtet wird, dringt Deep Crawling in die Schichten von Websites ein, um verborgene Datenschätze zu finden. Auf diese Weise können wir mit Web Scraping unter Verwendung von Java alle möglichen Informationen sammeln, wie Produktpreise, Benutzerbewertungen, Finanzstatistiken und Nachrichtenartikel.

Deep Crawling hilft uns, an eine Menge strukturierter und unstrukturierter Daten zu gelangen, die wir sonst nicht sehen würden. Indem wir das Internet sorgfältig erkunden, können wir Daten sammeln, die bei Geschäftsentscheidungen helfen, die Forschung unterstützen und mit Java Web Scraping neue Ideen anregen können.

Unterscheidung zwischen flachem und tiefem Krabbeln

Flaches Crawling ist wie ein schneller Blick auf die Oberfläche eines Teichs, bei dem nur das Sichtbare betrachtet wird. Dabei wird normalerweise nur ein kleiner Teil einer Website betrachtet, etwa die Hauptseite oder ein paar wichtige Seiten. Dabei entgehen jedoch viele versteckte Dinge.

Beim Deep Crawling hingegen taucht man tief in den Ozean ein und erkundet jeden Winkel. Dabei wird die gesamte Website durchsucht, durch Links geklickt und in verschiedenen Abschnitten versteckte Schätze gefunden. Deep Crawling ist für Unternehmen, Forscher und Entwickler äußerst nützlich, da es eine Menge wertvoller Daten ausgräbt, die sonst schwer zu finden sind.

Umfang und Bedeutung von Deep Crawling erkunden

Der Anwendungsbereich von Deep Crawling geht weit über die Datenextraktion hinaus. Es ist ein Tor zum Verständnis der Dynamik des Webs und zur Aufdeckung von Erkenntnissen, die die Entscheidungsfindung beeinflussen. Von E-Commerce-Plattformen, die die Produktpreise auf den Websites der Wettbewerber überwachen möchten, bis hin zu Nachrichtenorganisationen, die die Stimmung in Artikeln analysieren möchten – die Anwendungsbereiche von Deep Crawling sind so vielfältig wie die Daten, die es ans Licht bringt.

In der Forschung ist Deep Crawling die Grundlage für die Analyse von Daten, um neue Trends zu verstehen und herauszufinden, wie Menschen das Internet nutzen und welche Inhalte ihnen gefallen. Es ist auch wichtig, um Gesetze und Vorschriften einzuhalten, denn Unternehmen müssen sich Gedanken über die richtige Art der Datenerfassung machen und die Regeln der Websites einhalten, von denen sie die Daten beziehen.

In diesem Tutorial werden wir uns eingehend mit dem Web Scraping in Java befassen.

Warum müssen Sie einen Java Web Scraper erstellen?

Sie benötigen einen Java-Web-Scraper, um Website-Informationen zu sammeln und zu nutzen. Ein solcher Web-Scraper ist Crawlbase Crawler, aber was genau ist Crawlbase Crawler, und wie entfaltet es seine Magie?

Was ist Crawlbase? Crawler?

Crawlbase Crawler ist ein dynamisches Tool zur Extraktion von Webdaten, das einen modernen und intelligenten Ansatz zum Sammeln wertvoller Informationen von Websites bietet. Im Gegensatz zu herkömmlichen Scraping-Methoden, die ständige Abfragen erfordern, bietet Crawlbase Crawler arbeitet asynchron. Das heißt, es kann Anfragen zur Datenextraktion selbstständig verarbeiten und diese in Echtzeit bereitstellen, ohne dass eine manuelle Überwachung erforderlich ist.

Der Workflow: Wie Crawlbase Crawler Betreibt

Crawlbase Crawler basiert auf einem nahtlosen und effizienten Workflow, der in wenigen wichtigen Schritten zusammengefasst werden kann:

Übermittlung von URLs: Als Benutzer initiieren Sie den Prozess, indem Sie URLs an die Crawlbase übermitteln Crawler Verwendung der Crawling API.
Anfragebearbeitung: Die Crawler empfängt diese Anfragen und verarbeitet sie asynchron. Das bedeutet, dass mehrere Anfragen gleichzeitig ohne manuelles Eingreifen bearbeitet werden können.
Datenextraktion: Die Crawler besucht die angegebenen URLs, extrahiert die angeforderten Daten und verpackt sie für die Zustellung.
Webhook-Integration: Crawlbase Crawler lässt sich per Webhook integrieren, sodass keine manuelle Abfrage erforderlich ist. Dieser Webhook dient als Messenger, der die extrahierten Daten in Echtzeit direkt an den Endpunkt Ihres Servers liefert.
Echtzeitlieferung: Die extrahierten Daten werden an den Webhook-Endpunkt Ihres Servers übermittelt, sobald sie verfügbar sind, und ermöglichen so einen sofortigen Zugriff ohne Verzögerungen.
Neue Erkenntnisse: Durch den Erhalt von Daten in Echtzeit verschaffen Sie sich einen Wettbewerbsvorteil, da Sie fundierte Entscheidungen auf der Grundlage der neuesten Webinhalte treffen können.

Die Vorteile: Warum Sie sich für Crawlbase entscheiden sollten Crawler

Ein Crawler ermöglicht zwar sofortiges Web Scraping mit Java, bietet aber auch noch einige andere Vorteile:

Effizienz: Durch die asynchrone Verarbeitung entfällt die Notwendigkeit einer kontinuierlichen Überwachung, sodass Ihre Ressourcen für andere Aufgaben frei werden.
Echtzeit-Einblicke: Erhalten Sie Daten, sobald diese verfügbar sind, sodass Sie Trends und Änderungen immer einen Schritt voraus sind.
Optimierter Arbeitsablauf: Die Webhook-Integration ersetzt manuelle Abfragen und vereinfacht den Datenübermittlungsprozess.
Rechtzeitige Entscheidungsfindung: Der sofortige Zugriff auf frisch extrahierte Daten ermöglicht zeitnahe und datengesteuerte Entscheidungen.

Zugreifen Java-Webcrawler, müssen Sie es innerhalb Ihres Crawlbase-Konto-DashboardSie können sich für TCP oder JavaScript entscheiden Crawler basierend auf Ihren spezifischen Anforderungen. Das TCP Crawler ist ideal für statische Seiten, während JavaScript Crawler eignet sich für Inhalte, die über JavaScript generiert werden, wie z. B. mit JavaScript erstellte Seiten oder dynamisch gerenderte Browserinhalte. Lesen Sie hier, um mehr zu erfahren über Crawlbase Crawler.

Während der Erstellung werden Sie aufgefordert, Ihre Webhook-Adresse anzugeben. Wir werden sie also erstellen, nachdem wir erfolgreich einen Webhook in unserem Spring Boot-Projekt erstellt haben. Im nächsten Abschnitt werden wir tiefer in die Codierung eintauchen und die erforderliche Komponente entwickeln, um unser Projekt abzuschließen.

So funktioniert Web Scraping in Java

Befolgen Sie die nachstehenden Schritte, um Web Scraping in Java zu erlernen.

Die Bühne bereiten: Ihre Umgebung vorbereiten

Bevor wir uns auf unsere Reise ins Deep Crawling begeben, ist es wichtig, die Voraussetzungen für den Erfolg zu schaffen. Dieser Abschnitt führt Sie durch die wesentlichen Schritte, um sicherzustellen, dass Ihre Entwicklungsumgebung bereit ist, die spannenden Herausforderungen zu meistern, die vor Ihnen liegen.

Installieren von Java unter Ubuntu und Windows

Java ist das Rückgrat unseres Entwicklungsprozesses und wir müssen sicherstellen, dass es auf unserem System verfügbar ist. Wenn Sie Java nicht auf Ihrem System installiert haben, können Sie die folgenden Schritte entsprechend Ihrem Betriebssystem ausführen.

Java auf Ubuntu installieren:

Öffnen Sie das Terminal durch Drücken von Strg + Alt + T.
Führen Sie den folgenden Befehl aus, um die Paketliste zu aktualisieren:

1	sudo apt-Update

Installieren Sie das Java Development Kit (JDK), indem Sie Folgendes ausführen:

1	sudo apt installieren default-jdk

Überprüfen Sie die JDK-Installation, indem Sie Folgendes eingeben:

1	Java-Version

Java unter Windows installieren:

Besuche den Beamten Oracle -Website und laden Sie das neueste Java Development Kit (JDK) herunter.
Folgen Sie den Anweisungen des Installationsassistenten, um die Installation abzuschließen. Nach der Installation können Sie sie überprüfen, indem Sie die Eingabeaufforderung öffnen und Folgendes eingeben:

1	Java-Version

Installieren der Spring Tool Suite (STS) unter Ubuntu und Windows:

Spring Tool Suite (STS) ist eine integrierte Entwicklungsumgebung (IDE), die speziell für die Entwicklung von Anwendungen mit dem Spring Framework entwickelt wurde, einem beliebten Java-Framework zum Erstellen von Anwendungen auf Unternehmensebene. STS bietet Tools, Funktionen und Plugins, die die Entwicklungserfahrung bei der Arbeit mit Spring-basierten Projekten verbessern. Befolgen Sie die nachstehenden Schritte, um sie zu installieren.

Besuchen Sie die offizielle Website der Spring Tool Suite unter spring.io/tools.
Laden Sie die entsprechende Version der Spring Tool Suite für Ihr Betriebssystem (Ubuntu oder Windows) herunter.

Unter Ubuntu:

Navigieren Sie nach dem Download im Terminal zu dem Verzeichnis, in dem sich die heruntergeladene Datei befindet.
Entpacke das heruntergeladene Archiv:

1 2	# Ersetzen Und gemäß dem Archivnamen tar -xvf Spring-Tool-Suite- - .tar.gz

Verschieben Sie das extrahierte Verzeichnis an einen Ort Ihrer Wahl:

1 2	# Ersetzen gemäß dem Namen des extrahierten Ordners mv sts- /Ihr_Wunschpfad/

Unter Windows:

Führen Sie das heruntergeladene Installationsprogramm aus und befolgen Sie die Anweisungen auf dem Bildschirm, um die Installation abzuschließen.

Installieren von MySQL unter Ubuntu und Windows

Die Einrichtung eines zuverlässigen Datenbankverwaltungssystems ist von größter Bedeutung, um Ihre Reise ins Deep Crawling und die Extraktion von Webdaten zu starten. MySQL, eine beliebte relationale Open-Source-Datenbank, bietet die Grundlage für die sichere Speicherung und Verwaltung der Daten, die Sie durch Ihre Crawling-Bemühungen sammeln. Hier finden Sie eine Schritt-für-Schritt-Anleitung zur Installation von MySQL auf Ubuntu- und Windows-Plattformen:

MySQL auf Ubuntu installieren:

Öffnen Sie ein Terminal und führen Sie die folgenden Befehle aus, um sicherzustellen, dass Ihr System auf dem neuesten Stand ist:

1 2	sudo apt-Update sudo apt aktualisieren

Führen Sie den folgenden Befehl aus, um das MySQL-Serverpaket zu installieren:

1	sudo apt install mysql-server

Starten Sie nach der Installation den MySQL-Dienst:

1	sudo systemctl starte mysql.service

Überprüfen Sie mit dem folgenden Befehl, ob MySQL ausgeführt wird:

1	sudo systemctl status mysql

MySQL unter Windows installieren:

Besuche den Beamten MySQL-Website und laden Sie das MySQL-Installationsprogramm für Windows herunter.
Führen Sie das heruntergeladene Installationsprogramm aus und wählen Sie den Installationstyp „Developer Default“. Dadurch werden MySQL Server und andere zugehörige Tools installiert.
Während der Installation werden Sie aufgefordert, MySQL Server zu konfigurieren. Legen Sie ein sicheres Root-Passwort fest und merken Sie es sich.
Folgen Sie den Anweisungen des Installationsprogramms, um die Installation abzuschließen.
Nach der Installation sollte MySQL automatisch starten. Sie können es auch manuell über die Windows-Anwendung „Dienste“ starten.

Überprüfen der MySQL-Installation:

Unabhängig von Ihrer Plattform können Sie die MySQL-Installation überprüfen, indem Sie ein Terminal oder eine Eingabeaufforderung öffnen und den folgenden Befehl eingeben:

1	mysql -u root -p

Sie werden aufgefordert, das MySQL-Root-Passwort einzugeben, das Sie während der Installation festgelegt haben. Wenn die Verbindung erfolgreich ist, werden Sie mit der MySQL-Befehlszeilenschnittstelle begrüßt.

Jetzt, da Sie Java und STS bereit haben, sind Sie bereit für die nächste Phase Ihres Deep Crawling-Abenteuers. Im nächsten Schritt führen wir Sie durch die Erstellung eines Spring Boot-Starterprojekts und bereiten damit die Bühne für Ihre Deep Crawling-Bemühungen. Tauchen wir ein in diese spannende Phase der Reise!

Vereinfachen Sie die Einrichtung von Spring Boot-Projekten mit Spring Initializr

Stellen Sie sich vor, das Einrichten eines Spring Boot-Projekts ist wie das Navigieren durch ein kniffliges Labyrinth von Einstellungen. Aber keine Sorge, Frühlings-Initialisierung ist hier, um zu helfen! Es ist, als ob Sie einen intelligenten Helfer online hätten, der den Prozess viel einfacher macht. Sie könnten es manuell machen, aber das ist wie ein Puzzle, das viel Zeit in Anspruch nimmt. Spring Initializr kommt zur Rettung, indem es die Dinge von Anfang an reibungsloser macht. Befolgen Sie die folgenden Schritte, um ein Spring Boot-Projekt mit Spring Initializr zu erstellen.

Gehen Sie zur Spring Initializr-Website

Öffnen Sie Ihren Webbrowser und rufen Sie die Spring Initializr-Website auf. Sie finden sie unter start.spring.io.

Wählen Sie Ihre Projektdetails

Hier treffen Sie wichtige Entscheidungen für Ihr Projekt. Sie müssen den Projekttyp und die Sprache auswählen, die Sie verwenden möchten. Wir müssen wählen Maven als Projekttyp und JAVA als Sprache. Wählen Sie für die Spring Boot-Version eine stabile Version (z. B. 3.1.2). Fügen Sie dann Details zu Ihrem Projekt hinzu, z. B. den Namen und worum es geht. Das ist ganz einfach – folgen Sie einfach dem Beispiel im Bild.

Fügen Sie das coole Zeug hinzu

Es ist Zeit, Ihrem Projekt spezielle Funktionen hinzuzufügen! Es ist, als würden Sie ihm Superkräfte verleihen. Integrieren Sie Spring Web (das ist wichtig für Spring Boot-Projekte), Spring Data JPA und den MySQL-Treiber, wenn Sie eine Datenbank verwenden möchten. Vergessen Sie Lombok nicht – es ist wie ein magisches Werkzeug, das Zeit spart. Wir werden in den nächsten Teilen des Blogs mehr darüber sprechen.

Holen Sie sich Ihr Projekt

Nachdem Sie alle guten Sachen ausgewählt haben, klicken Sie auf „GENERIEREN“. Ihr Starter-Projekt wird als ZIP-Datei heruntergeladen. Öffnen Sie anschließend die ZIP-Datei, um den Anfang Ihres Projekts anzuzeigen.

Wenn Sie diese Schritte befolgen, stellen Sie sicher, dass Ihr Deep-Crawling-Abenteuer reibungslos beginnt. Spring Initializr ist wie ein zuverlässiger Leitfaden, der Sie bei der Einrichtung unterstützt. Im nächsten Abschnitt führen wir Sie durch den Import Ihres Projekts in die von Ihnen installierte Spring Tool Suite. Machen Sie sich bereit, diese aufregende Phase Ihrer Deep-Crawling-Reise zu beginnen!

Importieren des Starterprojekts in die Spring Tool Suite

Gut, jetzt, da Sie Ihr Spring Boot-Starterprojekt vollständig eingerichtet und startklar haben, besteht der nächste Schritt darin, es in die Spring Tool Suite (STS) zu importieren. Es ist, als würden Sie Ihr Projekt in einen gemütlichen Arbeitsbereich einladen, in dem Sie Ihre Magie wirken lassen können. So geht's:

Öffnen Sie die Spring Tool Suite (STS).

Als Erstes starten Sie Ihre Spring Tool Suite. Sie ist Ihr kreativer Mittelpunkt, in dem die gesamte Programmierung und Entwicklung stattfindet.

Importieren des Projekts

Navigieren Sie zum Menü „Datei“ und wählen Sie „Importieren“. Es öffnet sich ein Fenster mit verschiedenen Optionen – wählen Sie „Vorhandene Maven-Projekte“ und klicken Sie auf „Weiter“.

Projektverzeichnis auswählen

Klicken Sie auf die Schaltfläche „Durchsuchen“ und suchen Sie das Verzeichnis, in das Sie Ihr Starter-Projekt entpackt haben. Wählen Sie das Stammverzeichnis des Projekts aus und klicken Sie auf „Fertig“.

Beobachten Sie die Magie

Spring Tool Suite wird seine Magie wirken und Ihr Projekt importieren. Es erscheint im „Projekt-Explorer“ auf der linken Seite Ihres Arbeitsbereichs.

Sind Sie bereit?

Das ist es! Ihr Starter-Projekt ist nun bequem in der Spring Tool Suite eingerichtet. Sie können mit dem Erstellen, Codieren und Erkunden beginnen.

Wenn Sie Ihr Projekt in die Spring Tool Suite integrieren, öffnen sich Ihnen endlose Möglichkeiten. Jetzt haben Sie die Werkzeuge und den Platz, um Ihr Projekt zu etwas ganz Besonderem zu machen. Im folgenden Abschnitt werden wir uns mit der Struktur des Projekts befassen und die einzelnen Schichten abtragen, um seine Komponenten und seine Funktionsweise zu enthüllen. Machen Sie sich bereit für eine Entdeckungsreise, bei der wir Ihnen zeigen, was sich dahinter verbirgt!

Den Entwurf Ihres Projekts verstehen: Ein Blick in die Projektstruktur

Nachdem Ihr Spring Boot-Starterprojekt nun bequem in die Spring Tool Suite (STS) eingebettet ist, werfen wir einen Blick auf die Funktionsweise. Es ist, als würden Sie den Grundriss Ihres neuen Zuhauses kennenlernen, bevor Sie mit der Einrichtung beginnen.

Maven und pom.xml

Im Kern Ihres Projekts liegt ein leistungsstarkes Tool namens Maven. Stellen Sie sich Maven als den Organizer Ihres Projekts vor – es verwaltet Bibliotheken, Abhängigkeiten und Builds. In der Datei mit dem Namen pom.xml geschieht die ganze projektbezogene Magie. Sie ist wie die Blaupause, die Maven sagt, was zu tun ist und was Ihr Projekt braucht. In unserem aktuellen Fall werden wir dies im Projekt pom.xml haben.

<?xml-Version="1.0" Kodierung="UTF-8"?>
<Projekt xmlns=„http://maven.apache.org/POM/4.0.0“ xmlns:xsi="http://www.w3.org/2001/XMLSchema-Instanz"
 xsi:schemaLocation=„http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd“>
   <ModellVersion>4.0.0</ModellVersion>
   <Elternteil>
      <Gruppen-ID>org.springframework.boot</Gruppen-ID>
      <Artefakt-ID>Spring-Boot-Starter-Eltern</Artefakt-ID>
      <Version>3.1.2</Version>
      <relativerPfad/> 
   </Elternteil>
   <Gruppen-ID>com.beispiel</Gruppen-ID>
   <Artefakt-ID>Crawlbase</Artefakt-ID>
   <Version>0.0.1-SCHNAPPSCHUSS</Version>
   <Name>Crawlbase Crawler Mit Spring Boot</Name>
   <Beschreibung>Demo zur Verwendung von Crawlbase Crawler mit Spring Boot und wie man Deep Crawling macht</Beschreibung>
   <immobilien>
      <java.version>17</java.version>
   </immobilien>
   <Abhängigkeiten>
      <Abhängigkeit>
         <Gruppen-ID>org.springframework.boot</Gruppen-ID>
         <Artefakt-ID>Spring-Boot-Starter-Daten-JPA</Artefakt-ID>
      </Abhängigkeit>
      <Abhängigkeit>
         <Gruppen-ID>org.springframework.boot</Gruppen-ID>
         <Artefakt-ID>Spring-Boot-Starter-Web</Artefakt-ID>
      </Abhängigkeit>
      <Abhängigkeit>
         <Gruppen-ID>com.mysql</Gruppen-ID>
         <Artefakt-ID>MySQL-Connector-J</Artefakt-ID>
         <Umfang>Laufzeit</Umfang>
      </Abhängigkeit>
      <Abhängigkeit>
         <Gruppen-ID>org.projectlombok</Gruppen-ID>
         <Artefakt-ID>Lombok</Artefakt-ID>
         <optional>was immer dies auch sein sollte.</optional>
      </Abhängigkeit>
      <Abhängigkeit>
         <Gruppen-ID>org.springframework.boot</Gruppen-ID>
         <Artefakt-ID>Spring-Boot-Starter-Test</Artefakt-ID>
         <Umfang>Test</Umfang>
      </Abhängigkeit>
   </Abhängigkeiten>

   <bauen>
      <Plugins>
         <Plugin>
            <Gruppen-ID>org.springframework.boot</Gruppen-ID>
            <Artefakt-ID>Spring-Boot-Maven-Plugin</Artefakt-ID>
            <Konfiguration>
               <umfasst nicht>
                  <ausschließen>
                     <Gruppen-ID>org.projectlombok</Gruppen-ID>
                     <Artefakt-ID>Lombok</Artefakt-ID>
                  </ausschließen>
               </umfasst nicht>
            </Konfiguration>
         </Plugin>
        </Plugins>
   </bauen>
</Projekt>

Java-Bibliotheken

Erinnern Sie sich an die speziellen Funktionen, die Sie beim Erstellen des Projekts hinzugefügt haben? Sie werden Abhängigkeiten genannt, wie magische Tools, die Ihr Projekt leistungsfähiger machen. Sie haben diese Bibliotheken tatsächlich hinzugefügt, als Sie Spring Web, Spring Data JPA, MySQL Driver und Lombok aus dem Spring Initializr einbezogen haben. Sie können diese in der obigen pom.xml sehen. Sie bringen vorgefertigte Funktionen in Ihr Projekt und sparen Ihnen Zeit und Mühe.

Frühlingsweb: Mit dieser Bibliothek können Sie Spring Boot-Webanwendungen erstellen. Sie hilft beispielsweise bei der Bearbeitung von Anfragen und der Erstellung von Webcontrollern.
Spring Data JPA: Diese Bibliothek ist Ihr Verbündeter, wenn Sie mit Datenbanken arbeiten. Sie vereinfacht die Datenbankinteraktion und -verwaltung, sodass Sie sich auf die Logik Ihres Projekts konzentrieren können.
MySQL-Treiber: Wenn Sie MySQL als Datenbank verwenden, hilft dieser Treiber Ihrem Projekt, effektiv mit der Datenbank zu kommunizieren.
Lombok: Verabschieden Sie sich von sich wiederholendem Code! Lombok reduziert den Boilerplate-Code, den Sie normalerweise schreiben müssen, und macht Ihr Projekt übersichtlicher und prägnanter.

Verstehen Sie die Projektstruktur

Wenn Sie die Ordner Ihres Projekts durchsuchen, werden Sie feststellen, wie ordentlich alles organisiert ist. Ihr Java-Code kommt in das Verzeichnis src/main/java, während Ressourcen wie Konfigurationsdateien und statische Assets im Verzeichnis src/main/resources liegen. Hier finden Sie auch die Datei application.properties – sie ist wie das Kontrollzentrum Ihres Projekts, in dem Sie Einstellungen konfigurieren können.

Im src/main/java Verzeichnis finden wir ein Paket, das eine Java-Klasse mit Hauptfunktion enthält. Diese Datei dient als Ausgangspunkt bei der Ausführung des Spring Boot-Projekts. In unserem Fall haben wir CrawlbaseApplication.java Datei mit folgendem Code.

Paket com.beispiel.crawlbase;

importieren org.springframework.boot.SpringApplication;
importieren org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootAnwendung
// Fügen Sie dies hinzu, um Asynchronität im Projekt zu aktivieren
@EnableAsync
Öffentlichkeit Klasse CrawlbaseAnwendung {

    Öffentlichkeit statisch ungültig Haupt-(String[] args) {
        SpringApplication.run(CrawlbaseApplication.class, args);
    }

}

Jetzt, da Sie mit den Grundlagen vertraut sind, können Sie sich sicher in der Landschaft Ihres Projekts zurechtfinden. Bevor wir mit der Codierung beginnen, werden wir uns mit Crawlbase befassen und versuchen zu verstehen, wie es funktioniert und wie wir es in unserem Projekt verwenden können. Machen Sie sich also bereit, die wahre Leistungsfähigkeit von Crawlern zu entdecken.

Beginnen Sie Ihre Programmierreise mit Java Scraping

Nachdem Sie nun das Java Web Scraping Framework, die Java Web Scraping Library und den Java Web Scraper eingerichtet haben, ist es an der Zeit, in die Programmierung des Java Web Scraping-Tutorials einzutauchen. In diesem Abschnitt werden die wesentlichen Schritte zum Erstellen von Controllern, Diensten, Repositories und Aktualisieren von Eigenschaftendateien beschrieben. Bevor wir uns mit den Einzelheiten der Programmierung befassen, müssen wir die Grundlagen legen und wichtige Abhängigkeiten einführen, die unser Projekt unterstützen.

Da wir die Crawlbase verwenden Crawler, ist es wichtig sicherzustellen, dass wir es problemlos in unserem Java-Projekt verwenden können. Glücklicherweise bietet Crawlbase eine Java-Bibliothek, die diesen Integrationsprozess vereinfacht. Um sie zu unserem Projekt hinzuzufügen, müssen wir nur die entsprechende Maven-Abhängigkeit in die pom.xml-Datei des Projekts aufnehmen.

<Abhängigkeit>
    <Gruppen-ID>com.crawlbase</Gruppen-ID>
    <Artefakt-ID>Crawlbase-Java-SDK-POM</Artefakt-ID>
    <Version>1.0</Version>
</Abhängigkeit>

Nach dem Hinzufügen dieser Abhängigkeit stellt eine schnelle Maven-Installation sicher, dass die Crawlbase Java-Bibliothek aus dem Maven-Repository heruntergeladen und einsatzbereit ist.

Integrieren der JSoup-Abhängigkeit

Da wir uns eingehend mit HTML-Inhalten befassen, ist es wichtig, einen leistungsstarken HTML-Parser zur Verfügung zu haben. Hier kommt JSoup ins Spiel, ein robuster und vielseitiger HTML-Parser für Java. Er bietet praktische Methoden zum Navigieren und Bearbeiten von HTML-Strukturen. Um seine Funktionen nutzen zu können, müssen wir die JSoup-Bibliothek über eine weitere Maven-Abhängigkeit in unser Projekt einbinden:

<Abhängigkeit>
    <Gruppen-ID>org.jsoup</Gruppen-ID>
    <Artefakt-ID>jsuppe</Artefakt-ID>
    <Version>1.16.1</Version>
</Abhängigkeit>

Einrichten der Datenbank

Bevor wir fortfahren, legen wir den Grundstein für unser Projekt, indem wir eine Datenbank erstellen. Befolgen Sie diese Schritte, um eine MySQL-Datenbank zu erstellen:

Öffnen Sie die MySQL-Konsole: Wenn Sie Ubuntu verwenden, öffnen Sie ein Terminalfenster. Öffnen Sie unter Windows den MySQL-Befehlszeilenclient oder die MySQL-Shell.
Melden Sie sich bei MySQL an: Geben Sie den folgenden Befehl ein und geben Sie Ihr MySQL-Root-Passwort ein, wenn Sie dazu aufgefordert werden:

1	mysql -u root -p

Erstellen Sie eine neue Datenbank: Erstellen Sie nach der Anmeldung eine neue Datenbank mit dem gewünschten Namen:

1 2	# Ersetzen Sie database_name durch den von Ihnen gewählten Namen DATENBANK ERSTELLEN Datenbankname;

Planen der Modelle

Bevor wir uns kopfüber in die Modellplanung stürzen, wollen wir verstehen, was der Crawler zurückgibt, wenn URLs an ihn gesendet werden, und welche Antwort wir bei unserem Webhook erhalten. Wenn wir URLs an den Crawler senden, antwortet er mit einer Request-ID wie dieser:

1	{ "loswerden": "1e92e8bff32c31c2728714d4" }

Sobald der Crawler den HTML-Inhalt erfolgreich gecrawlt hat, leitet er die Ausgabe an unseren Webhook weiter. Die Antwort sieht folgendermaßen aus:

Headers:
  "Inhaltstyp" => "Text/Plain"
  "Inhaltskodierung" => "gzip"
  "Original-Status" => 200
  "PC-Status" => 200
  "loswerden" => „Die RID, die Sie im Push-Call erhalten haben“
  "URL" => „Die URL, die gecrawlt wurde“

Korpus:
  Das HTML der Seite

// Der Text wird gzip-kodiert

Wenn wir dies berücksichtigen, können wir die folgende Datenbankstruktur in Betracht ziehen.

Wir müssen die Datenbanktabellen nicht direkt erstellen, da wir unser Spring Boot-Projekt so einrichten, dass die Tabellen automatisch initialisiert werden, wenn wir es ausführen. Wir werden überwintern das für uns zu tun.

Entwerfen der Modelldateien

Nachdem wir die Grundlagen im vorherigen Abschnitt gelegt haben, können wir uns nun mit der Erstellung unserer Modelldateien befassen. Im com.example.crawlbase.models Paket erstellen wir zwei grundlegende Modelle: CrawlerRequest.java und CrawlerResponse.java. Diese Modelle kapseln die Struktur unserer Datenbanktabellen und um die Effizienz zu gewährleisten, werden wir Lombok verwenden, um den Boilerplate-Code zu reduzieren.

CrawlerAnforderungsmodell:

Paket com.beispiel.crawlbase.models;

importieren jakarta.persistence.CascadeType;
importieren jakarta.persistence.Entity;
importieren jakarta.persistence.FetchType;
importieren jakarta.persistence.GenerierterWert;
importieren jakarta.persistence.Id;
importieren jakarta.persistence.EinsZuEins;
importieren lombok.AllArgsKonstruktor;
importieren lombok.Builder;
importieren lombok.Daten;
importieren lombok.NoArgsConstructor;

@Juristische Person
@Daten
@NoArgsConstructor
@AllArgsConstructor
@Builder(toBuilder = wahr)
Öffentlichkeit Klasse CrawlerPREISANFRAGE (Request) {

    @Ich würde
    @GenerierterWert
    privat Lange ID;

    privat String-URL;
    privat Zeichenfolgentyp;
    privat Ganzzahliger Status;
    privat Schnur loswerden;

    @OneToOne(mappedBy = "crawlerRequest", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    privat CrawlerAntwortcrawlerAntwort;

}

CrawlerAntwortmodell:

Paket com.beispiel.crawlbase.models;

importieren jakarta.persistence.Spalte;
importieren jakarta.persistence.Entity;
importieren jakarta.persistence.GenerierterWert;
importieren jakarta.persistence.Id;
importieren jakarta.persistence.JoinColumn;
importieren jakarta.persistence.EinsZuEins;
importieren lombok.AllArgsKonstruktor;
importieren lombok.Builder;
importieren lombok.Daten;
importieren lombok.NoArgsConstructor;

@Juristische Person
@Daten
@NoArgsConstructor
@AllArgsConstructor
@Builder(toBuilder = wahr)
Öffentlichkeit Klasse CrawlerAntwort {

    @Ich würde
    @GenerierterWert
    privat Lange ID;

    privat Ganzzahliger pcStatus;
    privat Ganzzahliger Originalstatus;

    @Column(Spaltendefinition = "LANGER TEXT")
    privat Zeichenfolge pageHtml;

    @EinsZuEins
    @JoinColumn(Name = "Anforderungs-ID")
    privat CrawlerCrawlerRequest anfordern;

}

Einrichten von Repositorien für beide Modelle

Nach der Erstellung unserer Modelle besteht der nächste Schritt darin, Repositories für eine nahtlose Interaktion zwischen unserem Projekt und der Datenbank einzurichten. Diese Repository-Schnittstellen dienen als wichtige Konnektoren und nutzen die JpaRepository-Schnittstelle, um grundlegende Funktionen für den Datenzugriff bereitzustellen. Hibernate, ein leistungsstarkes ORM-Tool, verwaltet die zugrunde liegende Zuordnung zwischen Java-Objekten und Datenbanktabellen.

Erstellen Sie ein Paket com.example.crawlbase.repositories und erstellen Sie darin zwei Repository-Schnittstellen, CrawlerRequestRepository.java und CrawlerResponseRepository.java.

CrawlerRequestRepository-Schnittstelle:

Paket com.beispiel.crawlbase.repositories;

importieren java.util.Liste;
importieren org.springframework.data.jpa.repository.JpaRepository;
importieren org.springframework.data.jpa.repository.Abfrage;
importieren org.springframework.data.repository.query.Param;

importieren com.beispiel.crawlbase.models.CrawlerAnfrage;

Öffentlichkeit Schnittstelle CrawlerAnfrage-Repository erweitert JpaRepository<CrawlerAnfrage, Lang> {

    //Suchen nach Spaltenname und -wert
    ListeCrawlerAnfrage> findByRid(Zeichenfolgenwert);
}

CrawlerResponseRepository-Schnittstelle:

Paket com.beispiel.crawlbase.repositories;

importieren org.springframework.data.jpa.repository.JpaRepository;
importieren com.beispiel.crawlbase.models.CrawlerAntwort;

Öffentlichkeit Schnittstelle CrawlerAntwort-Repository erweitert JpaRepository<CrawlerAntwort, Lang> {

}

Planen von APIs und Request Body Mapper-Klassen

Nutzung der Crawlbase Crawler beinhaltet die Entwicklung von zwei wichtigen APIs: eine zum Weiterleiten von URLs an den Crawler und eine andere, die als Webhook dient. Lassen Sie uns zunächst die Anforderungstextstrukturen für diese APIs planen.

Push-URL-Anforderungstext:

{
    "URLs": [
        „http://www.3bfluidpower.com/“,
        .....
    ]
}

Der Anforderungstext der Webhook-API muss mit dem übereinstimmen CrawlerAntwortstruktur, wie bereits besprochen. Sie können mehr darüber lesen HIER.

Im Rahmen dieser Planung erstellen wir zwei Request-Mapping-Klassen im com.example.crawlbase.requests Paket:

CrawlerWebhookRequest-Klasse:

Paket com.beispiel.crawlbase.requests;

importieren lombok.Builder;
importieren lombok.Daten;

@Daten
@Baumeister
Öffentlichkeit Klasse CrawlerWebhook-Anfrage {

    privat Ganzzahliger PC_Status;
    privat Ganzzahliger Originalstatus;
    privat Schnur loswerden;
    privat String-URL;
    privat Saitenkörper;

}

ScrapeUrlRequest-Klasse:

Paket com.beispiel.crawlbase.requests;

importieren lombok.Builder;
importieren lombok.Daten;

@Daten
@Baumeister
Öffentlichkeit Klasse CrawlerWebhook-Anfrage {

    privat Ganzzahliger PC_Status;
    privat Ganzzahliger Originalstatus;
    privat Schnur loswerden;
    privat String-URL;
    privat Saitenkörper;

}

Erstellen eines ThreadPools zur Optimierung des Webhooks

Wenn wir unseren Webhook nicht für die Verarbeitung einer großen Anzahl von Anfragen optimieren, führt dies zu versteckten Problemen. Hier können wir Multithreading verwenden. In JAVA wird ThreadPoolTaskExecutor verwendet, um einen Pool von Worker-Threads für die gleichzeitige Ausführung asynchroner Aufgaben zu verwalten. Dies ist insbesondere dann nützlich, wenn Sie Aufgaben haben, die unabhängig und parallel ausgeführt werden können.

Erstellen Sie ein neues Paket com.example.crawlbase.config und formen ThreadPoolTaskExecutorConfig.java Datei darin.

ThreadPoolTaskExecutorConfig-Klasse:

Paket com.example.crawlbase.config;

importieren org.springframework.context.annotation.Bean;
importieren org.springframework.context.annotation.Konfiguration;
importieren org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Aufbau
Öffentlichkeit Klasse ThreadPoolTaskExecutorConfig {

    @Bean(Name = "TaskExecutor")
    Öffentlichkeit ThreadPoolTaskExecutor TaskExecutor() {
        int Kerne = Runtime.getRuntime().availableProcessors();
        ThreadPoolTaskExecutor Testamentsvollstrecker = neu ThreadPoolTaskExecutor();
        executor.setCorePoolSize(Kerne);
        executor.setMaxPoolSize(Kerne);
        Executor.SetQueueCapacity(Integer.MAX_VALUE);
        executor.setThreadNamePrefix(„Asynchron-“);
        Executor.initialisieren();
        Rückkehr Testamentsvollstrecker;
    }
}

Erstellen der Controller und ihrer Dienste

Da wir zwei APIs benötigen und deren Geschäftslogik sehr unterschiedlich ist, werden wir sie in separaten Controllern implementieren. Separate Controller bedeuten, dass wir separate Dienste haben werden. Erstellen wir zunächst einen MainController.java und sein Dienst als MainService.java. Wir implementieren die API, die Sie auf der URL pushen. Crawler in diesem Controller.

Erstellen Sie ein neues Paket com.example.crawlbase.controllers für Controller und com.example.crawlbase.services für Leistungen im Projekt.

MainController-Klasse:

Paket com.beispiel.crawlbase.controllers;

importieren org.springframework.beans.factory.annotation.Autowired;
importieren org.springframework.http.HttpStatus;
importieren org.springframework.http.ResponseEntity;
importieren org.springframework.web.bind.annotation.PostMapping;
importieren org.springframework.web.bind.annotation.RequestBody;
importieren org.springframework.web.bind.annotation.RequestMapping;
importieren org.springframework.web.bind.annotation.RestController;

importieren com.example.crawlbase.requests.ScrapeUrlRequest;
importieren com.example.crawlbase.services.MainService;

importieren lombok.extern.slf4j.Slf4j;

@RestController
@RequestMapping("/scrape")
@Slf4j
Öffentlichkeit Klasse Hauptcontroller {

 @Autowired
 privat Hauptdienst Hauptdienst;

 @PostMapping("/push-urls")
 Öffentlichkeit Antwortentität pushUrlsToCawler(@RequestBody ScrapeUrlRequest-Anfrage) {
  versuchen {
   if(!request.getUrls().isEmpty()) {
    // Die Anfrage asynchron verarbeiten
    mainService.pushUrlsToCrawler(Anfrage.getUrls(), "Elternteil");
   }
   Rückkehr ResponseEntity.status(HttpStatus.OK).build();
  } Fang (Ausnahme e) {
   log.fehler("Fehler in pushUrlsToCrawler Funktion: " + e.getMessage());
   Rückkehr ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
  }
 }

}

Wie Sie oben sehen können, haben wir eine Restful-API „@POST /scrape/push-urls“ erstellt, die für die Bearbeitung der Anfrage zum Pushen von URLs an die Crawler.

MainService-Klasse:

Paket com.example.crawlbase.services;

importieren java.util.*;
importieren com.crawlbase.*;
importieren com.beispiel.crawlbase.models.CrawlerAnfrage;
importieren com.beispiel.crawlbase.repositories.CrawlerAnforderungs-Repository;
importieren com.fasterxml.jackson.databind.JsonNode;
importieren com.fasterxml.jackson.databind.ObjectMapper;

importieren lombok.extern.slf4j.Slf4j;

importieren org.springframework.beans.factory.annotation.Autowired;
importieren org.springframework.beans.factory.annotation.Wert;
importieren org.springframework.scheduling.annotation.Async;
importieren org.springframework.stereotype.Service;

@Slf4j
@Bedienung
Öffentlichkeit Klasse Hauptservice {

 @Autowired
    privat CrawlerRequestRepository CrawlerRequestRepository;

    // Einfügen der Werte aus der Eigenschaftendatei
    @Wert("${crawlbase.token}")
    privat Zeichenfolge CrawlbaseToken;
    @Wert("${crawlbase.crawler}")
    privat Zeichenfolge CrawlbaseCrawlerName;

    privat Finale ObjectMapper ObjektMapper = neu ObjectMapper();

    @Asynchron
    Öffentlichkeit ungültig pushUrlsToCrawler(Liste URLs, String-Typ) {
    HashMap Optionen = neu HashMap();
        Optionen.put("Rückruf", "True");
        Optionen.put("Raupen", CrawlbaseCrawlerName);
        Optionen.put("Rückruf_Header", "Typ:" + Typ);

        API Bienen = null;
        CrawlerPREISANFRAGE (Request) req = null;
        JsonNode jsonNode = null;
        Schnur zu befreien = null;

        
für(String-URL: URLs) {
            versuchen {
            API = neu API(CrawlbaseToken);
            api.get(URL, Optionen);
            jsonNode = objectMapper.readTree(api.getBody());
                befreien = jsonNode.get("loswerden").asText();
                if(befreien != null) {
                    erforderlich = CrawlerRequest.builder().url(url).Typ(Typ).
                    status(api.getStatusCode()).rid(rid).build();
                    crawlerRequestRepository.save(req);
                }
            } Fang(Ausnahme e) {
                log.fehler("Fehler in pushUrlsToCrawler Funktion: " + e.getMessage());
            }
        }
    }

}

Im obigen Dienst haben wir eine Async-Methode erstellt, um die Anforderung asynchron zu verarbeiten. pushUrlsToCrawler Funktion verwendet die Crawlbase-Bibliothek, um URLs an die Crawler und speichern Sie dann die empfangene RID und andere Attribute in der crawler_request-Tabelle. Um URLs an die Crawlermüssen wir die Parameter „Crawler“ und „Callback“ verwenden. Wir verwenden außerdem „Callback_Headers“, um einen benutzerdefinierten Header-„Typ“ zu senden, mit dessen Hilfe wir feststellen, ob die URL die von uns angegebene ist oder ob sie beim Deep Crawling abgekratzt wurde. Weitere Informationen zu diesen und vielen anderen Parametern finden Sie hier.

Nun müssen wir die API implementieren. Wir werden dafür einen Webhook verwenden. Dafür erstellen wir WebhookController.java begann com.example.crawlbase.controllers Paket und WebhookService.java begann com.example.crawlbase.services Paket.

WebhookController-Klasse:

Paket com.beispiel.crawlbase.controllers;

importieren org.springframework.beans.factory.annotation.Autowired;
importieren org.springframework.http.HttpHeaders;
importieren org.springframework.http.HttpStatus;
importieren org.springframework.http.ResponseEntity;
importieren org.springframework.web.bind.annotation.PostMapping;
importieren org.springframework.web.bind.annotation.RequestBody;
importieren org.springframework.web.bind.annotation.RequestHeader;
importieren org.springframework.web.bind.annotation.RequestMapping;
importieren org.springframework.web.bind.annotation.RestController;

importieren com.example.crawlbase.services.WebhookService;

importieren lombok.extern.slf4j.Slf4j;

@RestController
@RequestMapping("/webhook")
@Slf4j
Öffentlichkeit Klasse WebhookController {

    @Autowired
    privat Webhook-Dienst Webhook-Dienst;

    @PostMapping("/crawlbase")
    Öffentlichkeit Antwortentität CrawlbaseCrawlerAntwort(@RequestHeader HttpHeaders-Header, @RequestBody Byte[] komprimierter Körper) {
        versuchen {
        if(!headers.getFirst(HttpHeaders.USER_AGENT).equalsIgnoreCase(„Crawlbase-Überwachungsbot 1.0“) &&
            "gzip".equalsIgnoreCase(headers.getFirst(HttpHeaders.CONTENT_ENCODING)) &&
            headers.getFirst("pc_status").gleich("200")) {
            // Die Anfrage asynchron verarbeiten
            webhookService.handleWebhookResponse(Header, komprimierter Text);
        }
        Rückkehr ResponseEntity.status(HttpStatus.OK).build();
        } Fang (Ausnahme e) {
            log.fehler("Fehler in CrawlbaseCrawlerAntwortfunktion: " + e.getMessage());
            Rückkehr ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
        }
    }

}

Im obigen Code können Sie sehen, dass wir eine Restful-API erstellt haben, „@POST /webhook/crawlbase“, die für den Empfang der Antwort auf die Ausgabeanforderung von verantwortlich ist Crawler. Sie können im Code feststellen, dass wir die Aufrufe mit USER_AGENT als „Crawlbase Monitoring Bot 1.0“ ignorieren, weil Crawler Monitoring Bot fordert diesen Benutzeragenten auf, zu prüfen, ob der Rückruf aktiv und zugänglich ist. Diese Anfrage muss also nicht verarbeitet werden. Geben Sie einfach eine erfolgreiche Antwort an den Crawler.

Während der Arbeit mit Crawlbase Crawler, Ihr Server-Webhook sollte…

Öffentlich von Crawlbase-Servern aus erreichbar sein
Seien Sie bereit, POST-Anrufe zu empfangen und innerhalb von 200 ms zu antworten
Antworten Sie innerhalb von 200 ms mit einem Statuscode 200, 201 oder 204 ohne Inhalt

WebhookService-Klasse:

Paket com.example.crawlbase.services;

importieren java.io.ByteArrayInputStream;
importieren java.io.InputStreamReader;
importieren java.net.URI;
importieren java.net.URISyntaxException;
importieren java.util.ArrayList;
importieren java.util.Liste;
importieren java.util.Objekte;
importieren java.util.regex.Matcher;
importieren java.util.regex.Muster;
importieren java.util.zip.GZIPInputStream;

importieren org.jsoup.Jsoup;
importieren org.jsoup.nodes.Dokument;
importieren org.jsoup.nodes.Element;
importieren org.jsoup.select.Elemente;
importieren org.springframework.beans.factory.annotation.Autowired;
importieren org.springframework.http.HttpHeaders;
importieren org.springframework.scheduling.annotation.Async;
importieren org.springframework.stereotype.Service;

importieren com.beispiel.crawlbase.models.CrawlerAnfrage;
importieren com.beispiel.crawlbase.models.CrawlerAntwort;
importieren com.beispiel.crawlbase.repositories.CrawlerAnforderungs-Repository;
importieren com.beispiel.crawlbase.repositories.CrawlerAntwort-Repository;
importieren com.example.crawlbase.requests.CrawlerWebhook-Anfrage;

importieren lombok.extern.slf4j.Slf4j;

@Slf4j
@Bedienung
Öffentlichkeit Klasse Webhook-Dienst {

    @Autowired
    privat CrawlerRequestRepository CrawlerRequestRepository;
    @Autowired
    privat CrawlerAntwort-Repository crawlerResponseRepository;
    @Autowired
    privat Hauptdienst Hauptdienst;

    @Async("taskExecutor")
    Öffentlichkeit ungültig HandleWebhookAntwort(HttpHeaders-Header, Byte[] komprimierter Körper) {
        versuchen {
            // Entpacken Sie den gzippten Textkörper
            GZIPInputStream gzipEingabestream = neu GZIPInputStream(neu ByteArrayInputStream(komprimierter Körper));
            InputStreamReader Leser = neu InputStreamReader(gzipInputStream);

            // Verarbeiten Sie den unkomprimierten HTML-Inhalt
            StringBuilder htmlInhalt = neu StringBuilder();
            verkohlen[] Puffer = neu verkohlen[1024];
            int bytesLesen;
            während ((bytesRead = reader.read(buffer)) != -1) {
                htmlContent.append(Puffer, 0, BytesLesen);
            }

            // Der HTML-String
            Schnur htmlString = htmlContent.toString();

            //Erstellen des Request-Objekts
            CrawlerWebhook-Anfrage Anforderung = CrawlerWebhookRequest.builder()
                .original_status(Integer.valueOf(headers.getFirst("ursprünglicher_Status")))
                .pc_status(Integer.Wert von(headers.getFirst("pc_status")))
                .rid(header.getFirst("loswerden"))
                .url(header.getFirst("URL"))
                .body(htmlString).build();

            // Speichern CrawlerAntwortmodell
            ListeCrawlerAnfrage> Ergebnisse = crawlerRequestRepository.findByRid(request.getRid());
            CrawlerPREISANFRAGE (Request) Crawler-Anfrage = !results.isEmpty() ? Ergebnisse.get(0): null;
            if(CrawlerAnfrage != null) {
                // Bauen CrawlerAntwortmodell
                CrawlerAntwort CrawlerAntwort = CrawlerAntwort.builder().pcStatus(Anfrage.getPc_status())
                    .originalStatus(request.getOriginal_status()).pageHtml(request.getBody()).crawlerRequest(crawlerRequest).build();
                crawlerResponseRepository.save(crawlerResponse);
            }

            // Nur übergeordnete URL tief crawlen
            if(header.getFirst("Typ").equalsIgnoreCase("Elternteil")) {
                deepCrawlParentResponse(request.getBody(), request.getUrl());
            }
        } Fang (Ausnahme e) {
            log.fehler(„Fehler in der Funktion handleWebhookResponse: „ + e.getMessage());
        }

    }

    privat ungültig deepCrawlParentResponse(String HTML, String Basis-URL) {
    Dokument Dokument = Jsoup.parse(html);
        verschiedenste Komponenten Hyperlinks = document.getElementsByTag("ein");
        Liste Links = neu Anordnungsliste();

        Schnur URL = null;
        
für (Element HyperLink: Hyperlinks) {
            url = Prozess-Url(HyperLink.attr("href"), Basis-URL);
            if(URL != null) {
            links.add(url);
        }
        }

        mainService.pushUrlsToCrawler(Links, "Kind");
    }

    privat Schnur ProzessURL(String href, String Basis-URL) {
        versuchen {
            if (href != null && !href.isEmpty()) {
                Basis-URL = Normalisierungs-URL (Basis-URL);
                Schnur verarbeiteteURL = normalizeUrl(href.startsWith("/") ? Basis-URL + href : href);
                if (isValidUrl(verarbeiteteUrl) &&
                    !verarbeiteteURL.ersetzen("http://", "").ersetzen("https://", "").equals(baseUrl.replace("http://", "").ersetzen("https://", "")) &&
                    // Es werden nur URLs mit gleichem Hostnamen berücksichtigt
                    Objekte.gleich(neu URI(verarbeiteteURL).getHost(), neu URI(baseUrl).getHost())) {

                    Rückkehr verarbeiteteURL;
                }
            }
        } Fang (Ausnahme e) {
            log.fehler(„Fehler in der Funktion processUrl: „ + e.getMessage());
        }
        Rückkehr null;
    }

    privat boolean ist gültige URL(Zeichenfolge Zeichenfolge) {
     Schnur urlRegex = "((http|https)://)(www.)?"
                + „[a-zA-Z0-9@:%._\\+~#?&//=]“
                + „{2,256}\\.[az]“
                + "{2,6}\\b([-a-zA-Z0-9@:%"
                + "._\\+~#?&//=]*)";
        Schnittmuster Anleitungen = Muster.kompilieren(urlRegex);
        Matcher Matcher = Muster.Matcher(Zeichenfolge);
        Rückkehr matcher.matches();
    }

    privat Schnur URL normalisieren(String-URL) wirft URISyntaxException {
        url = url.ersetzen("//www.", "//");
        url = url.split("#")[0];
        url = url.endetMit("/") ? url.Teilzeichenfolge(0, url.länge() - 1) : URL;
        Rückkehr URL:
    }
}

Die Klasse WebhookService spielt eine entscheidende Rolle bei der effizienten Verarbeitung von Webhook-Antworten und der Orchestrierung des Deep Crawling-Prozesses. Wenn eine Webhook-Antwort empfangen wird, wird die Methode handleWebhookResponse asynchron von der Crawlbase des WebhookControllers aufgerufen.CrawlerAntwortfunktion. Diese Methode beginnt mit dem Entpacken des komprimierten HTML-Inhalts und dem Extrahieren der erforderlichen Metadaten und HTML-Daten. Die extrahierten Daten werden dann verwendet, um eine CrawlerWebhookRequest-Objekt, das Details wie Status, Anforderungs-ID (rid), URL und HTML-Inhalt enthält.

Als nächstes prüft der Dienst, ob ein vorhandener CrawlerAnfrage, die mit der Anfrage-ID verknüpft ist. Wenn sie gefunden wird, wird eine CrawlerAntwortobjekt zur Einkapselung der relevanten Antwortdetails. Dies CrawlerDie Antwortinstanz wird dann in der Datenbank gespeichert durch CrawlerAntwort-Repository.

Was diesen Dienst jedoch auszeichnet, ist seine Fähigkeit, Deep Crawling zu ermöglichen. Wenn der Webhook-Antworttyp eine „übergeordnete“ URL anzeigt, ruft der Dienst die Methode deepCrawlParentResponse auf. Bei dieser Methode wird der HTML-Inhalt mithilfe der Jsoup-Bibliothek analysiert, um Hyperlinks innerhalb der Seite zu identifizieren. Diese Hyperlinks, die untergeordnete URLs darstellen, werden verarbeitet und validiert. Nur URLs, die zum selben Hostnamen gehören und einem bestimmten Format entsprechen, werden beibehalten.

Der MainService wird dann eingesetzt, um diese gültigen untergeordneten URLs in die Crawling-Pipeline zu schieben, wobei der Typ „child“ als Flag verwendet wird. Dadurch wird ein rekursiver Prozess des Deep Crawlings eingeleitet, bei dem untergeordnete URLs weiter gecrawlt werden, wodurch die Erkundung auf mehrere Ebenen miteinander verbundener Seiten ausgeweitet wird. Im Wesentlichen koordiniert der WebhookService den komplizierten Tanz der Verarbeitung von Webhook-Antworten, der Erfassung und Aufbewahrung relevanter Daten und der Orchestrierung des komplizierten Prozesses des Deep Crawlings durch intelligente Identifizierung und Navigation durch übergeordnete und untergeordnete URLs.

Aktualisieren der Datei application.properties

Im letzten Schritt konfigurieren wir die Datei application.properties, um wesentliche Eigenschaften und Einstellungen für unser Projekt zu definieren. Diese Datei dient als zentraler Knotenpunkt für die Konfiguration verschiedener Aspekte unserer Anwendung. Hier müssen wir datenbankbezogene Eigenschaften, Hibernate-Einstellungen, Details zur Crawlbase-Integration und Protokollierungseinstellungen angeben.

Stellen Sie sicher, dass Ihre Datei application.properties die folgenden Eigenschaften enthält:

# Datenbankkonfiguration
spring.datasource.url=jdbc:mysql://localhost:3306/
spring.datasource.benutzername=
spring.datasource.password=

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update

# Crawlbase Crawler Integration
crawlbase.token=
crawlbase.crawler=Crawler_Name>

logging.file.name=Protokolle/ .Log

Sie finden Ihr Crawlbase TCP (normal) Token HIER. Denken Sie daran, die Platzhalter im obigen Code durch Ihre tatsächlichen Werte zu ersetzen, wie in den vorherigen Abschnitten festgelegt. Diese Konfiguration ist wichtig für das Herstellen von Datenbankverbindungen, das Synchronisieren von Hibernate-Vorgängen, die Integration mit der Crawlbase-API und das Verwalten der Protokollierung für Ihre Anwendung. Durch sorgfältiges Anpassen dieser Eigenschaften stellen Sie eine nahtlose Kommunikation zwischen verschiedenen Komponenten und Diensten in Ihrem Projekt sicher.

Ausführen des Projekts und Starten des Deep Crawlings

Nach Abschluss der Codierungsphase besteht der nächste Schritt darin, das Projekt in Gang zu setzen. Spring Boot verwendet im Kern einen eingebetteten Apache Tomcat-Build, der für reibungslose Übergänge von der Entwicklung zur Produktion sorgt und sich nahtlos in gängige Plattformen als Service integriert. Die Ausführung des Projekts innerhalb der Spring Tool Suite (STS) umfasst einen unkomplizierten Prozess:

Klicken Sie mit der rechten Maustaste auf das Projekt im STS-Projektstrukturbaum.
Navigieren Sie zum Menü „Ausführen als“. und
Wählen Sie „Spring Boot App“.

Diese Aktion löst den Start des Projekts auf dem lokalen Host, Port 8080, aus.

Den Webhook öffentlich zugänglich machen

Da der von uns eingerichtete Webhook lokal auf unserem System auf localhost, Port 8080, liegt, müssen wir ihm öffentlichen Zugriff gewähren. Geben Sie ein Ngrok, ein Tool, das sichere Tunnel erstellt und Fernzugriff gewährt, ohne dass Netzwerkeinstellungen oder Router-Ports geändert werden müssen. Ngrok wird auf Port 8080 ausgeführt, um unseren Webhook öffentlich erreichbar zu machen.

Ngrok stellt praktischerweise eine öffentliche Weiterleitungs-URL zur Verfügung, die wir später mit Crawlbase nutzen werden Crawler.

Erstellen der Crawlbase Crawler

Erinnern Sie sich an unsere frühere Diskussion über Crawlbase Crawler Erstellung über die Crawlbase-Dashboard. Ausgestattet mit einem öffentlich zugänglichen Webhook über Ngrok wird die Erstellung des Crawlers zum Kinderspiel.

Im dargestellten Fall arbeitet die ngrok-Weiterleitungs-URL mit der Webhook-Adresse „/webhook/crawlbase“ als Rückruf zusammen. Diese Fusion ergibt eine vollständig öffentliche Webhook-Adresse. Wir taufen unseren Crawler als „Test-Crawler“, ein Name, der in die Datei application.properties des Projekts aufgenommen wird. Die Auswahl von TCP Crawler stimmt mit unserer Wahl überein. Wenn Sie auf „Erstellen“ klicken, Crawler“ nimmt der Crawler Gestalt an und wird gemäß den angegebenen Parametern konfiguriert.

Deep Crawling durch Pushen von URLs einleiten

Nach der Erstellung des Crawlers und der Aufnahme seines Namens in die Datei application.properties sind wir bereit, mit der API „@POST /scrape/push-urls“ zu interagieren. Über diese API senden wir URLs an den Crawler und lösen damit den Deep-Crawl-Prozess aus. Lassen Sie uns dies veranschaulichen, indem wir die URL pushen http://www.3bfluidpower.com/.

Mit diesem proaktiven Ansatz setzen wir die Räder des Deep Crawlings in Bewegung und nutzen dabei die Leistung von Crawlbase Crawler um in die digitale Landschaft einzutauchen und wertvolle Erkenntnisse zu gewinnen.

Analysieren der Ausgabe in der Datenbank

Beim Starten des URL-Pushs zum Crawlerwird eine Request ID (RID) zurückgegeben – ein Konzept, das in früheren Diskussionen ausführlicher erläutert wurde –, die den Beginn des Crawling-Prozesses der Seite auf der Crawler's Ende. Dieser strategische Ansatz eliminiert die Wartezeit, die normalerweise mit dem Crawling-Prozess verbunden ist, und verbessert die Effizienz und Effektivität der Datenerfassung. Sobald die Crawler Das Crawlen wird abgeschlossen und die Ausgabe wird nahtlos an unseren Webhook übermittelt.

Der Parameter „Custom Headers“, insbesondere der Parameter „type“, erweist sich für unser Vorhaben als hilfreich. Seine Präsenz ermöglicht es uns, zwischen den URLs zu unterscheiden, die wir gepusht haben, und denen, die wir beim Deep Crawling entdeckt haben. Wenn der Typ als „parent“ gekennzeichnet ist, stammt die URL aus unserer Übermittlung, was uns dazu veranlasst, neue URLs aus dem gecrawlten HTML zu extrahieren und sie anschließend wieder in die Crawler– diesmal als „Kind“ kategorisiert. Diese Strategie stellt sicher, dass nur die von uns eingeführten URLs einem Deep Crawling unterzogen werden, was den Prozess rationalisiert.

In unserem aktuellen Szenario, unter Berücksichtigung einer einzelnen URL-Übermittlung an die Crawlerläuft der Workflow wie folgt ab: Nach Erhalt des gecrawlten HTML speichert der Webhook-Dienst es in der Tabelle crawler_response. Anschließend erfolgt das Deep Crawling dieses HTML, wodurch neu entdeckte URLs entstehen, die dann an die Crawler.

crawler_request-Tabelle:

Wie Sie oben sehen können, haben wir bei unserem Webhook-Dienst 16 neue URLs aus dem HTML der Seite gefunden, deren URL wir an die Crawler im vorherigen Abschnitt, den wir in der Datenbank mit „Typ: übergeordnetes Element“ speichern. Wir senden alle neu gefundenen URLs an den Crawler, um die angegebene URL gründlich zu crawlen. Crawler wird sie alle crawlen und die Ausgabe an unseren Webhook senden. Wir speichern das gecrawlte HTML in der Tabelle crawler_response.

crawler_response-Tabelle:

Wie Sie in der obigen Tabellenansicht sehen können, werden alle Informationen, die wir bei unserem Webhook erhalten, in der Tabelle gespeichert. Sobald Sie das HTML bei Ihrem Webhook haben, können wir alle gewünschten Informationen extrahieren. Dieser detaillierte Prozess zeigt, wie Deep Crawling funktioniert und ermöglicht es uns, wichtige Informationen aus Webinhalten zu ermitteln.

Schlussfolgerung

Während dieser Erkundung des Web Scraping mit Java und Spring Boot haben wir die kritischen Schritte der Einrichtung einer auf Web Scraping zugeschnittenen Java-Umgebung, der Auswahl der geeigneten Bibliotheken und der Ausführung sowohl einfacher als auch anspruchsvoller Web Scraping-Projekte durchlaufen. Diese Reise unterstreicht die Vielseitigkeit und Robustheit von Java beim Extrahieren von Daten aus dem Web und hebt Tools wie JSoup, Selenium und HtmlUnit aufgrund ihrer einzigartigen Stärken bei der Verarbeitung sowohl statischer als auch dynamischer Webinhalte hervor. Indem dieser Artikel den Lesern das Wissen vermittelt, um ihre Web Scraping-Bemühungen an projektspezifische Anforderungen anzupassen, dient er als umfassender Leitfaden zu den Komplexitäten und Möglichkeiten des Web Scraping mit Java.

Abschließend lässt sich sagen, dass die Beherrschung von Web Scraping in Java eine Fülle von Möglichkeiten zur Datenextraktion, -analyse und -anwendung eröffnet. Ob das Ziel darin besteht, Markttrends zu überwachen, Inhalte zu aggregieren oder aufschlussreiche Daten aus dem gesamten Web zu sammeln, die hier bereitgestellten Techniken und Erkenntnisse bilden eine solide Grundlage für Anfänger und erfahrene Entwickler gleichermaßen. Während Herausforderungen wie der Umgang mit dynamischen Inhalten und das Umgehen von Sicherheitsmaßnahmen weiterhin bestehen, verspricht die Weiterentwicklung der Java-Web-Scraping-Tools kontinuierliche Fortschritte. Daher ist es wichtig, auf dem Laufenden zu bleiben und sich anzupassen, um das volle Potenzial der Web-Scraping-Technologien in der sich ständig weiterentwickelnden Landschaft des Internets auszuschöpfen.

Vielen Dank, dass Sie uns auf dieser Reise begleiten. Den vollständigen Quellcode des Projekts finden Sie auf GitHub HIER. Mögen Ihre Bemühungen im Bereich Webdaten ebenso transformativ sein wie die Tools und Kenntnisse, die Sie hier erworben haben. Während sich die digitale Landschaft weiter entwickelt, denken Sie daran, dass die Macht zur Innovation in Ihren Händen liegt.

Weitere Tutorials wie diese finden Sie in unserem Blog, hier sind einige Java-Tutorials, die Sie interessieren könnten

Crawling von E-Commerce-Websites

Web Scraping Expedia

Web Scraping Booking.com

So scrapen Sie G2-Produktbewertungen

Dramatiker-Web-Scraping

Yahoo Finanzen scrapen

Häufig gestellte Fragen

F: Muss ich JAVA verwenden, um die Crawler?

Nein, Sie müssen nicht ausschließlich JAVA verwenden, um die Crawlbase zu nutzen Crawlerdem „Vermischten Geschmack“. Seine Crawler bietet mehrere Bibliotheken für verschiedene Programmiersprachen, sodass Benutzer mit ihnen in ihrer bevorzugten Sprache interagieren können. Egal, ob Sie mit Python, JavaScript, Java, Ruby oder anderen Programmiersprachen vertraut sind, Crawlbase bietet alles für Sie. Darüber hinaus bietet Crawlbase APIs, mit denen Benutzer auf die Crawlers-Funktionen, ohne auf bestimmte Bibliotheken angewiesen zu sein, und ist damit für eine breite Palette von Entwicklern mit unterschiedlichen Sprachpräferenzen und technischen Hintergründen zugänglich. Diese Flexibilität stellt sicher, dass Sie die Crawler in Ihre Projekte und Arbeitsabläufe integrieren und dabei die Sprache verwenden, die Ihren Anforderungen am besten entspricht.

F: Können Sie Java für Web Scraping verwenden?

Ja, Java ist eine äußerst leistungsfähige Programmiersprache, die für eine Vielzahl von Anwendungen verwendet wird, darunter auch Web Scraping. Sie hat sich im Laufe der Jahre erheblich weiterentwickelt und unterstützt verschiedene Tools und Bibliotheken speziell für Scraping-Aufgaben.

F: Welche Java-Bibliothek ist für Web Scraping am effektivsten?

Für Web Scraping in Java sind JSoup, HtmlUnit und Selenium WebDriver die am meisten empfohlenen Bibliotheken. JSoup ist besonders nützlich zum Extrahieren von Daten aus statischen HTML-Seiten. Für dynamische Websites, die JavaScript verwenden, sind HtmlUnit und Selenium WebDriver besser geeignet.

F: Was ist besser für Web Scraping geeignet: Java oder Python?

Python wird beim Web Scraping im Allgemeinen Java vorgezogen. Diese Präferenz ist auf die Einfachheit von Python und sein reichhaltiges Ökosystem an Bibliotheken wie BeautifulSoup zurückzuführen, das das Parsen und Navigieren in HTML- und XML-Dokumenten vereinfacht.

F: Welche Programmiersprache gilt als die beste für Web Scraping?

Python gilt als die beste Programmiersprache für Web Scraping-Aufgaben. Es bietet eine umfassende Suite an Bibliotheken und Tools wie BeautifulSoup und Scrapy, die für effizientes und effektives Web Scraping konzipiert sind.