Dans ce tutoriel Java sur le Web scraping, nous aborderons l'exploration en profondeur : une forme avancée de Web scraping. Ce guide complet sur le Web scraping en Java utilisera l'exploration en profondeur avec Java Spring Boot pour explorer le Web.

Grâce à une exploration en profondeur, même les sections les plus isolées d’un site Web deviennent accessibles, révélant des données qui pourraient autrement passer inaperçues.

Ce qui est encore plus remarquable, c'est que nous ne parlons pas seulement de théorie : nous vous montrons comment le faire. Démarrage de Spring Java et la Crawlbase bibliothèque Java, nous vous apprendrons à faire de l'exploration en profondeur une réalité. Nous vous aiderons à configurer vos outils, vous expliquerons la différence entre l'exploration superficielle et l'exploration en profondeur (ce n'est pas aussi compliqué qu'il y paraît !) et vous montrerons comment extraire des informations de différentes pages Web et les stocker de votre côté.

Pour comprendre la partie codage du scraping Web Java, vous devez avoir une compréhension de base de Java Spring Boot et de la base de données MySQL. Commençons par la création d'un scraper Web en Java.

Sommaire :

  1. Comprendre l'exploration en profondeur : la passerelle vers les données Web
  2. Pourquoi avez-vous besoin de créer un scraper Web Java
  3. Comment faire du Web Scraping en Java
  4. Préparer le terrain : préparer votre environnement
  5. Simplifiez la configuration du projet Spring Boot avec Spring Initializr
  6. Importer le projet de démarrage dans Spring Tool Suite
  7. Comprendre le plan directeur de votre projet : un aperçu de la structure du projet
  8. Commencer le parcours de codage
  9. Exécution du projet et lancement d'une exploration approfondie
  10. Analyse des résultats dans la base de données
  11. Conclusion
  12. Foire aux questions (FAQ)

Profond Crawling en Java.

L'exploration en profondeur, également connue sous le nom de Web scraping, consiste à fouiller en profondeur sur Internet pour trouver de nombreuses informations précieuses. Dans cette partie, nous allons parler de ce qu'est l'exploration en profondeur, en quoi elle diffère du simple survol de la surface des sites Web et pourquoi elle est importante pour obtenir des données.

Fondamentalement, l'exploration en profondeur est une manière intelligente de parcourir les sites Web et de récupérer des informations spécifiques à partir de différentes parties de ces sites. Contrairement à l'exploration superficielle, qui ne regarde que les éléments superficiels, l'exploration en profondeur fouille dans les couches des sites Web pour trouver des trésors de données cachés. Cela nous permet de collecter toutes sortes d'informations, comme les prix des produits, les avis des utilisateurs, les statistiques financières et les articles de presse avec le scraping Web à l'aide de Java.

L'exploration en profondeur nous aide à mettre la main sur un ensemble de données structurées et non structurées que nous ne verrions pas autrement. En explorant soigneusement Internet, nous pouvons recueillir des données qui peuvent aider à la prise de décisions commerciales, soutenir la recherche et susciter de nouvelles idées grâce au scraping Web Java.

Différencier le crawling superficiel et profond

L'exploration superficielle est comme un rapide coup d'œil à la surface d'un étang, en ne voyant que ce qui est visible. Elle ne regarde généralement qu'une petite partie d'un site Web, comme la page principale ou quelques pages importantes. Mais elle passe à côté de beaucoup d'éléments cachés.

D'un autre côté, l'exploration en profondeur est comme une plongée dans les profondeurs de l'océan, explorant chaque recoin. Elle vérifie l'intégralité du site Web, clique sur les liens et trouve des trésors cachés dans différentes sections. L'exploration en profondeur est extrêmement utile pour les entreprises, les chercheurs et les développeurs, car elle permet de récupérer une tonne de données précieuses qui sont autrement difficiles à trouver.

Ramper en profondeur ou en surface

Exploration de la portée et de l'importance du crawling profond

La portée de l'exploration approfondie va bien au-delà de l'extraction de données ; c'est une passerelle vers la compréhension de la dynamique du Web et la découverte d'informations qui orientent la prise de décision. Des plateformes de commerce électronique qui souhaitent surveiller les prix des produits sur les sites concurrents aux organismes de presse qui souhaitent analyser le sentiment à travers des articles, les applications de l'exploration approfondie sont aussi diverses que les données qu'elle révèle.

Dans le domaine de la recherche, l'exploration approfondie est une sorte de base pour analyser les données afin de comprendre les nouvelles tendances, la façon dont les gens utilisent Internet et le contenu qu'ils aiment. Elle est également importante pour respecter les lois et les règles, car les entreprises doivent réfléchir à la bonne façon de collecter les données et de suivre les règles des sites Web sur lesquels elles les obtiennent.

Dans ce tutoriel, nous allons approfondir le scraping Web Java.

Pourquoi avez-vous besoin de créer un scraper Web Java

Vous avez besoin d'un web scraper Java pour collecter et exploiter les informations d'un site web. Voici un exemple : Crawlbase Crawler, mais qu'est-ce que c'est exactement Crawlbase Crawler, et comment opère sa magie ?

Quel est Crawlbase Crawler?

Crawlbase Crawler est un outil dynamique d'extraction de données web qui propose une approche moderne et intelligente pour collecter des informations précieuses sur les sites web. Contrairement aux méthodes de scraping traditionnelles qui impliquent des interrogations constantes, Crawlbase Crawler fonctionne de manière asynchrone. Cela signifie qu'il peut traiter de manière indépendante les demandes d'extraction de données et les livrer en temps réel sans nécessiter de surveillance manuelle.

Le flux de travail : comment Crawlbase Crawler Fonctionne

Crawlbase Crawler fonctionne selon un flux de travail fluide et efficace qui peut être résumé en quelques étapes clés :

  1. Soumission d'URL : En tant qu'utilisateur, vous lancez le processus en soumettant des URL à l' Crawlbase Crawler en utilisant la fonction Crawling API.
  2. Traitement des demandes : Crawler reçoit ces requêtes et les traite de manière asynchrone. Cela signifie qu'il peut gérer plusieurs requêtes simultanément sans aucune intervention manuelle.
  3. Extraction de données: Crawler visite les URL spécifiées, extrait les données demandées et les conditionne pour la livraison.
  4. Intégration Webhook : Crawlbase Crawler s'intègre au webhook au lieu de nécessiter une interrogation manuelle. Ce webhook sert de messager qui délivre les données extraites directement au point de terminaison de votre serveur en temps réel.
  5. Livraison en temps réel : Les données extraites sont livrées au point de terminaison webhook de votre serveur dès qu'elles sont disponibles, permettant un accès immédiat sans délai.
  6. Nouvelles perspectives : En recevant des données en temps réel, vous obtenez un avantage concurrentiel en prenant des décisions éclairées basées sur le contenu Web le plus récent.

Les avantages : pourquoi choisir Crawlbase Crawler

Bien qu'un crawler permette un scraping Web instantané avec Java, il présente également d'autres avantages :

  1. Rendement : Le traitement asynchrone élimine le besoin de surveillance continue, libérant ainsi vos ressources pour d’autres tâches.
  2. Informations en temps réel : Recevez les données dès qu'elles sont disponibles, ce qui vous permet de rester au courant des tendances et des changements.
  3. Flux de travail rationalisé : L'intégration Webhook remplace l'interrogation manuelle, simplifiant ainsi le processus de livraison des données.
  4. Prise de décision en temps opportun : L'accès instantané aux données fraîchement extraites permet une prise de décision rapide et basée sur les données.

