Créer un document HTML – Créer, charger du HTML en Java
Document HTML
La classe HTMLDocument est le point de départ de la bibliothèque Aspose.HTML for Java, permettant aux développeurs de travailler avec du contenu HTML de manière programmatique. La classe HTMLDocument représente une page HTML telle qu’elle est rendue dans un navigateur, servant de racine au Document Object Model (DOM).
Certaines fonctionnalités de HTMLDocument
- Des constructeurs flexibles permettent de créer un document HTML à partir d’un fichier, d’une URL, d’un flux ou d’une chaîne.
- HTMLDocument fournit une représentation en mémoire qui garantit la structure DOM complète pour la manipulation.
- La gestion des événements comprend la prise en charge des événements DOM pour les opérations asynchrones.
Le HTMLDocument fournit une représentation en mémoire d’un DOM HTML et est entièrement basé sur les spécifications W3C DOM et WHATWG DOM supportées par de nombreux navigateurs modernes. Si vous connaissez les normes WHATWG DOM, WHATWG HTML et JavaScript, vous pourrez utiliser Aspose.HTML for Java en toute simplicité. Sinon, vous pouvez visiter www.w3schools.com, où vous trouverez de nombreux exemples et tutoriels sur la façon de travailler avec des documents HTML.
Créer un document HTML vide
L’extrait de code suivant montre l’utilisation du constructeur par défaut HTMLDocument() pour créer un document HTML vide et l’enregistrer dans un fichier.
1// Create an empty HTML document using Java
2
3// Initialize an empty HTML Document
4HTMLDocument document = new HTMLDocument();
5
6// Save the document to disk
7document.save("create-empty-document.html");Après la création, le fichier create-empty-document.html apparaît avec la structure initiale du document : le document vide comprend des éléments tels que <html> <head> et <body>. Pour plus de détails sur l’enregistrement des fichiers HTML, voir l’article
Enregistrer un document HTML.
Structure du fichier résultant :
1<html>
2 <head></head>
3 <body></body>
4</html>Créer un nouveau document HTML
Pour générer un document par programme à partir de zéro, utilisez le constructeur HTMLDocument() sans paramètres, comme le montre l’extrait de code ci-dessus. Une fois l’objet document créé, il peut être rempli ultérieurement avec des éléments HTML. Vous pouvez remplir le document avec du contenu, par exemple en créant un nœud de texte et en l’ajoutant au corps du document :
1// Create an HTML document using Java
2
3// Initialize an empty HTML document
4HTMLDocument document = new HTMLDocument();
5
6// Create a text node and add it to the document
7Text text = document.createTextNode("Hello, World!");
8document.getBody().appendChild(text);
9
10// Save the document to disk
11document.save("create-new-document.html");Charger du HTML à partir d’un fichier
L’extrait de code suivant montre comment charger le HTMLDocument à partir d’un fichier existant :
1// Load HTML from a file using Java
2
3// Prepare the "load-from-file.html" file
4try (java.io.FileWriter fileWriter = new java.io.FileWriter("load-from-file.html")) {
5 fileWriter.write("Hello, World!");
6}
7
8// Load HTML from the file
9HTMLDocument document = new HTMLDocument("load-from-file.html");
10
11// Write the document content to the output stream
12System.out.println(document.getDocumentElement().getOuterHTML());Charger du HTML à partir d’une URL
La classe HTMLDocument permet de récupérer et de charger le contenu HTML d’une page web. Dans l’extrait de code suivant, vous verrez comment charger une page web dans HTMLDocument.
Dans le cas où vous passez une mauvaise URL qui ne peut pas être atteinte en ce moment, la bibliothèque lance une
DOMException avec le code spécialisé NetworkError pour vous informer que la ressource sélectionnée ne peut pas être trouvée.
1// Load HTML from a URL using Java
2
3// Load a document from https://docs.aspose.com/html/files/document.html web page
4HTMLDocument document = new HTMLDocument("https://docs.aspose.com/html/files/document.html");
5
6System.out.println(document.getDocumentElement().getOuterHTML());Charger du HTML à partir d’un code HTML
Si vous préparez un code HTML sous forme d’objets Class String ou Class InputStream en mémoire, vous n’avez pas besoin de les enregistrer dans le fichier, il vous suffit de passer votre code HTML dans des constructeurs spécialisés. Pour créer un document à partir d’une chaîne, utilisez le constructeur HTMLDocument(content, baseUri) avec le contenu HTML et une baseUri :
1// Create HTML from a string using Java
2
3// Prepare HTML code
4String html_code = "<p>Hello, World!</p>";
5
6// Initialize a document from a string variable
7HTMLDocument document = new HTMLDocument(html_code, ".");
8
9// Save the document to disk
10document.save("create-from-string.html");Si votre code HTML contient des ressources liées (styles, scripts, images, etc.), vous devez passer un paramètre baseUrl valide au constructeur du document. Il sera utilisé pour résoudre l’emplacement de la ressource pendant le chargement du document.
Charger du HTML à partir d’un flux
Pour créer un document HTML à partir d’un flux, vous pouvez utiliser le constructeur HTMLDocument(stream, string) :
1// Load HTML from a stream using Java
2
3// Create a memory stream object
4String code = "<p>Hello, World! I love HTML!</p>";
5java.io.InputStream inputStream = new java.io.ByteArrayInputStream(code.getBytes());
6
7// Initialize a document from the stream variable
8HTMLDocument document = new HTMLDocument(inputStream, ".");
9
10// Save the document to disk
11document.save("load-from-stream.html");Travailler avec des documents SVG, MHTML et EPUB
Document SVG
Étant donné que les graphiques vectoriels évolutifs (SVG) font partie des normes W3C et peuvent être intégrés dans HTMLDocument, nous avons implémenté SVGDocument et toutes ses fonctionnalités. Notre implémentation est basée sur la spécification officielle SVG2, vous pouvez donc charger, lire, manipuler les documents SVG tels qu’ils sont décrits officiellement.
Puisque
SVGDocument et
HTMLDocument sont basés sur le même standard
WHATWG DOM, toutes les opérations telles que le chargement, la lecture, l’édition, la conversion et la sauvegarde sont similaires pour les deux documents. Ainsi, tous les exemples de manipulation de HTMLDocument s’appliquent également à SVGDocument.
L’exemple ci-dessous montre comment charger le document SVG à partir de la variable Class String en mémoire :
1// Load SVG from a string using Java
2
3// Initialize an SVG document from a string object
4SVGDocument document = new SVGDocument("<svg xmlns='http://www.w3.org/2000/svg'><circle cx='50' cy='50' r='40'/></svg>", ".");
5
6// Write the document content to the output stream
7System.out.println(document.getDocumentElement().getOuterHTML());Document MHTML
MHTML (MIME encapsulation of aggregate HTML documents) est un format spécialisé pour la création d’archives de pages web. La bibliothèque Aspose.HTML for Java prend en charge le MHTML, mais sa fonctionnalité est actuellement limitée aux opérations de conversion et de rendu du MHTML vers d’autres formats de sortie pris en charge. Pour plus d’informations, reportez-vous à l’article Conversion entre formats.
Document EPUB
EPUB, un format de publication électronique largement utilisé pour les livres électroniques, présente des limitations similaires à celles de MHTML dans la bibliothèque Aspose.HTML for Java. La bibliothèque ne prend en charge que les opérations de rendu à partir d’EPUB vers les formats de sortie pris en charge. Pour plus de détails, consultez l’article Conversion entre formats.
Opérations asynchrones
Nous sommes conscients que le chargement d’un document peut être une opération gourmande en ressources puisqu’il faut charger non seulement le document lui-même mais aussi toutes les ressources liées et traiter tous les scripts. Ainsi, dans les extraits de code suivants, nous vous montrons comment utiliser des opérations asynchrones et charger HTMLDocument sans bloquer le fil d’exécution principal.
Le code suivant illustre l’utilisation d’un document HTMLDocument en Java en s’abonnant à l’événement OnReadyStateChange, qui surveille le chargement du document. Lorsque le document atteint l’état “complete”, il récupère le balisage HTML complet de son élément racine à l’aide de la méthode getOuterHTML() et le stocke dans un StringBuilder. Pour garantir le temps de chargement du document et l’exécution du gestionnaire d’événements, le programme suspend son exécution pendant 5 secondes à l’aide de Thread.sleep(5000). Enfin, il affiche le code HTML capturé sur la console.
1// Load HTML asynchronously using Java
2
3// Create an instance of the HTMLDocument class
4HTMLDocument document = new HTMLDocument();
5
6// Create a string variable for OuterHTML property reading
7StringBuilder outerHTML = new StringBuilder();
8
9// Subscribe to 'ReadyStateChange' event
10// This event will be fired during the document loading process
11document.OnReadyStateChange.add(new DOMEventHandler() {
12 @Override
13 public void invoke(Object sender, Event e) {
14 // Check the value of the 'ReadyState' property
15 // This property is representing the status of the document. For detail information please visit https://www.w3schools.com/jsref/prop_doc_readystate.asp
16 if (document.getReadyState().equals("complete")) {
17 // Fill the outerHTML variable by value of loaded document
18 outerHTML.append(document.getDocumentElement().getOuterHTML());
19 }
20 }
21});
22
23Thread.sleep(5000);
24
25System.out.println("outerHTML = " + outerHTML);Contrairement au premier exemple, celui-ci illustre une navigation asynchrone en chargeant un document depuis une URL donnée et en utilisant la méthode wait/notify au lieu d’un délai fixe. Cette approche est plus fiable, car elle réagit précisément lorsque le document atteint l’état “complete”, évitant ainsi toute attente inutile ou exécution prématurée.
1// Create an instance of the HTMLDocument class
2
3HTMLDocument document = new HTMLDocument();
4
5// Subscribe to the 'ReadyStateChange' event. This event will be fired during the document loading process
6document.OnReadyStateChange.add(new DOMEventHandler() {
7 @Override
8 public void invoke(Object sender, Event e) {
9 // Check the value of 'ReadyState' property
10 // This property is representing the status of the document. For detail information please visit https://www.w3schools.com/jsref/prop_doc_readystate.asp
11 if (document.getReadyState().equals("complete")) {
12 System.out.println(document.getDocumentElement().getOuterHTML());
13 notifyAll();
14 }
15 }
16});
17
18// Navigate asynchronously at the specified Uri
19document.navigate("https://html.spec.whatwg.org/multipage/introduction.html");
20
21synchronized (this) {
22 wait(10000);
23}Cet exemple Java définit une classe HTMLDocumentWaiter personnalisée qui implémente Runnable pour gérer les documents HTML de manière asynchrone à l’aide de la bibliothèque Aspose.HTML for Java. Le constructeur accepte une instance de HTMLDocumentAsynchronouslyOnLoad et déclenche son exécution dans un thread distinct. Dans la méthode run(), le code vérifie en permanence la réception d’un message de l’opération asynchrone, en mettant le thread en pause pendant un intervalle de temps Thread.sleep(60000) entre chaque vérification. Dès que le message est disponible ou que le thread est interrompu, l’attente s’arrête. Cette approche permet de surveiller le processus de chargement asynchrone en parallèle avec le flux principal du programme.
1// Create async waiter thread for HTML document loading using Java
2
3public class HTMLDocumentWaiter implements Runnable {
4
5 private final HTMLDocumentAsynchronouslyOnLoad html;
6
7 public HTMLDocumentWaiter(HTMLDocumentAsynchronouslyOnLoad html) throws Exception {
8 this.html = html;
9 this.html.execute();
10 }
11
12 @Override
13 public void run() {
14 System.out.println("Current Thread: " + Thread.currentThread().getName() + "; " + Thread.currentThread().getId());
15
16 while (!Thread.currentThread().isInterrupted() && html.getMsg() == null) {
17 try {
18 Thread.sleep(60000);
19 } catch (InterruptedException e) {
20 throw new RuntimeException(e);
21 }
22 }
23 Thread.currentThread().interrupt();
24 }
25}Dans l’exemple suivant, le code utilise l’événement OnLoad plutôt que de s’appuyer sur les vérifications ReadyState ou l’attente manuelle. L’événement OnLoad est automatiquement déclenché une fois le chargement du document terminé, ce qui simplifie et optimise cette approche. Lorsque l’événement est déclenché, le programme récupère le code HTML externe du document et l’affiche sur la console. Cette méthode évite les retards et les problèmes de synchronisation inutiles, offrant ainsi une méthode plus simple pour gérer le contenu HTML chargé de manière asynchrone.
1// Handle HTML document onLoad event when navigating to URL using Java
2
3// Create an instance of the HTMLDocument class
4HTMLDocument document = new HTMLDocument();
5
6// Subscribe to the 'OnLoad' event. This event will be fired once the document is fully loaded
7document.OnLoad.add(new DOMEventHandler() {
8 @Override
9 public void invoke(Object sender, Event e) {
10 msg = document.getDocumentElement().getOuterHTML();
11 System.out.println(msg);
12 }
13});
14
15// Navigate asynchronously at the specified Uri
16document.navigate("https://html.spec.whatwg.org/multipage/introduction.html");Conclusions
Manipulation complète du DOM : La classe
HTMLDocumentfournit un moyen robuste et conforme aux normes de créer, modifier et manipuler des documents HTML par programmation, conformément aux spécifications du W3C et du WHATWG.Création et chargement de documents flexibles : À l’aide de constructeurs, les développeurs peuvent créer des documents à partir de zéro, charger du HTML à partir de diverses sources (fichiers, URL, flux) ou générer dynamiquement du contenu.
Prise en charge des opérations avancées : Des fonctionnalités telles que le chargement asynchrone et la gestion des événements permettent l’intégration transparente d’opérations gourmandes en ressources sans bloquer le fil principal de l’application.
Compatibilité multiformat : La bibliothèque étend certaines fonctionnalités du HTML à d’autres formats de documents tels que le SVG, le MHTML et l’EPUB, offrant ainsi une approche unifiée de la gestion de divers contenus web.
Vous pouvez télécharger les exemples complets et les fichiers de données à partir de GitHub.