HTML-Dokument erstellen – HTML in Java erstellen und laden
HTML-Dokument
Die Klasse HTMLDocument ist ein Ausgangspunkt für die Aspose.HTML for Java-Bibliothek, die es Entwicklern ermöglicht, programmatisch mit HTML-Inhalten zu arbeiten. Die Klasse HTMLDocument stellt eine HTML-Seite dar, wie sie in einem Browser gerendert wird, und dient als Wurzel des Document Object Model (DOM).
Einige HTMLDocument-Funktionen
- Flexible Konstruktoren unterstützen die Erstellung eines HTML-Dokuments aus einer Datei, einer URL, einem Stream oder einem String.
- HTMLDocument bietet eine speicherinterne Darstellung, die die vollständige DOM-Struktur für die Manipulation gewährleistet.
- Die Ereignisbehandlung umfasst Unterstützung für DOM-Ereignisse für asynchrone Operationen.
Das HTMLDocument bietet eine speicherinterne Darstellung eines HTML-DOM und basiert vollständig auf den W3C DOM und WHATWG DOM Spezifikationen, die von vielen modernen Browsern unterstützt werden. Wenn Sie mit den Standards WHATWG DOM, WHATWG HTML und JavaScript vertraut sind, können Sie Aspose.HTML for Java ganz einfach verwenden. Andernfalls können Sie www.w3schools.com besuchen, wo Sie viele Beispiele und Tutorials zur Arbeit mit HTML-Dokumenten finden.
Ein leeres HTML-Dokument erstellen
Der folgende Codeausschnitt zeigt die Verwendung des Standardkonstruktors HTMLDocument(), um ein leeres HTML-Dokument zu erstellen und in einer Datei zu speichern.
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");Nach der Erstellung erscheint die Datei create-empty-document.html mit der anfänglichen Dokumentstruktur: Das leere Dokument enthält Elemente wie <html> <head> und <body>. Weitere Einzelheiten zum Speichern von HTML-Dateien finden Sie im Artikel
HTML-Dokument speichern.
Die resultierende Dateistruktur:
1<html>
2 <head></head>
3 <body></body>
4</html>Ein neues HTML-Dokument erstellen
Um ein Dokument von Grund auf programmatisch zu erzeugen, verwenden Sie den Konstruktor HTMLDocument() ohne Parameter, wie im obigen Codeschnipsel gezeigt. Sobald das Dokumentobjekt erstellt ist, kann es später mit HTML-Elementen gefüllt werden. Sie können das Dokument mit Inhalt füllen, indem Sie z.B. einen Textknoten erstellen und ihn in den Textkörper des Dokuments einfügen:
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");HTML aus einer Datei laden
Das folgende Codeschnipsel zeigt, wie man das HTMLDocument aus einer vorhandenen Datei lädt:
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());HTML von einer URL laden
Die Klasse HTMLDocument kann HTML-Inhalte von einer Webseite abrufen und laden. Im nächsten Codeschnipsel sehen Sie, wie Sie eine Webseite in HTMLDocument laden können.
Falls Sie eine falsche URL übergeben, die im Moment nicht erreichbar ist, löst die Bibliothek die
DOMException mit dem speziellen Code NetworkError aus, um Sie zu informieren, dass die ausgewählte Ressource nicht gefunden werden kann.
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());HTML aus HTML-Code laden
Wenn Sie einen HTML-Code als speicherinterne Class String oder Class InputStream Objekte vorbereiten, brauchen Sie diese nicht in der Datei zu speichern, sondern übergeben Ihren HTML-Code einfach an spezielle Konstruktoren. Um ein Dokument aus einem String zu erstellen, verwenden Sie den Konstruktor HTMLDocument(content, baseUri) mit dem HTML-Inhalt und einer 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");Wenn Ihr HTML-Code verknüpfte Ressourcen (Stile, Skripte, Bilder usw.) enthält, müssen Sie einen gültigen baseUrl-Parameter an den Konstruktor des Dokuments übergeben. Er wird verwendet, um den Speicherort der Ressource während des Ladens des Dokuments aufzulösen.
HTML aus einem Stream laden
Um ein HTML-Dokument aus einem Stream zu erstellen, können Sie den Konstruktor HTMLDocument(stream, string) verwenden:
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");Arbeiten mit SVG-, MHTML- und EPUB-Dokumenten
SVG-Dokument
Da Scalable Vector Graphics (SVG) ein Teil des W3C Standards ist und in HTMLDocument eingebettet werden kann, haben wir SVGDocument und alle seine Funktionen implementiert. Unsere Implementierung basiert auf der offiziellen SVG2-Spezifikation, so dass Sie SVG-Dokumente laden, lesen und manipulieren können, wie es offiziell beschrieben ist.
Da
SVGDocument und
HTMLDocument auf demselben
WHATWG DOM Standard beruhen, sind alle Operationen wie Laden, Lesen, Bearbeiten, Konvertieren und Speichern für beide Dokumente ähnlich. Daher sind alle Beispiele, in denen Sie Manipulationen mit HTMLDocument sehen können, auch für SVGDocument anwendbar.
Das folgende Beispiel zeigt Ihnen, wie Sie das SVG-Dokument aus der speicherinternen Variablen Class String laden können:
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());MHTML-Dokument
MHTML (MIME encapsulation of aggregate HTML documents) ist ein spezielles Format zur Erstellung von Webseitenarchiven. Die Aspose.HTML for Java-Bibliothek unterstützt MHTML, aber ihre Funktionalität ist derzeit auf Konvertierungs- und Rendering-Operationen von MHTML in andere unterstützte Ausgabeformate beschränkt. Weitere Informationen finden Sie in dem Artikel Konvertierung zwischen Formaten.
EPUB-Dokument
EPUB, ein elektronisches Publikationsformat, das häufig für eBooks verwendet wird, unterliegt in der Aspose.HTML for Java-Bibliothek ähnlichen Einschränkungen wie MHTML. Die Bibliothek unterstützt nur Rendering-Operationen von EPUB in unterstützte Ausgabeformate. Weitere Einzelheiten finden Sie im Artikel Konvertierung zwischen Formaten.
Asynchrone Vorgänge
Wir wissen, dass das Laden eines Dokuments ein ressourcenintensiver Vorgang sein kann, da nicht nur das Dokument selbst, sondern auch alle verknüpften Ressourcen geladen und alle Skripte verarbeitet werden müssen. In den folgenden Codeschnipseln zeigen wir Ihnen daher, wie Sie asynchrone Operationen verwenden und HTMLDocument laden können, ohne den Hauptthread zu blockieren.
Der folgende Code demonstriert die Arbeit mit einem HTMLDocument in Java durch Abonnieren des Ereignisses OnReadyStateChange, das den Ladevorgang des Dokuments überwacht. Sobald das Dokument den Status “complete” erreicht, ruft es mit der Methode getOuterHTML() das vollständige HTML-Markup des Stammelements des Dokuments ab und speichert es in einem StringBuilder. Um sicherzustellen, dass das Dokument genügend Zeit zum Laden hat und der Ereignishandler ausgeführt werden kann, pausiert das Programm die Ausführung für 5 Sekunden mit Thread.sleep(5000). Anschließend gibt es das erfasste HTML in der Konsole aus.
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);Im Gegensatz zum ersten Beispiel demonstriert das folgende Beispiel die asynchrone Navigation, indem ein Dokument von einer bestimmten URL geladen und wait/notify anstelle einer festen Verzögerung verwendet wird. Dieser Ansatz ist zuverlässiger, da er präzise reagiert, wenn das Dokument den Status “complete” erreicht, wodurch unnötiges Warten oder vorzeitige Ausführung vermieden wird.
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}Dieses Java-Beispiel definiert eine benutzerdefinierte Klasse HTMLDocumentWaiter, die Runnable implementiert, um HTML-Dokumente mithilfe der Bibliothek Aspose.HTML for Java asynchron zu bearbeiten. Der Konstruktor akzeptiert eine Instanz von HTMLDocumentAsynchronouslyOnLoad und löst deren Ausführung in einem separaten Thread aus. In der Methode run() prüft der Code kontinuierlich, ob eine Nachricht von der asynchronen Operation empfangen wurde. Der Thread wird zwischen den Prüfungen für ein bestimmtes Intervall (Thread.sleep(60000)) angehalten. Sobald die Nachricht verfügbar ist oder der Thread unterbrochen wird, stoppt der Waiter. Dieser Ansatz ermöglicht die Überwachung des asynchronen Ladevorgangs parallel zum Hauptprogrammablauf.
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}Im folgenden Beispiel verwendet der Code das Ereignis OnLoad, anstatt auf ReadyState-Prüfungen oder manuelles Warten zurückzugreifen. Das Ereignis OnLoad wird automatisch ausgelöst, sobald das Dokument vollständig geladen ist. Dies macht diesen Ansatz einfacher und effizienter. Wenn das Ereignis ausgelöst wird, ruft das Programm das äußere HTML des Dokuments ab und gibt es in der Konsole aus. Diese Methode vermeidet unnötige Verzögerungen und Synchronisierungsprobleme und ermöglicht eine sauberere Arbeit mit asynchron geladenen HTML-Inhalten.
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");Schlussfolgerungen
Umfassende DOM-Manipulation: Die Klasse
HTMLDocumentbietet eine robuste und standardkonforme Möglichkeit, HTML-Dokumente programmatisch zu erstellen, zu verändern und zu manipulieren, gemäß den Spezifikationen des W3C und der WHATWG.Flexible Dokumentenerstellung und -ladung: Mithilfe von Konstruktoren können Entwickler Dokumente von Grund auf neu erstellen, HTML aus einer Vielzahl von Quellen (Dateien, URLs, Streams) laden oder Inhalte dynamisch generieren.
Erweiterte Unterstützung von Operationen: Funktionen wie asynchrones Laden und Ereignisbehandlung ermöglichen die nahtlose Integration ressourcenintensiver Vorgänge, ohne den Hauptanwendungsthread zu blockieren.
Formatübergreifende Kompatibilität: Die Bibliothek erweitert einige Funktionen von HTML auf andere Dokumentformate wie SVG, MHTML und EPUB und bietet so einen einheitlichen Ansatz für die Handhabung verschiedener Webinhalte.
Sie können die vollständigen Beispiele und Datendateien unter GitHub herunterladen.