Accéder Robot d'exploration Web Java, vous devez le créer dans votre Crawlbase tableau de bord de compte. Vous pouvez opter pour le TCP ou le JavaScript Crawler en fonction de vos besoins spécifiques. Le TCP Crawler est idéal pour les pages statiques, tandis que le JavaScript Crawler convient au contenu généré via JavaScript, comme dans les pages créées avec JavaScript ou le contenu de navigateur rendu dynamiquement. Lisez ici pour en savoir plus sur Crawlbase Crawler.

Lors de la création, il vous sera demandé de fournir l'adresse de votre webhook. Nous le créerons donc après avoir réussi à créer un webhook dans notre projet Spring Boot. Dans la section suivante, nous approfondirons le codage et développerons le composant requis pour terminer notre projet.

Comment faire du Web Scraping en Java

Suivez les étapes ci-dessous pour apprendre le scraping Web en Java.

Préparer le terrain : préparer votre environnement

Avant de nous lancer dans l'exploration approfondie, il est important de préparer le terrain pour réussir. Cette section vous guide à travers les étapes essentielles pour garantir que votre environnement de développement est prêt à relever les défis passionnants à venir.

Installation de Java sur Ubuntu et Windows

Java est l'épine dorsale de notre processus de développement et nous devons nous assurer qu'il est disponible sur notre système. Si Java n'est pas installé sur votre système, vous pouvez suivre les étapes ci-dessous en fonction de votre système d'exploitation.

Installation de Java sur Ubuntu :

  1. Ouvrez le Terminal en appuyant sur Ctrl + Alt + T.
  2. Exécutez la commande suivante pour mettre à jour la liste des packages :
1
sudo mise à jour apt
  1. Installez le kit de développement Java (JDK) en exécutant :
1
sudo apt installe le jdk par défaut
  1. Vérifiez l’installation du JDK en tapant :
1
java -version

Installation de Java sous Windows :

  1. Visitez le site officiel Oracle site Web et téléchargez le dernier kit de développement Java (JDK).
  2. Suivez les instructions de l'assistant d'installation pour terminer l'installation. Une fois l'installation terminée, vous pouvez la vérifier en ouvrant l'invite de commande et en saisissant :
1
java -version

Installation de Spring Tool Suite (STS) sur Ubuntu et Windows :

Spring Tool Suite (STS) est un environnement de développement intégré (IDE) spécialement conçu pour développer des applications à l'aide de Spring Framework, un framework Java populaire pour la création d'applications de niveau entreprise. STS fournit des outils, des fonctionnalités et des plugins qui améliorent l'expérience de développement lorsque vous travaillez avec des projets basés sur Spring ; suivez les étapes ci-dessous pour les installer.

  1. Visitez le site Web officiel de Spring Tool Suite à l'adresse spring.io/outils.
  2. Téléchargez la version appropriée de Spring Tool Suite pour votre système d'exploitation (Ubuntu ou Windows).

Sur Ubuntu :

  1. Après le téléchargement, accédez au répertoire où se trouve le fichier téléchargé dans le Terminal.
  2. Extraire l'archive téléchargée:
1
2
# Remplacer et selon le nom de l'archive
tar-xvf spring-tool-suite- - .tar.gz
  1. Déplacez le répertoire extrait vers un emplacement de votre choix :
1
2
# Remplacer selon le nom du dossier extrait
mv sts- /votre_chemin_de_désir/

Sur Windows:

  1. Exécutez le programme d'installation téléchargé et suivez les instructions à l'écran pour terminer l'installation.

Installation de MySQL sur Ubuntu et Windows

La mise en place d'un système de gestion de base de données fiable est primordiale pour démarrer votre parcours vers l'exploration approfondie et l'extraction de données Web. MySQL, une base de données relationnelle open source populaire, fournit la base pour stocker et gérer en toute sécurité les données que vous collecterez grâce à vos efforts d'exploration. Voici un guide étape par étape sur la façon d'installer MySQL sur les plates-formes Ubuntu et Windows :

Installation de MySQL sur Ubuntu :

  1. Ouvrez un terminal et exécutez les commandes suivantes pour vous assurer que votre système est à jour :
1
2
sudo mise à jour apt
sudo mise à niveau apt
  1. Exécutez la commande suivante pour installer le package du serveur MySQL :
1
sudo apt installer mysql-server
  1. Après l'installation, démarrez le service MySQL :
1
sudo systemctl démarre mysql.service
  1. Vérifiez si MySQL est en cours d'exécution avec la commande :
1
sudo état systemctl mysql

Installation de MySQL sous Windows :

  1. Visitez le site officiel Site Web MySQL et téléchargez le programme d'installation MySQL pour Windows.
  2. Exécutez le programme d'installation téléchargé et choisissez le type d'installation « Developer Default ». Cela installera MySQL Server et d'autres outils associés.
  3. Lors de l'installation, il vous sera demandé de configurer le serveur MySQL. Définissez un mot de passe root fort et mémorisez-le.
  4. Suivez les instructions du programme d’installation pour terminer l’installation.
  5. Après l'installation, MySQL devrait démarrer automatiquement. Vous pouvez également le démarrer manuellement à partir de l'application « Services » de Windows.

Vérification de l'installation de MySQL :

Quelle que soit votre plateforme, vous pouvez vérifier l'installation de MySQL en ouvrant un terminal ou une invite de commande et en entrant la commande suivante :

1
mysql -u root -p

Vous serez invité à saisir le mot de passe root MySQL que vous avez défini lors de l'installation. Si la connexion est établie, l'interface de ligne de commande MySQL s'affichera.

Maintenant que vous avez Java et STS prêts, vous êtes prêt pour la phase suivante de votre aventure d'exploration en profondeur. Dans l'étape suivante, nous vous guiderons dans la création d'un projet de démarrage Spring Boot, préparant le terrain pour vos efforts d'exploration en profondeur. Plongeons dans cette phase passionnante du voyage !

Simplifiez la configuration du projet Spring Boot avec Spring Initializr

Imaginez que la configuration d'un projet Spring Boot soit comme naviguer dans un labyrinthe complexe de paramètres. Mais ne vous inquiétez pas, Initialisation du ressort est là pour vous aider ! C'est comme avoir un assistant intelligent en ligne qui rend le processus beaucoup plus facile. Vous pourriez le faire manuellement, mais c'est comme un puzzle qui prend beaucoup de temps. Spring Initializr vient à la rescousse en rendant les choses plus fluides dès le début. Suivez les étapes suivantes pour créer un projet Spring Boot avec Spring Initializr.

  1. Accéder au site Web Spring Initializr

Ouvrez votre navigateur Web et accédez au site Web Spring Initializr. Vous pouvez le trouver à l'adresse start.spring.io.

  1. Choisissez les détails de votre projet

C'est ici que vous faites des choix importants pour votre projet. Vous devez choisir le type de projet et la langue que vous allez utiliser. Nous devons choisir Maven en tant que type de projet et JAVA comme langue. Pour la version Spring Boot, optez pour une version stable (comme la 3.1.2). Ensuite, ajoutez des détails sur votre projet, comme son nom et son sujet. C'est facile : il suffit de suivre l'exemple de l'image.

  1. Ajoutez des trucs sympas

Il est temps d'ajouter des fonctionnalités spéciales à votre projet ! C'est comme lui donner des super pouvoirs. Incluez Spring Web (important pour les projets Spring Boot), Spring Data JPA et le pilote MySQL si vous envisagez d'utiliser une base de données. N'oubliez pas Lombok, c'est comme un outil magique qui fait gagner du temps. Nous en parlerons plus en détail dans les prochaines parties du blog.

  1. Obtenez votre projet

