Crear documento HTML – crear y cargar HTML en Java

Documento HTML

La clase HTMLDocument es un punto de partida para la biblioteca de clases Aspose.HTML for Java, que permite a los desarrolladores trabajar con contenido HTML mediante programación. La clase HTMLDocument representa una página HTML representada en un navegador y sirve como raíz del Modelo de objetos de documento (DOM).

Algunas características de HTMLDocument

El HTMLDocument proporciona una representación en memoria de un DOM HTML y se basa completamente en las especificaciones W3C DOM y WHATWG DOM compatibles con muchos navegadores modernos. Si está familiarizado con los estándares WHATWG DOM, WHATWG HTML y JavaScript, le resultará bastante cómodo utilizar Aspose.HTML for Java. De lo contrario, puedes visitar www.w3schools.com, donde puedes encontrar muchos ejemplos y tutoriales sobre cómo trabajar con documentos HTML.

Crear un documento HTML vacío

El siguiente fragmento de código muestra el uso del constructor predeterminado HTMLDocument() para crear un documento HTML vacío y guardarlo en un archivo.

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

Después de la creación, aparece el archivo create-empty-document.html con la estructura del documento inicial: el documento vacío incluye elementos como <html> <head> y <body>. Más detalles sobre cómo guardar archivos HTML se encuentran en el artículo Guardar documento HTML.

Estructura de archivo resultante:

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

Crear un nuevo documento HTML

Para generar un documento mediante programación desde cero, utilice el constructor HTMLDocument() sin parámetros, como se muestra en el fragmento de código anterior. Una vez creado el objeto del documento, se puede completar posteriormente con elementos HTML. Puede completar el documento con contenido, como crear un nodo de texto y agregarlo al cuerpo del documento:

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

Cargar HTML desde un archivo

El siguiente fragmento de código muestra cómo cargar el HTMLDocument desde un archivo existente:

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

Cargar HTML desde una URL

La clase HTMLDocument puede buscar y cargar contenido HTML desde una página web. En el siguiente fragmento de código puede ver cómo cargar una página web en HTMLDocument.

En caso de que pase una URL incorrecta a la que no se pueda acceder en este momento, la biblioteca genera la DOMException con el código especializado NetworkError para informarle que no se puede encontrar el recurso seleccionado.

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

Cargar HTML desde código HTML

Si prepara un código HTML como objetos en memoria Class String o Class InputStream, no necesita guardarlos en el archivo, simplemente pase su código HTML a constructores especializados. Para crear un documento a partir de una cadena, utilice el constructor HTMLDocument(content, baseUri) con el contenido HTML y un 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");

En caso de que su código HTML tenga los recursos vinculados (estilos, scripts, imágenes, etc.), debe pasar un parámetro baseUrl válido al constructor del documento. Se utilizará para resolver la ubicación del recurso durante la carga del documento.

Cargar HTML desde una secuencia

Para crear un documento HTML a partir de una secuencia, puede utilizar el constructor 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");

Trabajar con documentos SVG, MHTML y EPUB

Documento SVG

Dado que los gráficos vectoriales escalables (SVG) son parte de los estándares W3C y podrían integrarse en HTMLDocument, implementamos SVGDocument y toda su funcionalidad. Nuestra implementación se basa en la especificación oficial SVG2, por lo que puede cargar, leer y manipular documentos SVG como se describe oficialmente.

Dado que SVGDocument y HTMLDocument se basan en el mismo estándar WHATWG DOM, todas las operaciones como cargar, leer, editar, convertir y guardar son similares para ambos documentos. Por lo tanto, todos los ejemplos en los que puede ver manipulación con HTMLDocument también son aplicables para SVGDocument.

El siguiente ejemplo le muestra cómo cargar el documento SVG desde la variable en memoria Class String:

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

Documento MHTML

MHTML (encapsulación MIME de documentos HTML agregados) es un formato especializado para crear archivos de páginas web. La biblioteca Aspose.HTML for Java admite MHTML, pero su funcionalidad actualmente se limita a convertir y representar operaciones de MHTML a otros formatos de salida compatibles. Para obtener más información, consulte el artículo Conversión entre formatos.

