Create HTML Document – Create, Load HTML in Java

HTML Document

The HTMLDocument class is a starting point for the Aspose.HTML for Java library, allowing developers to work with HTML content programmatically. The HTMLDocument class represents an HTML page as rendered in a browser, serving as the root of the Document Object Model (DOM).

Some HTMLDocument features

Flexible constructors support creating an HTML document from a file, URL, stream, or string.
HTMLDocument provides an in-memory representation that ensures the full DOM structure for manipulation.
Event handling includes support for DOM events for asynchronous operations.

The HTMLDocument provides an in-memory representation of an HTML DOM and is entirely based on W3C DOM and WHATWG DOM specifications supported by many modern browsers. If you are familiar with WHATWG DOM, WHATWG HTML, and JavaScript standards, you will find it quite comfy to use the Aspose.HTML for Java. Otherwise, you can visit www.w3schools.com, where you can find many examples and tutorials on how to work with HTML documents.

Create an Empty HTML Document

The following code snippet shows the usage of the default HTMLDocument() constructor to create an empty HTML document and save it to a file.

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($o("create-empty-document.html"));

Example_CreateEmptyHtmlDocument.java hosted with ❤ by GitHub

After the creation, file create-empty-document.html appears with the initial document structure: the empty document includes elements such as <html> <head> and <body>. More details about HTML files saving are in the Save HTML Document article.

Resulting File Structure:

1<html>
2    <head></head>
3    <body></body>
4</html>

Create a New HTML Document

To generate a document programmatically from scratch, use the HTMLDocument() constructor with no parameters, as shown in the code snippet above. Once the document object is created, it can be filled later with HTML elements. You can populate the document with content, such as creating a text node and adding it to the body of the 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($o("create-new-document.html"));

Example_CreateNewHtmlDocument.java hosted with ❤ by GitHub

Load HTML from a File

Following code snippet shows how to load the HTMLDocument from an existing file:

 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($o("load-from-file.html"))) {
 5    fileWriter.write("Hello, World!");
 6}
 7
 8// Load HTML from the file
 9HTMLDocument document = new HTMLDocument($o("load-from-file.html"));
10
11// Write the document content to the output stream
12System.out.println(document.getDocumentElement().getOuterHTML());

Example_LoadHtmlDocumentFromFile.java hosted with ❤ by GitHub

Load HTML from a URL

The HTMLDocument class can fetch and load HTML content from a web page. In the next code snippet you can see how to load a web page into HTMLDocument.

In case if you pass a wrong URL that can’t be reached right at the moment, the library throws the DOMException with specialized code NetworkError to inform you that the selected resource can not be found.

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());

Example_LoadHtmlDocumentFromUrl.java hosted with ❤ by GitHub

Load HTML from HTML Code

If you prepare an HTML code as an in-memory Class String or Class InputStream objects, you don’t need to save them to the file, simply pass your HTML code into specialized constructors. To create a document from a string, use the constructor HTMLDocument(content, baseUri) with the HTML content and a 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($o("create-from-string.html"));

Example_CreateHtmlDocumentFromString.java hosted with ❤ by GitHub

In case your HTML code has the linked resources (styles, scripts, images, etc.), you need to pass a valid baseUrl parameter to the constructor of the document. It will be used to resolve the location of the resource during the document loading.

Load HTML from a Stream

To create an HTML document from a stream, you can use the HTMLDocument(stream, string) constructor:

 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($o("load-from-stream.html"));

Example_LoadHtmlDocumentFromStream.java hosted with ❤ by GitHub

Working with SVG, MHTML, and EPUB Documents

SVG Document

Since Scalable Vector Graphics (SVG) is a part of W3C standards and could be embedded into HTMLDocument, we implemented SVGDocument and all its functionality. Our implementation is based on official SVG2 specification, so you can load, read, manipulate SVG documents as it described officially.

Since SVGDocument and HTMLDocument are based on the same WHATWG DOM standard, the all operations such as loading, reading, editing, converting and saving are similar for both documents. So, the all examples where you can see manipulation with HTMLDocument are applicable for SVGDocument as well.

The example below shows you how to load the SVG Document from the in-memory Class String variable:

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());

Example_LoadSvgDocumentFromString.java hosted with ❤ by GitHub

MHTML Document

MHTML (MIME encapsulation of aggregate HTML documents) is a specialized format for creating web page archives. The Aspose.HTML for Java library supports MHTML, but its functionality is currently limited to converting and rendering operations from MHTML to other supported output formats. For more information, refer to the Converting Between Formats article.

EPUB Document

EPUB, an electronic publication format widely used for eBooks, has similar limitations in the Aspose.HTML for Java library as MHTML. The library supports only rendering operations from EPUB to supported output formats. For additional details, visit the Converting Between Formats article.

Asynchronous Operations

We realize that loading a document could be a resource-intensive operation since it’s required loading not only the document itself but all linked resources and processing all scripts. So, in the following code snippets, we show you how to use asynchronous operations and load HTMLDocument without blocking the main thread:

 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);

Example_LoadDocument_Async.java hosted with ❤ by GitHub

ReadyStateChange is not the only event that can used to handle an async loading operation, you can also subscribe for Load event, as it follows:

 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}

Example_CreatingADocument_HTMLDocumentAsynchronouslyOnReadyStateChange.java hosted with ❤ by GitHub

The following Java code example uses the HTMLDocumentWaiter class in the context of working with HTML documents asynchronously in the Aspose.HTML for Java library. The HTMLDocumentWaiter class provides constructors and methods that execute the asynchronous loading operation in a separate thread and waits until either the loading is finished or the current thread is interrupted. Let’s see what the code does:

 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}

Example_HtmlDocumentAsyncWaiterThread.java hosted with ❤ by GitHub

The following code snippet describes the SimpleWait class, which contains the main() method that serves as the entry point for a Java application. Inside the main() method, an html instance of the class Examples_Java_WorkingWithDocuments_CreatingADocument_HTMLDocumentAsynchronouslyOnLoad is created. It is responsible for loading the HTML document asynchronously and creates an HTMLDocumentWaiter object to wait for the loading to complete. Finally, it starts a new thread to execute the waiting process:

 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");

Example_UsingAsynchronousOperationsOnLoad.java hosted with ❤ by GitHub

Conclusions

Comprehensive DOM manipulation: The HTMLDocument class provides a robust and standards-compliant way to create, modify, and manipulate HTML documents programmatically, following W3C and WHATWG specifications.
Flexible document creation and loading: Using constructors, developers can create documents from scratch, load HTML from a variety of sources (files, URLs, streams), or dynamically generate content.
Advanced operations support: Features such as asynchronous loading and event handling enable seamless integration of resource-intensive operations without blocking the main application thread.
Cross-format compatibility: The library extends some functionality HTML to other document formats such as SVG, MHTML, and EPUB, offering a unified approach to handling diverse web content.

You can download the complete examples and data files from GitHub.

Working with HTML Documents Edit HTML Document