Après avoir sélectionné tous les éléments utiles, cliquez sur « GÉNÉRER ». Votre projet de démarrage sera téléchargé sous forme de fichier zip. Une fois terminé, ouvrez le fichier zip pour voir le début de votre projet.

Paramètres d'initialisation de Spring

En suivant ces étapes, vous vous assurez que votre aventure d'exploration en profondeur démarre sans problème. Spring Initializr est comme un guide fiable qui vous aide à configurer. Dans la section suivante, nous vous guiderons dans l'importation de votre projet dans la suite d'outils Spring que vous avez installée. Préparez-vous à démarrer cette phase passionnante de votre voyage d'exploration en profondeur !

Importer le projet de démarrage dans Spring Tool Suite

Très bien, maintenant que votre projet de démarrage Spring Boot est entièrement configuré et prêt à être lancé, l'étape suivante consiste à l'importer dans Spring Tool Suite (STS). C'est comme inviter votre projet dans un espace de travail confortable où vous pouvez exercer votre magie. Voici comment procéder :

  1. Suite d'outils Open Spring (STS)

Tout d'abord, lancez votre Spring Tool Suite. C'est votre centre créatif où tout le codage et la création auront lieu.

  1. Importer le projet

Accédez au menu « Fichier » et choisissez « Importer ». Une fenêtre apparaît avec différentes options : sélectionnez « Projets Maven existants » et cliquez sur « Suivant ».

  1. Choisissez le répertoire du projet

Cliquez sur le bouton « Parcourir » et recherchez le répertoire dans lequel vous avez décompressé votre projet Starter. Sélectionnez le répertoire racine du projet et cliquez sur « Terminer ».

  1. Regardez la magie

Spring Tool Suite fera son travail par magie et importera votre projet. Il apparaît dans l'« Explorateur de projets » sur le côté gauche de votre espace de travail.

  1. C’est parti

Et voilà ! Votre projet Starter est désormais confortablement installé dans Spring Tool Suite. Vous êtes prêt à commencer à créer, coder et explorer.

Importer dans STS

Intégrer votre projet dans Spring Tool Suite, c'est ouvrir la porte à des possibilités infinies. Vous disposez désormais des outils et de l'espace nécessaires pour rendre votre projet exceptionnel. La section suivante se penchera sur la structure du projet, en décortiquant les couches pour révéler ses composants et son fonctionnement interne. Préparez-vous à vous lancer dans un voyage de découverte pendant que nous dévoilons ce qui se cache à l'intérieur !

Comprendre le plan directeur de votre projet : un aperçu de la structure du projet

Maintenant que votre projet de démarrage Spring Boot est confortablement installé dans Spring Tool Suite (STS), examinons son fonctionnement interne. C'est comme apprendre à connaître l'agencement de votre nouvelle maison avant de commencer à la décorer.

Maven et pom.xml

Au cœur de votre projet se trouve un outil puissant appelé Maven. Considérez Maven comme l'organisateur de votre projet : il gère les bibliothèques, les dépendances et les builds. Le fichier nommé pom.xml est l'endroit où toute la magie liée au projet se produit. C'est comme le plan directeur qui indique à Maven ce qu'il doit faire et ce dont votre projet a besoin. Comme dans notre cas, actuellement, nous aurons cela dans le projet pom.xml.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<?version XML="1.0" encodage="UTF-8"?>
<Projet xmlns="http://maven.apache.org/POM/4.0.0" xmlns : xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:emplacement du schéma="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modèleVersion>4.0.0</modèleVersion>
   <mère>
      <ID de groupe>org.springframework.boot</ID de groupe>
      <ID de l'artefact>ressort-démarrage-démarreur-parent</ID de l'artefact>
      <version>3.1.2</version>
      <chemin relatif/> 
   </mère>
   <ID de groupe>com.exemple</ID de groupe>
   <ID de l'artefact>base d'exploration</ID de l'artefact>
   <version>0.0.1-INSTANTANÉ</version>
   <Le nom>Crawlbase Crawler Avec démarrage à ressort</Le nom>
   <la description>Démonstration d'utilisation Crawlbase Crawler avec Spring Boot et comment faire du Deep Crawling</la description>
   <propriétés>
      <version.java>17</version.java>
   </propriétés>
   <dépendances>
      <dépendance>
         <ID de groupe>org.springframework.boot</ID de groupe>
         <ID de l'artefact>données de démarrage spring-boot-jpa</ID de l'artefact>
      </dépendance>
      <dépendance>
         <ID de groupe>org.springframework.boot</ID de groupe>
         <ID de l'artefact>ressort-boot-starter-web</ID de l'artefact>
      </dépendance>
      <dépendance>
         <ID de groupe>com.mysql</ID de groupe>
         <ID de l'artefact>connecteur-mysql-j</ID de l'artefact>
         <portée>d'exécution</portée>
      </dépendance>
      <dépendance>
         <ID de groupe>org.projectlombok</ID de groupe>
         <ID de l'artefact>Lombok</ID de l'artefact>
         <facultatif>oui</facultatif>
      </dépendance>
      <dépendance>
         <ID de groupe>org.springframework.boot</ID de groupe>
         <ID de l'artefact>test de démarrage à ressort</ID de l'artefact>
         <portée>tester</portée>
      </dépendance>
   </dépendances>

   <construire>
      <plugins>
         <plug-in>
            <ID de groupe>org.springframework.boot</ID de groupe>
            <ID de l'artefact>Spring-boot-maven-plugin</ID de l'artefact>
            <paramétrage>
               <exclut>
                  <exclure>
                     <ID de groupe>org.projectlombok</ID de groupe>
                     <ID de l'artefact>Lombok</ID de l'artefact>
                  </exclure>
               </exclut>
            </paramétrage>
         </plug-in>
        </plugins>
   </construire>
</Projet>

Bibliothèques Java

Vous vous souvenez de ces fonctionnalités spéciales que vous avez ajoutées lors de la création du projet ? Elles sont appelées dépendances, comme des outils magiques qui rendent votre projet plus puissant. Vous ajoutiez en fait ces bibliothèques lorsque vous avez inclus Spring Web, Spring Data JPA, MySQL Driver et Lombok à partir de Spring Initializr. Vous pouvez les voir dans le fichier pom.xml ci-dessus. Elles apportent des fonctionnalités prédéfinies à votre projet, vous permettant ainsi de gagner du temps et des efforts.

  • Web de printemps : Cette bibliothèque est votre ticket pour créer des applications Web Spring Boot. Elle vous aide à gérer des tâches telles que la gestion des requêtes et la création de contrôleurs Web.
  • Données de printemps JPA : Cette bibliothèque est votre alliée si vous travaillez avec des bases de données. Elle simplifie les interactions et la gestion des bases de données, vous permettant de vous concentrer sur la logique de votre projet.
  • Pilote MySQL : Lorsque vous utilisez MySQL comme base de données, ce pilote aide votre projet à communiquer efficacement avec la base de données.
  • Lombok : Dites adieu au code répétitif ! Lombok réduit le code standard que vous devez habituellement écrire, rendant votre projet plus propre et plus concis.

Comprendre la structure du projet

En explorant les dossiers de votre projet, vous remarquerez que tout est bien organisé. Votre code Java se trouve dans le répertoire src/main/java, tandis que les ressources telles que les fichiers de configuration et les ressources statiques résident dans le répertoire src/main/resources. Vous y trouverez également le fichier application.properties, qui est comme le centre de contrôle de votre projet, où vous pouvez configurer les paramètres.

Structure du projet