Documento EPUB

EPUB, un formato de publicación electrónica ampliamente utilizado para libros electrónicos, tiene limitaciones similares en la biblioteca Aspose.HTML for Java que MHTML. La biblioteca solo admite operaciones de renderizado desde EPUB a formatos de salida compatibles. Para obtener detalles adicionales, visite el artículo Conversión entre formatos.

Operaciones asincrónicas

Nos damos cuenta de que cargar un documento puede ser una operación que consume muchos recursos, ya que es necesario cargar no solo el documento en sí, sino también todos los recursos vinculados y procesar todos los scripts. Entonces, en los siguientes fragmentos de código, le mostramos cómo usar operaciones asincrónicas y cargar HTMLDocument sin bloquear el hilo principal.

El siguiente código demuestra cómo trabajar con un HTMLDocument en Java suscribiéndose al evento OnReadyStateChange, que monitoriza el proceso de carga del documento. Cuando el documento alcanza el estado “complete”, recupera el marcado HTML completo del elemento raíz mediante el método getOuterHTML() y lo almacena en un StringBuilder. Para garantizar que el documento tenga tiempo suficiente para cargarse y que el controlador de eventos pueda ejecutarse, el programa pausa la ejecución durante 5 segundos mediante Thread.sleep(5000). Finalmente, imprime el HTML capturado en la consola.

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

A diferencia del primer ejemplo, el siguiente demuestra la navegación asíncrona cargando un documento desde una URL determinada y utilizando wait/notify en lugar de un retraso fijo. Este enfoque es más fiable porque reacciona con precisión cuando el documento alcanza el estado “complete”, evitando esperas innecesarias o ejecuciones prematuras.

 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}

Este ejemplo de Java define una clase HTMLDocumentWaiter personalizada que implementa Runnable para trabajar con documentos HTML de forma asíncrona mediante la biblioteca Aspose.HTML para Java. El constructor acepta una instancia de HTMLDocumentAsynchronouslyOnLoad y activa su ejecución en un hilo independiente. En el método run(), el código comprueba continuamente si se ha recibido un mensaje de la operación asíncrona, pausando el hilo durante un intervalo determinado Thread.sleep(60000) entre comprobaciones. Una vez que el mensaje está disponible o el hilo se interrumpe, el proceso de espera se detiene. Este enfoque permite supervisar el proceso de carga asíncrona en paralelo con el flujo principal del programa.

 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}

En el siguiente ejemplo, el código utiliza el evento OnLoad en lugar de depender de comprobaciones de ReadyState o de esperas manuales. El evento OnLoad se activa automáticamente una vez que el documento termina de cargarse, lo que simplifica y optimiza este enfoque. Al activarse el evento, el programa recupera el HTML externo del documento y lo imprime en la consola. Este método evita retrasos innecesarios y problemas de sincronización, proporcionando una forma más limpia de trabajar con contenido HTML cargado de forma asincrónica.

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

Conclusiones

  1. Manipulación DOM integral: la clase HTMLDocument proporciona una forma sólida y compatible con los estándares de crear, modificar y manipular documentos HTML mediante programación, siguiendo las especificaciones W3C y WHATWG.

  2. Creación y carga de documentos flexibles: mediante constructores, los desarrolladores pueden crear documentos desde cero, cargar HTML desde una variedad de fuentes (archivos, URL, secuencias) o generar contenido dinámicamente.

  3. Soporte de operaciones avanzadas: características como la carga asincrónica y el manejo de eventos permiten una integración perfecta de operaciones que consumen muchos recursos sin bloquear el hilo principal de la aplicación.

  4. Compatibilidad entre formatos: la biblioteca extiende algunas funciones HTML a otros formatos de documentos como SVG, MHTML y EPUB, ofreciendo un enfoque unificado para manejar contenido web diverso.

Puede descargar los ejemplos completos y los archivos de datos desde GitHub.

Subscribe to Aspose Product Updates

Get monthly newsletters & offers directly delivered to your mailbox.