Dans l' src/main/java Dans ce répertoire, nous trouverons un package contenant une classe Java avec la fonction principale. Ce fichier sert de point de départ lors de l'exécution du projet Spring Boot. Dans notre cas, nous aurons CrawlbaseApplication.java fichier avec le code suivant.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
paquet com.exemple.crawlbase;

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

@Application SpringBoot
// Ajoutez ceci pour activer l'asynchrone dans le projet
@EnableAsync
public classe CrawlbaseCandidature {

    public statique annuler principal(Chaîne[] arguments) {
        SpringApplication.run(CrawlbaseApplication.class, args);
    }

}

Maintenant que vous maîtrisez les bases, vous pouvez aborder votre projet en toute confiance. Avant de commencer le codage, nous allons nous plonger dans Crawlbase et essayons de comprendre son fonctionnement et comment l'utiliser dans notre projet. Alors, préparez-vous à découvrir la véritable puissance du crawler.

Démarrer le parcours de codage vers le scraping Java

Maintenant que vous avez configuré le framework de scraping Web Java, la bibliothèque de scraping Web Java et le scraper Web Java, il est temps de plonger dans le codage du didacticiel de scraping Web Java. Cette section décrit les étapes essentielles pour créer des contrôleurs, des services, des référentiels et mettre à jour des fichiers de propriétés. Avant d'entrer dans le vif du sujet du codage, nous devons jeter les bases et introduire les dépendances clés qui renforceront notre projet.

Puisque nous utilisons le Crawlbase Crawler, il est important de s'assurer que nous pouvons facilement l'utiliser dans notre projet Java. Heureusement, Crawlbase fournit une bibliothèque Java qui simplifie ce processus d'intégration. Pour l'ajouter à notre projet, il suffit d'inclure la dépendance Maven appropriée dans le fichier pom.xml du projet.

1
2
3
4
5
<dépendance>
    <ID de groupe>com.crawlbase</ID de groupe>
    <ID de l'artefact>crawlbase-java-sdk-pom</ID de l'artefact>
    <version>1.0</version>
</dépendance>

Après avoir ajouté cette dépendance, une installation rapide de Maven garantira que le Crawlbase La bibliothèque Java est téléchargée à partir du référentiel Maven et prête à l'emploi.

Intégration de la dépendance JSoup

Étant donné que nous allons plonger profondément dans le contenu HTML, il est essentiel de disposer d'un analyseur HTML puissant. C'est là qu'intervient JSoup, un analyseur HTML robuste et polyvalent pour Java. Il propose des méthodes pratiques pour naviguer et manipuler les structures HTML. Pour exploiter ses capacités, nous devons inclure la bibliothèque JSoup dans notre projet via une autre dépendance Maven :

1
2
3
4
5
<dépendance>
    <ID de groupe>org.jsoup</ID de groupe>
    <ID de l'artefact>jsoupe</ID de l'artefact>
    <version>1.16.1</version>
</dépendance>

Configuration de la base de données

Avant de poursuivre, posons les bases de notre projet en créant une base de données. Suivez ces étapes pour créer une base de données MySQL :

  1. Ouvrez la console MySQL : Si vous utilisez Ubuntu, lancez une fenêtre de terminal. Sous Windows, ouvrez le client de ligne de commande MySQL ou MySQL Shell.
  2. Connectez-vous à MySQL : Entrez la commande suivante et saisissez votre mot de passe root MySQL lorsque vous y êtes invité :
1
mysql -u root -p
  1. Créer une nouvelle base de données : Une fois connecté, créez une nouvelle base de données avec le nom souhaité :
1
2
# Remplacez database_name par le nom que vous avez choisi
CREATE DATABASE nom_base de données ;

Planification des modèles

Avant de plonger tête baissée dans la planification du modèle, comprenons ce que le robot renvoie lorsque des URL lui sont envoyées et quelle réponse nous recevons sur notre webhook. Lorsque nous envoyons des URL au robot, il répond avec un ID de requête, comme ceci :

1
{ "débarrasser": "1e92e8bff32c31c2728714d4" }

Une fois que le robot a effectivement exploré le contenu HTML, il transmet la sortie à notre webhook. La réponse ressemblera à ceci :

1
2
3
4
5
6
7
8
9
10
11
12
En-têtes:
  "Type de contenu" => "texte/plain"
  « Encodage de contenu » => "gzip"
  « Statut d'origine » => 200
  « Statut PC » => 200
  "débarrasser" => "Le RID que vous avez reçu lors de l'appel push"
  "url" => "L'URL qui a été explorée"

Les chuchotements :
  Le HTML de la page

// Le corps sera encodé au format gzip

Ainsi, en tenant compte de cela, nous pouvons considérer la structure de base de données suivante.

Schéma de base de données

Nous n'avons pas besoin de créer directement les tables de base de données car nous allons créer notre projet Spring Boot pour initialiser automatiquement les tables lorsque nous l'exécutons. Nous allons créer hiberner de faire ça pour nous.

Conception des fichiers modèles

Avec les bases posées dans la section précédente, plongeons-nous dans la création de nos fichiers modèles. com.example.crawlbase.models package, nous allons fabriquer deux modèles essentiels : CrawlerRequest.java et CrawlerResponse.javaCes modèles encapsulent la structure de nos tables de base de données et, pour garantir l'efficacité, nous utiliserons Lombok pour réduire le code standard.

CrawlerModèle de demande :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
paquet com.exemple.crawlbase.models;

importer jakarta.persistence.CascadeType;
importer jakarta.persistence.Entité;
importer jakarta.persistence.FetchType;
importer jakarta.persistence.GeneratedValue;
importer jakarta.persistence.Id;
importer jakarta.persistence.OneToOne;
importer lombok.AllArgsConstructor;
importer lombok.Constructeur;
importer lombok.Données;
importer lombok.NoArgsConstructor;

@Entité
@Données
@NoArgsConstructor
@AllArgsConstructor
@Builder(toBuilder = vrai)
public classe CrawlerDemander {

    @Identifiant
    @ValeurGénérée
    Privé Identifiant long;

    Privé Chaîne d'URL ;
    Privé Type de chaîne ;
    Privé Statut entier ;
    Privé Débarrasser la corde;

    @OneToOne(mappedBy = "crawlerRequest", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    Privé CrawlerRobot de réponseResponse;

}

CrawlerModèle de réponse :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
paquet com.exemple.crawlbase.models;

importer jakarta.persistence.Column;
importer jakarta.persistence.Entité;
importer jakarta.persistence.GeneratedValue;
importer jakarta.persistence.Id;
importer jakarta.persistence.JoinColumn;
importer jakarta.persistence.OneToOne;
importer lombok.AllArgsConstructor;
importer lombok.Constructeur;
importer lombok.Données;
importer lombok.NoArgsConstructor;

@Entité
@Données
@NoArgsConstructor
@AllArgsConstructor
@Builder(toBuilder = vrai)
public classe CrawlerRéponse {

    @Identifiant
    @ValeurGénérée
    Privé Identifiant long;

    Privé Entier pcStatus;
    Privé Entier originalStatus;

    @Column(columnDefinition = "TEXTE LONG")
    Privé Chaîne pageHtml;

    @OneToOne
    @JoinColumn(nom = "request_id")
    Privé CrawlerDemande crawlerRequest;

}

Création de référentiels pour les deux modèles

Après la création de nos modèles, l'étape suivante consiste à établir des référentiels pour une interaction transparente entre notre projet et la base de données. Ces interfaces de référentiel servent de connecteurs essentiels, exploitant l'interface JpaRepository pour fournir des fonctions fondamentales pour l'accès aux données. Hibernate, un puissant outil ORM, gère le mappage sous-jacent entre les objets Java et les tables de base de données.

Créer un package com.example.crawlbase.repositories et à l'intérieur de celui-ci, créez deux interfaces de référentiel, CrawlerRequestRepository.java et CrawlerResponseRepository.java.

CrawlerInterface de demande de dépôt :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
paquet com.exemple.crawlbase.repositories;

importer java.util.List;
importer JpaRepository est un référentiel de données qui permet de stocker des données sur des bases de données.
importer org.springframework.data.jpa.repository.Requête;
importer Par exemple, si vous utilisez un référentiel de données, vous pouvez créer un référentiel de données.

importer com.exemple.crawlbase.models.CrawlerDemande;

public interface CrawlerDemande de dépôt S'étend Référentiel Jpa<CrawlerRequête, longue> {

    // Rechercher par nom et valeur de colonne
    ListeCrawlerDemande> trouverByRid(Valeur de chaîne);
}

CrawlerInterface ResponseRepository :

1
2
3
4
5
6
7
8
paquet com.exemple.crawlbase.repositories;

importer JpaRepository est un référentiel de données qui permet de stocker des données sur des bases de données.
importer com.exemple.crawlbase.models.CrawlerRéponse;

public interface CrawlerRéponseRepository S'étend Référentiel Jpa<CrawlerRéponse, Long> {

}

API de planification et classes de mappage du corps de la requête

Exploiter le Crawlbase Crawler implique la conception de deux API cruciales : l'une pour envoyer des URL au robot d'exploration et l'autre pour servir de webhook. Pour commencer, planifions les structures du corps de la requête pour ces API.

Corps de la requête d'URL push :

1
2
3
4
5
6
{
    « URL »: [
        "http://www.3bfluidpower.com/",
        .....
    ]
}

Quant au corps de la requête de l'API webhook, il doit être aligné sur le CrawlerLa structure de réponse de , comme indiqué précédemment. Vous pouvez en savoir plus à ce sujet ici.

Conformément à cette planification, nous allons créer deux classes de mappage de requêtes dans le com.example.crawlbase.requests emballage:

CrawlerClasse WebhookRequest :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
paquet com.exemple.crawlbase.requests;

importer lombok.Constructeur;
importer lombok.Données;

@Données
@Constructeur
public classe CrawlerDemande de Webhook {

    Privé Entier pc_status;
    Privé Entier original_status;
    Privé Débarrasser la corde;
    Privé Chaîne d'URL ;
    Privé Corps de corde;

}

Classe ScrapeUrlRequest :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
paquet com.exemple.crawlbase.requests;

importer lombok.Constructeur;
importer lombok.Données;

@Données
@Constructeur
public classe CrawlerDemande de Webhook {

    Privé Entier pc_status;
    Privé Entier original_status;
    Privé Débarrasser la corde;
    Privé Chaîne d'URL ;
    Privé Corps de corde;

}

Créer un ThreadPool pour optimiser le webhook

Si nous n'optimisons pas notre webhook pour gérer un grand nombre de requêtes, cela entraînera des problèmes cachés. C'est là que nous pouvons utiliser le multithreading. En JAVA, ThreadPoolTaskExecutor est utilisé pour gérer un pool de threads de travail pour exécuter des tâches asynchrones simultanément. Ceci est particulièrement utile lorsque vous avez des tâches qui peuvent être exécutées indépendamment et en parallèle.

Créer un nouveau paquet com.example.crawlbase.config et créer ThreadPoolTaskExecutorConfig.java déposer dedans.

Classe ThreadPoolTaskExecutorConfig :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
paquet com.exemple.crawlbase.config;

importer org.springframework.context.annotation.Bean;
importer Configuration;
importer Utilisez la commande suivante pour exécuter une tâche :

@Configuration
public classe Configuration de ThreadPoolTaskExecutor {

    @Bean(nom = "taskExecutor")
    public Exécuteur de tâches ThreadPool exécuteur de tâches() {
        int couleurs = Exécution.getRuntime().availableProcessors();
        Exécuteur de tâches ThreadPool exécuteur = nouvelle Exécuteur de tâches ThreadPool();
        exécuteur.setCorePoolSize(cœurs);
        exécuteur.setMaxPoolSize(cœurs);
        exécuteur.setQueueCapacity(Integer.MAX_VALUE);
        exécuteur.setThreadNamePrefix("Async-");
        exécuteur.initialize();
        retourner exécuteur;
    }
}

Créer les contrôleurs et leurs services

Étant donné que nous avons besoin de deux API et que leur logique métier est très différente, nous les implémenterons dans des contrôleurs distincts. Des contrôleurs distincts signifient que nous aurons des services distincts. Créons d'abord un MainController.java et son service comme MainService.java. Nous allons implémenter l'API sur laquelle vous envoyez l'URL Crawler dans ce contrôleur.

Créer un nouveau paquet com.example.crawlbase.controllers pour les contrôleurs et com.example.crawlbase.services pour les services du projet.

Classe MainController :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
paquet com.exemple.crawlbase.controllers;

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

importer com.example.crawlbase.requests.ScrapeUrlRequest;
importer com.exemple.crawlbase.services.MainService;

importer lombok.extern.slf4j.Slf4j;

@RestController
@RequestMapping("/scrape")
@Slf4j
public classe Contrôleur principal {

 @Autowired
 Privé Service principal mainService;

 @PostMapping("/push-urls")
 public Entité de réponse pousser les URL vers Cawler(@RequestBody (Requête ScrapeUrlRequest) {
  Essai {
   if(!request.getUrls().isEmpty()) {
    // Traiter la requête de manière asynchrone
    mainService.pushUrlsToCrawler(requête.getUrls(), "parent");
   }
   retourner ResponseEntity.status(HttpStatus.OK).build();
  } capture (Exception e) {
   log.erreur("Erreur dans pushUrlsToCrawler fonction: " + e.getMessage());
   retourner ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
  }
 }

}

Comme vous pouvez le voir ci-dessus, nous avons créé une API reposante « @POST /scrape/push-urls » qui sera responsable de la gestion de la demande de transmission d'URL vers le Crawler.

Classe MainService :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
paquet com.exemple.crawlbase.services;

importer java.util.*;
importer com.crawlbase.*;
importer com.exemple.crawlbase.models.CrawlerDemande;
importer com.exemple.crawlbase.repositories.CrawlerDemandeRepository;
importer com.fasterxml.jackson.databind.JsonNode;
importer com.fasterxml.jackson.databind.ObjectMapper;

importer lombok.extern.slf4j.Slf4j;

importer org.springframework.beans.factory.annotation.Autowired;
importer org.springframework.beans.factory.annotation.Value;
importer org.springframework.scheduling.annotation.Async;
importer Service de stéréotype de Springframework

@Slf4j
@Un service
public classe Service principal {

 @Autowired
    Privé CrawlercrawlerRequestRepository;

    // Injecter les valeurs du fichier de propriétés
    @Value("${crawlbase.token}")
    Privé Chaîne crawlbaseToken ;
    @Value("${crawlbase.crawler}")
    Privé Base de crawl de chaîneCrawlernom;

    Privé finale ObjectMappeur objetMapper = nouvelle ObjectMappeur();

    @Async
    public annuler pousser les URL versCrawler(Liste URL, type de chaîne) {
    HashMap options = nouvelle Carte de hachage();
        options.mettre("rappel", "True");
        options.mettre("crawler", base d'explorationCrawlerNom);
        options.mettre("callback_headers", "taper:" + type);

        API api = nul;
        CrawlerDemander req = nul;
        Node Json jsonNode = nul;
        Chaîne débarrasser = nul;

        pour(Chaîne d'URL : URL) {
            Essai {
            API = nouvelle API(jeton de base d'exploration);
            api.get(url, options);
            jsonNode = objectMapper.readTree(api.getBody());
                débarrasser = jsonNode.get("débarrasser").asText();
                if(débarrasser != nul) {
                    demande = CrawlerRequête.builder().url(url).type(type).
                    statut(api.getStatusCode()).rid(rid).build();
                    crawlerRequestRepository.save(req);
                }
            } capture(Exception e) {
                log.erreur("Erreur dans pushUrlsToCrawler fonction: " + e.getMessage());
            }
        }
    }

}

Dans le service ci-dessus, nous avons créé une méthode Async pour traiter la demande de manière asynchrone. pushUrlsToCrawler utilise la fonction Crawlbase bibliothèque pour pousser les URL vers le Crawler puis enregistrez le RID reçu et les autres attributs dans la table crawler_request. Pour envoyer des URL vers le Crawler, nous devons utiliser les paramètres « crawler » et « callback ». Nous utilisons également « callback_headers » pour envoyer un « type » d’en-tête personnalisé, que nous utiliserons pour savoir si l’URL est celle que nous avons donnée ou si elle est récupérée lors d’une exploration en profondeur. Vous pouvez en savoir plus sur ces paramètres et bien d’autres ici.

Maintenant, nous devons implémenter l'API, nous allons utiliser un webhook. Pour cela, créez WebhookController.java dans le com.example.crawlbase.controllers paquet et WebhookService.java dans le com.example.crawlbase.services paquet.

Classe WebhookController :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
paquet com.exemple.crawlbase.controllers;

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

importer com.example.crawlbase.services.WebhookService;

importer lombok.extern.slf4j.Slf4j;

@RestController
@RequestMapping("/webhook")
@Slf4j
public classe Contrôleur Webhook {

    @Autowired
    Privé Service Webhook

    @PostMapping("/crawlbase")
    public Entité de réponse base d'explorationCrawlerRéponse(@RequestHeader En-têtes HttpHeaders, @RequestBody octet[]compresséBody) {
        Essai {
        if(!headers.getFirst(HttpHeaders.USER_AGENT).equalsIgnoreCase("Crawlbase Surveillance Bot 1.0") &&
            "gzip".equalsIgnoreCase(en-têtes.getFirst(HttpHeaders.CONTENT_ENCODING)) &&
            en-têtes.getFirst("pc_status").égal à("200")) {
            // Traiter la requête de manière asynchrone
            webhookService.handleWebhookResponse(en-têtes, corps compressé);
        }
        retourner ResponseEntity.status(HttpStatus.OK).build();
        } capture (Exception e) {
            log.erreur("Erreur dans crawlbaseCrawlerFonction de réponse : " + e.getMessage());
            retourner ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
        }
    }

}

Dans le code ci-dessus, vous pouvez voir que nous avons créé une API reposante, « @POST /webhook/crawlbase », qui sera responsable de la réception de la réponse de la requête de sortie du Crawler. Vous pouvez remarquer dans le code que nous ignorons les appels avec USER_AGENT comme «Crawlbase Surveillance Bot 1.0” car Crawler Monitoring Bot demande à cet agent utilisateur de vérifier si le rappel est actif et accessible. Il n'est donc pas nécessaire de traiter cette demande. Il suffit de renvoyer une réponse positive à l'agent utilisateur. Crawler.

En travaillant avec Crawlbase CrawlerVotre webhook de serveur doit…

  • Être accessible publiquement depuis Crawlbase serveurs
  • Soyez prêt à recevoir des appels POST et à répondre dans les 200 ms
  • Répondez dans les 200 ms avec un code d'état 200, 201 ou 204 sans contenu

Classe WebhookService :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
paquet com.exemple.crawlbase.services;

importer java.io.ByteArrayInputStream;
importer java.io.InputStreamReader;
importer java.net.URI;
importer java.net.URISyntaxException;
importer java.util.ArrayList;
importer java.util.List;
importer java.util.Objects;
importer java.util.regex.Matcher;
importer java.util.regex.Modèle;
importer java.util.zip.GZIPInputStream;

importer org.jsoup.Jsoup;
importer Document.
importer Élément org.jsoup.nodes;
importer org.jsoup.select.Éléments;
importer org.springframework.beans.factory.annotation.Autowired;
importer org.springframework.http.HttpHeaders;
importer org.springframework.scheduling.annotation.Async;
importer Service de stéréotype de Springframework

importer com.exemple.crawlbase.models.CrawlerDemande;
importer com.exemple.crawlbase.models.CrawlerRéponse;
importer com.exemple.crawlbase.repositories.CrawlerDemandeRepository;
importer com.exemple.crawlbase.repositories.CrawlerRéponseRepository;
importer com.exemple.crawlbase.requests.CrawlerDemande de Webhook ;

importer lombok.extern.slf4j.Slf4j;

@Slf4j
@Un service
public classe Service Webhook {

    @Autowired
    Privé CrawlercrawlerRequestRepository;
    @Autowired
    Privé CrawlerRéponseRepository crawlerResponseRepository ;
    @Autowired
    Privé Service principal mainService;

    @Async("taskExecutor")
    public annuler handleWebhookRéponse(en-têtes HttpHeaders, octet[]compresséBody) {
        Essai {
            // Décompressez le corps gzipé
            Flux d'entrée GZIP flux d'entrée gzip = nouvelle Flux d'entrée GZIP(nouvelle Flux d'entrée de tableau d'octets(CorpsCompressé));
            Lecteur de flux d'entrée lecteur = nouvelle Lecteur de flux d'entrée(gzipInputStream);

            // Traiter le contenu HTML non compressé
            Générateur de chaînes Contenu html = nouvelle Générateur de chaînes();
            carboniser[] tampon = nouvelle carboniser[1024];
            int octetsLus;
            tout en ((bytesRead = lecteur.read(buffer)) != -1) {
                htmlContent.append(tampon, 0, octetsLus);
            }

            // La chaîne HTML
            Chaîne chaîne html = htmlContent.toString();

            // Créer l'objet de requête
            CrawlerDemande de Webhook demandez = CrawlerWebhookRequest.builder()
                .original_status(Entier.valueOf(en-têtes.getFirst("état_original")))
                .pc_status(Entier.valueOf(en-têtes.getFirst("pc_status")))
                .rid(en-têtes.getFirst("débarrasser"))
                .url(en-têtes.getFirst("url"))
                .corps(htmlString).build();

            // Sauvegarder CrawlerModèle de réponse
            ListeCrawlerRequête > résultats = crawlerRequestRepository.findByRid(request.getRid());
            CrawlerDemander crawlerRequest = !results.isEmpty() ? résultats.get(0): nul;
            if(crawlerRequest != nul) {
                // Construire CrawlerModèle de réponse
                CrawlerRéponse Réponse du robot = CrawlerRéponse.builder().pcStatus(request.getPc_status())
                    .originalStatus(request.getOriginal_status()).pageHtml(request.getBody()).crawlerRequest(crawlerRequest).build();
                crawlerResponseRepository.save(crawlerResponse);
            }

            // URL parente d'exploration approfondie uniquement
            if(en-têtes.getFirst("type").equalsIgnoreCase("parent")) {
                deepCrawlParentResponse(requête.getBody(), requête.getUrl());
            }
        } capture (Exception e) {
            log.erreur(« Erreur dans la fonction handleWebhookResponse : » + e.getMessage());
        }

    }

    Privé annuler Réponse parent deepCrawl(Chaîne html, chaîne baseUrl) {
    Documents document = Jsoup.parse(html);
        Éléments Liens hypertexte = document.getElementsByTag("une");
        Liste liens = nouvelle ArrayList();

        Chaîne url = nul;
        pour (Élément hyperlien : hyperliens) {
            url = processUrl(hyperlien.attr(href), baseUrl);
            if(url != nul) {
            liens.add(url);
        }
        }

        mainService.pushUrlsToCrawler(links, "enfant");
    }

    Privé Chaîne URL du processus(Chaîne href, chaîne baseUrl) {
        Essai {
            if (href != nul && !href.isEmpty()) {
                baseUrl = normalizeUrl(baseUrl);
                Chaîne URL traitée = normalizeUrl(href.startsWith("/") ? baseUrl + href : href);
                if (isValidUrl(processedUrl) &&
                    !processedUrl.replace("http://", "").remplacer("https://", "").equals(baseUrl.replace("http://", "").remplacer("https://", "")) &&
                    // Ne considérer que les URL avec le même nom d'hôte
                    Objets.equals(nouvelle URI(processedUrl).getHost(), nouvelle URI(baseUrl).getHost())) {

                    retourner URL traitée;
                }
            }
        } capture (Exception e) {
            log.erreur(« Erreur dans la fonction processUrl : » + e.getMessage());
        }
        retourner nul;
    }

    Privé booléen estValideUrl(chaîne de chaîne) {
     Chaîne urlRegex = "((http|https)://)(www.)?"
                + "[a-zA-Z0-9@:%._\\+~#?&//=]"
                + "{2,256}\\.[az]"
                + "{2,6}\\b([-a-zA-Z0-9@:%"
                + "._\\+~#?&//=]*)";
        Patron de Couture modèle = Motif.compile(urlRegex);
        matchers matcheur = pattern.matcher(chaîne);
        retourner matcher.matches();
    }

    Privé Chaîne normaliserUrl(Chaîne d'URL) jette Exception de syntaxe URIS {
        url = url.remplacer("//www.", "//");
        url = url.split("#")[0];
        url = url.endsWith("/") ? url.substring(0, url.length() - 1) : url;
        retourner URL;
    }
}

La classe WebhookService joue un rôle crucial dans la gestion efficace des réponses webhook et dans l'orchestration du processus d'exploration en profondeur. Lorsqu'une réponse webhook est reçue, la méthode handleWebhookResponse est invoquée de manière asynchrone à partir de la base d'exploration du WebhookControllerCrawlerFonction de réponse. Cette méthode commence par décompresser le contenu HTML compressé et extraire les métadonnées et les données HTML nécessaires. Les données extraites sont ensuite utilisées pour construire un CrawlerObjet WebhookRequest contenant des détails tels que l'état, l'ID de demande (rid), l'URL et le contenu HTML.

Ensuite, le service vérifie s'il existe un CrawlerRequête associée à l'ID de la demande. Si elle est trouvée, elle construit une CrawlerObjet de réponse pour encapsuler les détails de réponse pertinents. Ceci CrawlerL'instance de réponse est ensuite conservée dans la base de données via le CrawlerRéférentiel de réponses.

Cependant, ce qui distingue ce service est sa capacité à faciliter l'exploration en profondeur. Si le type de réponse du webhook indique une URL « parent », le service invoque la méthode deepCrawlParentResponse. Dans cette méthode, le contenu HTML est analysé à l'aide de la bibliothèque Jsoup pour identifier les hyperliens au sein de la page. Ces hyperliens, représentant des URL enfants, sont traités et validés. Seules les URL appartenant au même nom d'hôte et adhérant à un format spécifique sont conservées.

Le service MainService est ensuite utilisé pour envoyer ces URL enfants valides dans le pipeline d'exploration, en utilisant le type « enfant » comme indicateur. Cela déclenche un processus récursif d'exploration approfondie, où les URL enfants sont explorées plus en détail, étendant l'exploration à plusieurs niveaux de pages interconnectées. En substance, le service WebhookService coordonne la danse complexe de la gestion des réponses webhook, de la capture et de la conservation des données pertinentes et de l'orchestration du processus complexe d'exploration approfondie en identifiant et en parcourant intelligemment les URL parentes et enfants.

Mise à jour du fichier application.properties

Dans la dernière étape, nous allons configurer le fichier application.properties pour définir les propriétés et paramètres essentiels de notre projet. Ce fichier sert de point central pour la configuration de divers aspects de notre application. Nous devons y spécifier les propriétés liées à la base de données, les paramètres Hibernate, Crawlbase détails d'intégration et préférences de journalisation.

Assurez-vous que votre fichier application.properties inclut les propriétés suivantes :

1
2
3
4
5
6
7
8
9
10
11
12
13
# Configuration de la base de données
source de données de printemps.url=jdbc:mysql://localhost:3306/
printemps.datasource.nom d'utilisateur=
printemps.sourcededonnées.motdepasse=

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

# Crawlbase Crawler Intégration :
crawlbase.token=Crawlbase_Jeton_Normal>
crawlbase.crawler=Crawler_Nom>

logging.file.name=journaux/ .enregistrer

Vous pouvez trouver votre Crawlbase Jeton TCP (normal) iciN'oubliez pas de remplacer les espaces réservés dans le code ci-dessus par vos valeurs réelles, telles que définies dans les sections précédentes. Cette configuration est essentielle pour établir des connexions à la base de données, synchroniser les opérations Hibernate et intégrer le Crawlbase API et gestion de la journalisation de votre application. En ajustant soigneusement ces propriétés, vous assurerez une communication fluide entre les différents composants et services de votre projet.

Exécution du projet et lancement d'une exploration approfondie

Une fois la phase de codage terminée, l'étape suivante consiste à lancer le projet. Spring Boot, à la base, utilise une version Apache Tomcat intégrée qui permet des transitions fluides du développement à la production et s'intègre parfaitement aux principales plateformes en tant que service. L'exécution du projet dans Spring Tool Suite (STS) implique un processus simple :

  • Cliquez avec le bouton droit sur le projet dans l’arborescence de la structure du projet STS.
  • Accédez au menu « Exécuter en tant que ». et
  • Sélectionnez « Application Spring Boot ».

Cette action déclenche le lancement du projet sur localhost, port 8080.

Serveur Spring Boot en cours d'exécution

Rendre le Webhook accessible au public

Étant donné que le webhook que nous avons établi réside localement sur notre système sur localhost, port 8080, nous devons lui accorder l'accessibilité publique. Entrez Ngrok, un outil qui crée des tunnels sécurisés, permettant un accès à distance sans avoir à manipuler les paramètres réseau ou les ports du routeur. Ngrok est exécuté sur le port 8080 pour rendre notre webhook accessible au public.

Serveur Ngrok

Ngrok fournit commodément une URL de transfert publique, que nous utiliserons plus tard avec Crawlbase Crawler.

Création du Crawlbase Crawler

Rappelez-vous notre discussion précédente sur Crawlbase Crawler création via le Crawlbase tableau de bordArmé d'un webhook accessible au public via Ngrok, la création du robot devient sans effort.

CRÉER UN NOUVEAU DOSSIER Crawler

Dans l'exemple illustré, l'URL de transfert ngrok collabore avec l'adresse webhook « /webhook/crawlbase » en tant que rappel. Cette fusion produit une adresse webhook entièrement publique. Nous baptisons notre crawler « test-crawler », un nom qui sera incorporé dans le fichier application.properties du projet. La sélection de TCP Crawler correspond à notre choix. En cliquant sur « Créer Crawler", le crawler prend forme, configuré selon les paramètres spécifiés.

Initiation en profondeur Crawling en poussant les URL

Après la création du robot d'exploration et l'incorporation de son nom dans le fichier application.properties, nous sommes prêts à interagir avec l'API « @POST /scrape/push-urls ». Grâce à cette API, nous envoyons des URL au robot d'exploration, déclenchant ainsi le processus d'exploration en profondeur. Prenons l'exemple de l'envoi de l'URL http://www.3bfluidpower.com/.

Demande du facteur

Grâce à cette approche proactive, nous mettons en mouvement les roues de l’exploration en profondeur, en utilisant la puissance de Crawlbase Crawler pour approfondir le paysage numérique et dénicher des informations précieuses.

Analyse des résultats dans la base de données

Lors du lancement de l'URL push vers le Crawler, un identifiant de demande (RID) est renvoyé - un concept élaboré dans des discussions précédentes - marquant le début du processus d'exploration de la page sur le Crawler's end. Cette approche stratégique élimine le temps d'attente généralement associé au processus d'exploration, améliorant ainsi l'efficacité et l'efficience de l'acquisition de données. Une fois que le Crawler conclut l'exploration, il transmet de manière transparente la sortie à notre webhook.

Le paramètre Custom Headers, en particulier le paramètre « type », s’avère déterminant dans notre démarche. Sa présence nous permet de faire la distinction entre les URL que nous avons poussées et celles découvertes lors de l’exploration approfondie. Lorsque le type est désigné comme « parent », l’URL provient de notre soumission, ce qui nous incite à extraire de nouvelles URL du code HTML exploré et à les réacheminer ensuite vers le Crawler— cette fois-ci catégorisé comme « enfant ». Cette stratégie garantit que seules les URL que nous avons introduites subissent une exploration approfondie, simplifiant ainsi le processus.

Dans notre scénario actuel, en considérant une soumission d'URL singulière à la Crawler, le flux de travail se déroule comme suit : à la réception du code HTML exploré, le service webhook le stocke dans la table crawler_response. Par la suite, l'exploration approfondie de ce code HTML a lieu, produisant des URL nouvellement découvertes qui sont ensuite poussées vers le Crawler.

Tableau crawler_request :

Crawler Tableau de requête

Comme vous pouvez le voir ci-dessus, dans notre service webhook, nous avons trouvé 16 nouvelles URL à partir du HTML de la page dont nous envoyons l'URL vers le Crawler dans la section précédente, que nous sauvegardons dans la base de données avec « type : parent ». Nous envoyons toutes les nouvelles URL trouvées au robot d'exploration pour qu'il explore en profondeur l'URL donnée. Crawler nous allons tous les explorer et envoyer la sortie sur notre webhook. Nous enregistrons le code HTML exploré dans la table crawler_response.

Tableau crawler_response :

Crawler Tableau de réponse

Comme vous pouvez le voir dans le tableau ci-dessus, toutes les informations que nous obtenons sur notre webhook sont enregistrées dans le tableau. Une fois que vous avez le code HTML sur votre webhook, nous pouvons extraire toutes les informations que nous voulons. Ce processus détaillé met en évidence le fonctionnement de l'exploration en profondeur, nous permettant de découvrir des informations importantes à partir du contenu Web.

Conclusion

Tout au long de cette exploration du scraping Web avec Java et Spring Boot, nous avons parcouru les étapes critiques de la configuration d'un environnement Java adapté au scraping Web, de la sélection des bibliothèques appropriées et de l'exécution de projets de scraping Web simples et sophistiqués. Ce voyage souligne la polyvalence et la robustesse de Java dans l'extraction de données du Web, en mettant en avant des outils tels que JSoup, Selenium et HtmlUnit pour leurs atouts uniques dans la gestion du contenu Web statique et dynamique. En dotant les lecteurs des connaissances nécessaires pour adapter leurs efforts de scraping Web aux exigences spécifiques du projet, cet article sert de guide complet sur les complexités et les possibilités du scraping Web avec Java.

En conclusion, il est clair que la maîtrise du scraping Web en Java ouvre une multitude d'opportunités pour l'extraction, l'analyse et l'application des données. Que l'objectif soit de surveiller les tendances du marché, d'agréger du contenu ou de collecter des données pertinentes sur le Web, les techniques et les informations fournies ici constituent une base solide pour les développeurs novices comme expérimentés. Alors que des défis tels que la gestion de contenu dynamique et l'évasion des mesures de sécurité persistent, la nature évolutive des outils de scraping Web Java promet des avancées continues. Par conséquent, rester informé et adaptable sera essentiel pour exploiter tout le potentiel des technologies de scraping Web dans le paysage en constante évolution d'Internet.

Merci de nous avoir rejoint dans cette aventure. Vous pouvez trouver le code source complet du projet sur GitHub ici. Que vos efforts en matière de données Web soient aussi transformateurs que les outils et les connaissances que vous avez acquis ici. Alors que le paysage numérique continue de se développer, n'oubliez pas que le pouvoir d'innover est entre vos mains.

Pour plus de tutoriels comme ceux-ci, suivez notre blog, voici quelques guides de tutoriels Java qui pourraient vous intéresser

Exploration de sites Web de commerce électronique

Web Scrape Expedia

Web Scrape Booking.com

Comment récupérer les avis sur les produits G2

Scraping Web de dramaturges

Grattez Yahoo Finance

Foire aux questions (FAQ)

Q : Dois-je utiliser JAVA pour utiliser le Crawler?

Non, vous n'avez pas besoin d'utiliser exclusivement JAVA pour utiliser le Crawlbase CrawlerL’ Crawler propose plusieurs bibliothèques pour différents langages de programmation, permettant aux utilisateurs d'interagir avec eux dans leur langage préféré. Que vous soyez à l'aise avec Python, JavaScript, Java, Ruby ou d'autres langages de programmation, Crawlbase vous couvre. De plus, Crawlbase propose des API qui permettent aux utilisateurs d'accéder à CrawlerLes fonctionnalités de s sans s'appuyer sur des bibliothèques spécifiques, le rendant accessible à un large éventail de développeurs ayant des préférences linguistiques et des antécédents techniques différents. Cette flexibilité garantit que vous pouvez intégrer de manière transparente le Crawler dans vos projets et flux de travail en utilisant le langage qui correspond le mieux à vos besoins.

Q : Pouvez-vous utiliser Java pour le scraping Web ?

Oui, Java est un langage de programmation très performant qui a été utilisé pour de nombreuses applications, notamment le scraping Web. Il a considérablement évolué au fil des ans et prend en charge divers outils et bibliothèques spécifiquement destinés aux tâches de scraping.

Q : Quelle bibliothèque Java est la plus efficace pour le scraping Web ?

Pour le scraping Web en Java, les bibliothèques les plus recommandées sont JSoup, HtmlUnit et Selenium WebDriver. JSoup est particulièrement utile pour extraire des données de pages HTML statiques. Pour les sites Web dynamiques qui utilisent JavaScript, HtmlUnit et Selenium WebDriver sont mieux adaptés.

Q : Entre Java et Python, lequel est le plus adapté au web scraping ?

Python est généralement préféré à Java pour le scraping Web. Cette préférence est due à la simplicité de Python et à son riche écosystème de bibliothèques telles que BeautifulSoup, qui simplifie l'analyse et la navigation dans les documents HTML et XML.

Q : Quel langage de programmation est considéré comme le meilleur pour le scraping Web ?

Python est considéré comme le meilleur langage de programmation pour les tâches de scraping Web. Il propose une suite complète de bibliothèques et d'outils tels que BeautifulSoup et Scrapy, conçus pour faciliter un scraping Web efficace et efficient.